permissionless 0.2.25 → 0.2.27

package/utils/decode7579Calls.ts

@@ -0,0 +1,133 @@
+import {
+    type Address,
+    type Hex,
+    decodeAbiParameters,
+    decodeFunctionData,
+    getAddress,
+    size,
+    slice
+} from "viem"
+import type {
+    CallType,
+    ExecutionMode
+} from "../actions/erc7579/supportsExecutionMode.js"
+
+export type DecodeCallDataReturnType = {
+    mode: ExecutionMode<CallType>
+    callData: readonly {
+        to: Address
+        value?: bigint | undefined
+        data?: Hex | undefined
+    }[]
+}
+
+export function decode7579Calls(callData: Hex): DecodeCallDataReturnType {
+    const executeAbi = [
+        {
+            type: "function",
+            name: "execute",
+            inputs: [
+                {
+                    name: "execMode",
+                    type: "bytes32",
+                    internalType: "ExecMode"
+                },
+                {
+                    name: "executionCalldata",
+                    type: "bytes",
+                    internalType: "bytes"
+                }
+            ],
+            outputs: [],
+            stateMutability: "payable"
+        }
+    ] as const
+
+    const decoded = decodeFunctionData({
+        abi: executeAbi,
+        data: callData
+    })
+
+    const mode = decoded.args[0]
+    const executionCalldata = decoded.args[1]
+
+    const callType = slice(mode, 0, 1) // First byte
+    const revertOnError = slice(mode, 1, 2) // Second byte
+    const selector = slice(mode, 3, 7) as Hex // bytes 5-8
+    const context = slice(mode, 7) as Hex // bytes 9-32
+
+    let type: CallType
+    switch (BigInt(callType)) {
+        case BigInt(0x00):
+            type = "call"
+            break
+        case BigInt(0x01):
+            type = "batchcall"
+            break
+        case BigInt(0xff):
+            type = "delegatecall"
+            break
+        default:
+            throw new Error("Invalid call type")
+    }
+
+    const decodedMode: ExecutionMode<CallType> = {
+        type,
+        revertOnError: BigInt(revertOnError) === BigInt(1),
+        selector,
+        context
+    }
+
+    if (decodedMode.type === "batchcall") {
+        const [calls] = decodeAbiParameters(
+            [
+                {
+                    name: "executionBatch",
+                    type: "tuple[]",
+                    components: [
+                        {
+                            name: "target",
+                            type: "address"
+                        },
+                        {
+                            name: "value",
+                            type: "uint256"
+                        },
+                        {
+                            name: "callData",
+                            type: "bytes"
+                        }
+                    ]
+                }
+            ],
+            executionCalldata
+        )
+
+        return {
+            mode: decodedMode,
+            callData: calls.map((call) => ({
+                to: call.target,
+                value: call.value,
+                data: call.callData
+            }))
+        }
+    }
+
+    // Single call - calldata is encoded as concatenated (to, value, data)
+    const to = getAddress(slice(executionCalldata, 0, 20)) // 20 bytes address with 0x prefix
+    const value = BigInt(slice(executionCalldata, 20, 52)) // 32 bytes value
+
+    const data =
+        size(executionCalldata) > 52 ? slice(executionCalldata, 52) : "0x" // Remaining bytes are calldata
+
+    return {
+        mode: decodedMode,
+        callData: [
+            {
+                to,
+                value,
+                data
+            }
+        ]
+    }
+}

package/utils/getEstimationCallData.ts

@@ -0,0 +1,279 @@
+import { type Address, type Hex, encodeFunctionData } from "viem"
+import {
+    type UserOperation,
+    entryPoint06Abi,
+    toPackedUserOperation
+} from "viem/account-abstraction"
+
+function getPimlicoEstimationCallData06({
+    userOperation,
+    entrypoint
+}: {
+    userOperation: UserOperation<"0.6">
+    entrypoint: {
+        address: Address
+        version: "0.6"
+    }
+}): { to: Address; data: Hex } {
+    return {
+        to: entrypoint.address,
+        data: encodeFunctionData({
+            abi: entryPoint06Abi,
+            functionName: "simulateHandleOp",
+            args: [
+                {
+                    callData: userOperation.callData,
+                    callGasLimit: userOperation.callGasLimit,
+                    initCode: userOperation.initCode ?? "0x",
+                    maxFeePerGas: userOperation.maxFeePerGas,
+                    maxPriorityFeePerGas: userOperation.maxPriorityFeePerGas,
+                    nonce: userOperation.nonce,
+                    paymasterAndData: userOperation.paymasterAndData ?? "0x",
+                    preVerificationGas: userOperation.preVerificationGas,
+                    sender: userOperation.sender,
+                    signature: userOperation.signature,
+                    verificationGasLimit: userOperation.verificationGasLimit
+                },
+                "0x",
+                "0x"
+            ]
+        })
+    }
+}
+
+function encodeSimulateHandleOpLast({
+    userOperation
+}: {
+    userOperation: UserOperation<"0.7">
+}): Hex {
+    const userOperations = [userOperation]
+    const packedUserOperations = userOperations.map((uop) => ({
+        packedUserOperation: toPackedUserOperation(uop)
+    }))
+
+    const simulateHandleOpCallData = encodeFunctionData({
+        abi: [
+            {
+                type: "function",
+                name: "simulateHandleOpLast",
+                inputs: [
+                    {
+                        name: "ops",
+                        type: "tuple[]",
+                        internalType: "struct PackedUserOperation[]",
+                        components: [
+                            {
+                                name: "sender",
+                                type: "address",
+                                internalType: "address"
+                            },
+                            {
+                                name: "nonce",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "initCode",
+                                type: "bytes",
+                                internalType: "bytes"
+                            },
+                            {
+                                name: "callData",
+                                type: "bytes",
+                                internalType: "bytes"
+                            },
+                            {
+                                name: "accountGasLimits",
+                                type: "bytes32",
+                                internalType: "bytes32"
+                            },
+                            {
+                                name: "preVerificationGas",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "gasFees",
+                                type: "bytes32",
+                                internalType: "bytes32"
+                            },
+                            {
+                                name: "paymasterAndData",
+                                type: "bytes",
+                                internalType: "bytes"
+                            },
+                            {
+                                name: "signature",
+                                type: "bytes",
+                                internalType: "bytes"
+                            }
+                        ]
+                    }
+                ],
+                outputs: [
+                    {
+                        name: "",
+                        type: "tuple",
+                        internalType:
+                            "struct IEntryPointSimulations.ExecutionResult",
+                        components: [
+                            {
+                                name: "preOpGas",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "paid",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "accountValidationData",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "paymasterValidationData",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "paymasterVerificationGasLimit",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "paymasterPostOpGasLimit",
+                                type: "uint256",
+                                internalType: "uint256"
+                            },
+                            {
+                                name: "targetSuccess",
+                                type: "bool",
+                                internalType: "bool"
+                            },
+                            {
+                                name: "targetResult",
+                                type: "bytes",
+                                internalType: "bytes"
+                            }
+                        ]
+                    }
+                ],
+                stateMutability: "nonpayable"
+            }
+        ],
+        functionName: "simulateHandleOpLast",
+        args: [packedUserOperations.map((uop) => uop.packedUserOperation)]
+    })
+
+    return simulateHandleOpCallData
+}
+
+const PIMLICO_ESTIMATION_ADDRESS = "0x949CeCa936909f75E5A40bD285d9985eFBb9B0D3"
+
+function getPimlicoEstimationCallData07({
+    userOperation,
+    estimationAddress,
+    entrypoint
+}: {
+    userOperation: UserOperation<"0.7">
+    estimationAddress?: Address
+    entrypoint: {
+        address: Address
+        version: "0.7"
+    }
+}): { to: Address; data: Hex } {
+    const simulateHandleOpLast = encodeSimulateHandleOpLast({
+        userOperation
+    })
+
+    return {
+        to: estimationAddress ?? PIMLICO_ESTIMATION_ADDRESS,
+        data: encodeFunctionData({
+            abi: [
+                {
+                    inputs: [
+                        {
+                            internalType: "address payable",
+                            name: "ep",
+                            type: "address"
+                        },
+                        {
+                            internalType: "bytes[]",
+                            name: "data",
+                            type: "bytes[]"
+                        }
+                    ],
+                    name: "simulateEntryPoint",
+                    outputs: [
+                        {
+                            internalType: "bytes[]",
+                            name: "",
+                            type: "bytes[]"
+                        }
+                    ],
+                    stateMutability: "nonpayable",
+                    type: "function"
+                }
+            ],
+            functionName: "simulateEntryPoint",
+            args: [entrypoint.address, [simulateHandleOpLast]]
+        })
+    }
+}
+
+export type GetPimlicoEstimationCallDataParams<
+    entryPointVersion extends "0.6" | "0.7"
+> = {
+    userOperation: UserOperation<entryPointVersion>
+    entrypoint: {
+        address: Address
+        version: entryPointVersion
+    }
+} & (entryPointVersion extends "0.6"
+    ? {
+          estimationAddress: never
+      }
+    : { estimationAddress?: Address })
+
+function isEntryPoint06(
+    args: GetPimlicoEstimationCallDataParams<"0.6" | "0.7">
+): args is GetPimlicoEstimationCallDataParams<"0.6"> {
+    return args.entrypoint.version === "0.6"
+}
+
+function isEntryPoint07(
+    args: GetPimlicoEstimationCallDataParams<"0.6" | "0.7">
+): args is GetPimlicoEstimationCallDataParams<"0.7"> {
+    return args.entrypoint.version === "0.7"
+}
+
+export function getPimlicoEstimationCallData<
+    entryPointVersion extends "0.6" | "0.7"
+>(
+    args: GetPimlicoEstimationCallDataParams<entryPointVersion>
+): { to: Address; data: Hex } {
+    if (isEntryPoint06(args)) {
+        return getPimlicoEstimationCallData06({
+            userOperation: args.userOperation,
+            entrypoint: {
+                address: args.entrypoint.address,
+                version: "0.6"
+            }
+        })
+    }
+
+    if (isEntryPoint07(args)) {
+        return getPimlicoEstimationCallData07({
+            userOperation: args.userOperation,
+            estimationAddress: args.estimationAddress,
+            entrypoint: {
+                address: args.entrypoint.address,
+                version: "0.7"
+            }
+        })
+    }
+
+    throw new Error("Invalid entrypoint version")
+}

package/utils/index.ts

@@ -20,6 +20,12 @@ import {
     type EncodeCallDataParams,
     encode7579Calls
 } from "./encode7579Calls.js"
+
+import {
+    type DecodeCallDataReturnType,
+    decode7579Calls
+} from "./decode7579Calls.js"
+
 import {
     type Erc20AllowanceOverrideParameters,
     erc20AllowanceOverride
@@ -44,6 +50,8 @@ export {
     encodeInstallModule,
     type EncodeCallDataParams,
     encode7579Calls,
+    decode7579Calls,
+    type DecodeCallDataReturnType,
     erc20AllowanceOverride,
     erc20BalanceOverride,
     type Erc20AllowanceOverrideParameters,