@pimlico/alto 0.0.18 → 0.0.20

package/esm/utils/userop.js

@@ -1,35 +1,31 @@
-import { EntryPointV06Abi, EntryPointV07Abi, logSchema, receiptSchema } from "../types/index.js";
-import * as sentry from "@sentry/node";
-import { concat, decodeErrorResult, decodeEventLog, encodeAbiParameters, encodeEventTopics, getAddress, keccak256, pad, parseAbi, parseEventLogs, size, slice, toHex, zeroAddress } from "viem";
+import { logSchema, receiptSchema } from "../types/index.js";
+import { decodeEventLog, getAbiItem, getAddress, size, slice, toHex, zeroAddress } from "viem";
+import { entryPoint07Abi, getUserOperationHash, toPackedUserOperation } from "viem/account-abstraction";
 import { z } from "zod";
-import { fromZodError } from "zod-validation-error";
-import { areAddressesEqual, getAuthorizationStateOverrides } from "./helpers.js";
-// Type predicate check if the UserOperation is V06.
+import { getEip7702AuthAddress } from "./eip7702.js";
+// Type predicate check if the UserOperation is v0.6
 export function isVersion06(operation) {
     return "initCode" in operation && "paymasterAndData" in operation;
 }
-// Type predicate to check if the UserOperation is V07.
+// Type predicate to check if the UserOperation is v0.7
 export function isVersion07(operation) {
     return "factory" in operation && "paymaster" in operation;
 }
-// Type predicate to check if the UserOperation is V07.
+// Type predicate to check if the UserOperation is v0.8
 export function isVersion08(operation, entryPointAddress) {
-    return entryPointAddress.startsWith("0x4337");
+    return entryPointAddress.startsWith("0x433708");
 }
-export function getInitCode(unpackedUserOperation) {
-    return unpackedUserOperation.factory
-        ? concat([
-            unpackedUserOperation.factory === "0x7702"
-                ? pad(unpackedUserOperation.factory, {
-                    dir: "right",
-                    size: 20
-                })
-                : unpackedUserOperation.factory,
-            unpackedUserOperation.factoryData || "0x"
-        ])
-        : "0x";
+// Type predicate to check if the UserOperation is v0.9
+export function isVersion09(operation, entryPointAddress) {
+    return entryPointAddress.startsWith("0x433709");
 }
-export function unPackInitCode(initCode) {
+// Check if a userOperation is a deployment operation
+export function isDeployment(userOp) {
+    const isDeployment06 = isVersion06(userOp) && !!userOp.initCode && userOp.initCode !== "0x";
+    const isDeployment07 = isVersion07(userOp) && !!userOp.factory && userOp.factory !== "0x";
+    return isDeployment06 || isDeployment07;
+}
+function unPackInitCode(initCode) {
     if (initCode === "0x") {
         return {
             factory: null,
@@ -41,49 +37,19 @@ export function unPackInitCode(initCode) {
         factoryData: size(initCode) > 20 ? slice(initCode, 20) : null
     };
 }
-export function getAccountGasLimits(unpackedUserOperation) {
-    return concat([
-        pad(toHex(unpackedUserOperation.verificationGasLimit), {
-            size: 16
-        }),
-        pad(toHex(unpackedUserOperation.callGasLimit), { size: 16 })
-    ]);
-}
-export function unpackAccountGasLimits(accountGasLimits) {
+function unpackAccountGasLimits(accountGasLimits) {
     return {
         verificationGasLimit: BigInt(slice(accountGasLimits, 0, 16)),
         callGasLimit: BigInt(slice(accountGasLimits, 16))
     };
 }
-export function getGasLimits(unpackedUserOperation) {
-    return concat([
-        pad(toHex(unpackedUserOperation.maxPriorityFeePerGas), {
-            size: 16
-        }),
-        pad(toHex(unpackedUserOperation.maxFeePerGas), { size: 16 })
-    ]);
-}
-export function unpackGasLimits(gasLimits) {
+function unpackGasLimits(gasLimits) {
     return {
         maxPriorityFeePerGas: BigInt(slice(gasLimits, 0, 16)),
         maxFeePerGas: BigInt(slice(gasLimits, 16))
     };
 }
-export function getPaymasterAndData(unpackedUserOperation) {
-    return unpackedUserOperation.paymaster
-        ? concat([
-            unpackedUserOperation.paymaster,
-            pad(toHex(unpackedUserOperation.paymasterVerificationGasLimit || 0n), {
-                size: 16
-            }),
-            pad(toHex(unpackedUserOperation.paymasterPostOpGasLimit || 0n), {
-                size: 16
-            }),
-            unpackedUserOperation.paymasterData || "0x"
-        ])
-        : "0x";
-}
-export function unpackPaymasterAndData(paymasterAndData) {
+function unpackPaymasterAndData(paymasterAndData) {
     if (paymasterAndData === "0x") {
         return {
             paymaster: null,
@@ -100,18 +66,28 @@ export function unpackPaymasterAndData(paymasterAndData) {
         paymasterData: paymasterAndDataSize > 52 ? slice(paymasterAndData, 52) : null
     };
 }
-export function toPackedUserOperation(unpackedUserOperation) {
-    return {
-        sender: unpackedUserOperation.sender,
-        nonce: unpackedUserOperation.nonce,
-        initCode: getInitCode(unpackedUserOperation),
-        callData: unpackedUserOperation.callData,
-        accountGasLimits: getAccountGasLimits(unpackedUserOperation),
-        preVerificationGas: unpackedUserOperation.preVerificationGas,
-        gasFees: getGasLimits(unpackedUserOperation),
-        paymasterAndData: getPaymasterAndData(unpackedUserOperation),
-        signature: unpackedUserOperation.signature
+// Convert Alto's UserOperation07/08/09 (with null) to viem's format (with undefined)
+export function toViemUserOp(userOp) {
+    const base = {
+        ...userOp,
+        paymaster: userOp.paymaster ?? undefined,
+        paymasterData: userOp.paymasterData ?? undefined,
+        paymasterVerificationGasLimit: userOp.paymasterVerificationGasLimit ?? undefined,
+        paymasterPostOpGasLimit: userOp.paymasterPostOpGasLimit ?? undefined,
+        factory: userOp.factory ?? undefined,
+        factoryData: userOp.factoryData ?? undefined
     };
+    // UserOperation09 has paymasterSignature field
+    if ("paymasterSignature" in userOp) {
+        return {
+            ...base,
+            paymasterSignature: userOp.paymasterSignature ?? undefined
+        };
+    }
+    return base;
+}
+export function toPackedUserOp(unpacked) {
+    return toPackedUserOperation(toViemUserOp(unpacked));
 }
 // biome-ignore lint/suspicious/noExplicitAny: it's a generic type
 export function deepHexlify(obj) {
@@ -146,425 +122,217 @@ export function getAddressFromInitCodeOrPaymasterAndData(data) {
     }
     return null;
 }
-// Return the status of the bundling transaction.
-export const getBundleStatus = async ({ transactionHash, publicClient, bundle, logger }) => {
-    try {
-        const { entryPoint, version } = bundle;
-        const isVersion06 = version === "0.6";
-        const receipt = await publicClient.getTransactionReceipt({
-            hash: transactionHash
-        });
-        const blockNumber = receipt.blockNumber;
-        if (receipt.status === "reverted") {
-            const bundlingStatus = {
-                status: "reverted",
-                isAA95: false
-            };
-            if ("error" in receipt) {
-                try {
-                    const match = receipt.error.match(/0x([a-fA-F0-9]+)?/);
-                    if (match) {
-                        const revertReason = match[0];
-                        const decoded = decodeErrorResult({
-                            data: revertReason,
-                            abi: parseAbi([
-                                "error FailedOp(uint256 opIndex, string reason)"
-                            ])
-                        });
-                        if (decoded.args[1] === "AA95 out of gas") {
-                            bundlingStatus.isAA95 = true;
-                        }
-                    }
-                }
-                catch (e) {
-                    logger.error("Failed to decode userOperation revert reason due to ", e);
-                }
+export function getUserOpHash({ userOp, entryPointAddress, chainId }) {
+    if (isVersion09(userOp, entryPointAddress)) {
+        const authorization = userOp.eip7702Auth
+            ? {
+                address: getEip7702AuthAddress(userOp.eip7702Auth),
+                chainId: userOp.eip7702Auth.chainId,
+                nonce: userOp.eip7702Auth.nonce,
+                r: userOp.eip7702Auth.r,
+                s: userOp.eip7702Auth.s,
+                yParity: userOp.eip7702Auth.yParity,
+                v: userOp.eip7702Auth.v
             }
-            return { bundlingStatus, blockNumber };
-        }
-        const userOperationDetails = receipt.logs
-            .filter((log) => areAddressesEqual(log.address, entryPoint))
-            .reduce((result, log) => {
-            try {
-                const { data, topics } = log;
-                const { eventName, args } = decodeEventLog({
-                    abi: isVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
-                    data,
-                    topics
-                });
-                if (eventName === "AccountDeployed" ||
-                    eventName === "UserOperationRevertReason" ||
-                    eventName === "UserOperationEvent") {
-                    const opHash = args.userOpHash;
-                    // create result entry if doesn't exist
-                    result[opHash] ??= {
-                        accountDeployed: false,
-                        status: "succesful"
-                    };
-                    switch (eventName) {
-                        case "AccountDeployed": {
-                            result[opHash].accountDeployed = true;
-                            break;
-                        }
-                        case "UserOperationRevertReason": {
-                            result[opHash].revertReason = args.revertReason;
-                            break;
-                        }
-                        case "UserOperationEvent": {
-                            const status = args.success
-                                ? "succesful"
-                                : "calldata_phase_reverted";
-                            result[opHash].status = status;
-                            break;
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                sentry.captureException(e);
+            : undefined;
+        return getUserOperationHash({
+            chainId,
+            entryPointAddress,
+            entryPointVersion: "0.9",
+            userOperation: {
+                ...toViemUserOp(userOp),
+                authorization
             }
-            return result;
-        }, {});
-        return {
-            bundlingStatus: {
-                status: "included",
-                userOperationDetails
-            },
-            blockNumber
-        };
-    }
-    catch {
-        return {
-            bundlingStatus: {
-                status: "not_found"
-            },
-            blockNumber: undefined
-        };
+        });
     }
-};
-export const getUserOperationHashV06 = ({ userOperation, entryPointAddress, chainId }) => {
-    const hash = keccak256(encodeAbiParameters([
-        {
-            name: "sender",
-            type: "address"
-        },
-        {
-            name: "nonce",
-            type: "uint256"
-        },
-        {
-            name: "initCodeHash",
-            type: "bytes32"
-        },
-        {
-            name: "callDataHash",
-            type: "bytes32"
-        },
-        {
-            name: "callGasLimit",
-            type: "uint256"
-        },
-        {
-            name: "verificationGasLimit",
-            type: "uint256"
-        },
-        {
-            name: "preVerificationGas",
-            type: "uint256"
-        },
-        {
-            name: "maxFeePerGas",
-            type: "uint256"
-        },
-        {
-            name: "maxPriorityFeePerGas",
-            type: "uint256"
-        },
-        {
-            name: "paymasterAndDataHash",
-            type: "bytes32"
-        }
-    ], [
-        userOperation.sender,
-        userOperation.nonce,
-        keccak256(userOperation.initCode),
-        keccak256(userOperation.callData),
-        userOperation.callGasLimit,
-        userOperation.verificationGasLimit,
-        userOperation.preVerificationGas,
-        userOperation.maxFeePerGas,
-        userOperation.maxPriorityFeePerGas,
-        keccak256(userOperation.paymasterAndData)
-    ]));
-    return keccak256(encodeAbiParameters([
-        {
-            name: "userOpHash",
-            type: "bytes32"
-        },
-        {
-            name: "entryPointAddress",
-            type: "address"
-        },
-        {
-            name: "chainId",
-            type: "uint256"
-        }
-    ], [hash, entryPointAddress, BigInt(chainId)]));
-};
-export const getUserOperationHashV07 = ({ userOperation, entryPointAddress, chainId }) => {
-    const hash = keccak256(encodeAbiParameters([
-        {
-            name: "sender",
-            type: "address"
-        },
-        {
-            name: "nonce",
-            type: "uint256"
-        },
-        {
-            name: "initCodeHash",
-            type: "bytes32"
-        },
-        {
-            name: "callDataHash",
-            type: "bytes32"
-        },
-        {
-            name: "accountGasLimits",
-            type: "bytes32"
-        },
-        {
-            name: "preVerificationGas",
-            type: "uint256"
-        },
-        {
-            name: "gasFees",
-            type: "bytes32"
-        },
-        {
-            name: "paymasterAndDataHash",
-            type: "bytes32"
-        }
-    ], [
-        userOperation.sender,
-        userOperation.nonce,
-        keccak256(userOperation.initCode),
-        keccak256(userOperation.callData),
-        userOperation.accountGasLimits,
-        userOperation.preVerificationGas,
-        userOperation.gasFees,
-        keccak256(userOperation.paymasterAndData)
-    ]));
-    return keccak256(encodeAbiParameters([
-        {
-            name: "userOpHash",
-            type: "bytes32"
-        },
-        {
-            name: "entryPointAddress",
-            type: "address"
-        },
-        {
-            name: "chainId",
-            type: "uint256"
-        }
-    ], [hash, entryPointAddress, BigInt(chainId)]));
-};
-export const getUserOperationHashV08 = async ({ userOperation, entryPointAddress, publicClient }) => {
-    const packedUserOp = toPackedUserOperation(userOperation);
-    // : concat(["0xef0100", code ?? "0x"])
-    const stateOverrides = getAuthorizationStateOverrides({
-        userOperations: [userOperation]
-    });
-    const hash = await publicClient.readContract({
-        address: entryPointAddress,
-        abi: [
-            {
-                inputs: [
-                    {
-                        components: [
-                            { name: "sender", type: "address" },
-                            { name: "nonce", type: "uint256" },
-                            { name: "initCode", type: "bytes" },
-                            { name: "callData", type: "bytes" },
-                            { name: "accountGasLimits", type: "bytes32" },
-                            { name: "preVerificationGas", type: "uint256" },
-                            { name: "gasFees", type: "bytes32" },
-                            { name: "paymasterAndData", type: "bytes" },
-                            { name: "signature", type: "bytes" }
-                        ],
-                        name: "userOp",
-                        type: "tuple"
-                    }
-                ],
-                name: "getUserOpHash",
-                outputs: [{ name: "", type: "bytes32" }],
-                stateMutability: "view",
-                type: "function"
+    if (isVersion08(userOp, entryPointAddress)) {
+        const authorization = userOp.eip7702Auth
+            ? {
+                address: getEip7702AuthAddress(userOp.eip7702Auth),
+                chainId: userOp.eip7702Auth.chainId,
+                nonce: userOp.eip7702Auth.nonce,
+                r: userOp.eip7702Auth.r,
+                s: userOp.eip7702Auth.s,
+                yParity: userOp.eip7702Auth.yParity,
+                v: userOp.eip7702Auth.v
             }
-        ],
-        functionName: "getUserOpHash",
-        args: [packedUserOp],
-        stateOverride: [
-            ...Object.keys(stateOverrides).map((address) => ({
-                address: address,
-                code: stateOverrides[address]?.code ?? "0x"
-            }))
-        ]
-    });
-    return hash;
-};
-export const getUserOperationHash = ({ userOperation, entryPointAddress, chainId, publicClient }) => {
-    if (isVersion06(userOperation)) {
-        return getUserOperationHashV06({
-            userOperation,
+            : undefined;
+        return getUserOperationHash({
+            chainId,
             entryPointAddress,
-            chainId
+            entryPointVersion: "0.8",
+            userOperation: {
+                ...toViemUserOp(userOp),
+                authorization
+            }
         });
     }
-    if (isVersion08(userOperation, entryPointAddress)) {
-        return getUserOperationHashV08({
-            userOperation,
-            entryPointAddress,
+    if (isVersion07(userOp)) {
+        return getUserOperationHash({
             chainId,
-            publicClient
+            entryPointAddress,
+            entryPointVersion: "0.7",
+            userOperation: toViemUserOp(userOp)
         });
     }
-    return getUserOperationHashV07({
-        userOperation: toPackedUserOperation(userOperation),
+    return getUserOperationHash({
+        chainId,
         entryPointAddress,
-        chainId
+        entryPointVersion: "0.6",
+        userOperation: userOp
     });
-};
+}
 export const getNonceKeyAndSequence = (nonce) => {
     const nonceKey = nonce >> 64n; // first 192 bits of nonce
     const nonceSequence = nonce & 0xffffffffffffffffn; // last 64 bits of nonce
     return [nonceKey, nonceSequence];
 };
-export const encodeNonce = ({ nonceKey, nonceSequence }) => {
-    return (nonceKey << 64n) | nonceSequence;
-};
-export function toUnpackedUserOperation(packedUserOperation) {
-    const { factory, factoryData } = unPackInitCode(packedUserOperation.initCode);
-    const { callGasLimit, verificationGasLimit } = unpackAccountGasLimits(packedUserOperation.accountGasLimits);
-    const { maxFeePerGas, maxPriorityFeePerGas } = unpackGasLimits(packedUserOperation.gasFees);
-    const { paymaster, paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymasterData } = unpackPaymasterAndData(packedUserOperation.paymasterAndData);
+// Check if a userOperation has a paymaster
+export function hasPaymaster(userOp) {
+    if (isVersion06(userOp)) {
+        return !!userOp.paymasterAndData && userOp.paymasterAndData !== "0x";
+    }
+    return !!userOp.paymaster && userOp.paymaster !== "0x";
+}
+export function calculateRequiredPrefund(userOp) {
+    if (isVersion06(userOp)) {
+        const mul = hasPaymaster(userOp) ? 3n : 1n;
+        const requiredGas = userOp.callGasLimit +
+            userOp.verificationGasLimit * mul +
+            userOp.preVerificationGas;
+        return requiredGas * userOp.maxFeePerGas;
+    }
+    // v0.7/v0.8 logic: sum all gas limits directly
+    const paymasterVerificationGasLimit = userOp.paymasterVerificationGasLimit ?? 0n;
+    const paymasterPostOpGasLimit = userOp.paymasterPostOpGasLimit ?? 0n;
+    const requiredGas = userOp.verificationGasLimit +
+        userOp.callGasLimit +
+        paymasterVerificationGasLimit +
+        paymasterPostOpGasLimit +
+        userOp.preVerificationGas;
+    return requiredGas * userOp.maxFeePerGas;
+}
+export function toUnpackedUserOp(packedUserOp) {
+    const { factory, factoryData } = unPackInitCode(packedUserOp.initCode);
+    const { callGasLimit, verificationGasLimit } = unpackAccountGasLimits(packedUserOp.accountGasLimits);
+    const { maxFeePerGas, maxPriorityFeePerGas } = unpackGasLimits(packedUserOp.gasFees);
+    const { paymaster, paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymasterData } = unpackPaymasterAndData(packedUserOp.paymasterAndData);
     return {
-        sender: packedUserOperation.sender,
-        nonce: packedUserOperation.nonce,
+        sender: packedUserOp.sender,
+        nonce: packedUserOp.nonce,
         factory: factory,
         factoryData: factoryData,
-        callData: packedUserOperation.callData,
+        callData: packedUserOp.callData,
         callGasLimit: callGasLimit,
         verificationGasLimit: verificationGasLimit,
-        preVerificationGas: packedUserOperation.preVerificationGas,
+        preVerificationGas: packedUserOp.preVerificationGas,
         maxFeePerGas: maxFeePerGas,
         maxPriorityFeePerGas: maxPriorityFeePerGas,
         paymaster: paymaster,
         paymasterVerificationGasLimit: paymasterVerificationGasLimit,
         paymasterPostOpGasLimit: paymasterPostOpGasLimit,
         paymasterData: paymasterData,
-        signature: packedUserOperation.signature
+        signature: packedUserOp.signature
     };
 }
-export const getRequiredPrefund = (userOperation) => {
-    if (isVersion06(userOperation)) {
-        const op = userOperation;
-        const multiplier = (op.paymasterAndData?.length ?? 0) > 2 ? BigInt(3) : BigInt(1);
-        const requiredGas = op.callGasLimit +
-            op.verificationGasLimit * multiplier +
-            op.preVerificationGas;
-        return BigInt(requiredGas) * BigInt(op.maxFeePerGas);
-    }
-    const op = userOperation;
-    const requiredGas = op.verificationGasLimit +
-        op.callGasLimit +
-        (op.paymasterVerificationGasLimit || 0n) +
-        (op.paymasterPostOpGasLimit || 0n) +
-        op.preVerificationGas;
-    return requiredGas * op.maxFeePerGas;
-};
-export function parseUserOperationReceipt(userOpHash, receipt) {
-    const userOperationRevertReasonAbi = parseAbi([
-        "event UserOperationRevertReason(bytes32 indexed userOpHash, address indexed sender, uint256 nonce, bytes revertReason)"
-    ]);
-    const userOperationEventTopic = encodeEventTopics({
-        abi: EntryPointV06Abi,
-        eventName: "UserOperationEvent"
-    });
-    const userOperationRevertReasonTopicEvent = encodeEventTopics({
-        abi: userOperationRevertReasonAbi
-    })[0];
+export function parseUserOpReceipt(userOpHash, receipt) {
     let entryPoint = zeroAddress;
-    let revertReason = undefined;
+    let revertReason;
+    let userOpEventArgs;
     let startIndex = -1;
-    let endIndex = -1;
-    receipt.logs.forEach((log, index) => {
-        if (log?.topics[0] === userOperationEventTopic[0]) {
-            // process UserOperationEvent
-            if (log.topics[1] === userOpHash) {
-                // it's our userOpHash. save as end of logs array
-                endIndex = index;
-                entryPoint = log.address;
-            }
-            else if (endIndex === -1) {
-                // it's a different hash. remember it as beginning index, but only if we didn't find our end index yet.
+    let userOpEventIndex = -1;
+    // Find our UserOpEvent and determine the starting point for logs
+    for (let index = 0; index < receipt.logs.length; index++) {
+        const log = receipt.logs[index];
+        try {
+            const { eventName, args } = decodeEventLog({
+                abi: [
+                    getAbiItem({
+                        abi: entryPoint07Abi,
+                        name: "UserOperationEvent"
+                    }),
+                    getAbiItem({
+                        abi: entryPoint07Abi,
+                        name: "UserOperationRevertReason"
+                    }),
+                    getAbiItem({
+                        abi: entryPoint07Abi,
+                        name: "BeforeExecution"
+                    })
+                ],
+                data: log.data,
+                topics: log.topics
+            });
+            if (eventName === "BeforeExecution") {
+                // BeforeExecution is emitted once and before individually executing UserOperations.
                 startIndex = index;
             }
-        }
-        if (log?.topics[0] === userOperationRevertReasonTopicEvent) {
-            // process UserOperationRevertReason
-            if (log.topics[1] === userOpHash) {
-                // it's our userOpHash. capture revert reason.
-                const decodedLog = decodeEventLog({
-                    abi: userOperationRevertReasonAbi,
-                    data: log.data,
-                    topics: log.topics
-                });
-                revertReason = decodedLog.args.revertReason;
+            if (eventName === "UserOperationRevertReason" &&
+                args.userOpHash === userOpHash) {
+                revertReason = args.revertReason;
+            }
+            if (eventName === "UserOperationEvent") {
+                if (args.userOpHash === userOpHash) {
+                    userOpEventIndex = index;
+                    entryPoint = log.address;
+                    userOpEventArgs = args;
+                    break;
+                }
+                // Update startIndex to this UserOpEvent for the next UserOp's logs
+                startIndex = index;
             }
         }
-    });
-    if (endIndex === -1) {
-        throw new Error("fatal: no UserOperationEvent in logs");
+        catch { }
     }
-    const filteredLogs = receipt.logs.slice(startIndex + 1, endIndex);
-    const logsParsing = z.array(logSchema).safeParse(filteredLogs);
-    if (!logsParsing.success) {
-        const err = fromZodError(logsParsing.error);
-        throw err;
+    if (userOpEventIndex === -1 || startIndex === -1 || !userOpEventArgs) {
+        throw new Error("fatal: no UserOpEvent in logs");
     }
-    const receiptParsing = receiptSchema.safeParse({
+    // Get logs between the starting point and our UserOpEvent
+    const filteredLogs = receipt.logs.slice(startIndex + 1, userOpEventIndex);
+    const parsedLogs = z.array(logSchema).parse(filteredLogs);
+    const parsedReceipt = receiptSchema.parse({
         ...receipt,
         status: receipt.status === "success" ? 1 : 0
     });
-    if (!receiptParsing.success) {
-        const err = fromZodError(receiptParsing.error);
-        throw err;
+    let paymaster = userOpEventArgs.paymaster;
+    if (paymaster === zeroAddress) {
+        paymaster = undefined;
     }
-    const userOperationEvent = parseEventLogs({
-        abi: EntryPointV06Abi,
-        eventName: "UserOperationEvent",
-        args: {
-            userOpHash
-        },
-        logs: receipt.logs
-    })[0];
-    let paymaster = userOperationEvent.args.paymaster;
-    paymaster = paymaster === zeroAddress ? undefined : paymaster;
-    const userOperationReceipt = {
+    const userOpReceipt = {
         userOpHash,
         entryPoint,
-        sender: userOperationEvent.args.sender,
-        nonce: userOperationEvent.args.nonce,
         paymaster,
-        actualGasUsed: userOperationEvent.args.actualGasUsed,
-        actualGasCost: userOperationEvent.args.actualGasCost,
-        success: userOperationEvent.args.success,
+        sender: userOpEventArgs.sender,
+        nonce: userOpEventArgs.nonce,
+        actualGasUsed: userOpEventArgs.actualGasUsed,
+        actualGasCost: userOpEventArgs.actualGasCost,
+        success: userOpEventArgs.success,
         reason: revertReason,
-        logs: logsParsing.data,
-        receipt: receiptParsing.data
+        logs: parsedLogs,
+        receipt: parsedReceipt
     };
-    return userOperationReceipt;
+    return userOpReceipt;
 }
+export const getViemEntryPointVersion = (userOp, entryPoint) => {
+    if (isVersion09(userOp, entryPoint)) {
+        return "0.9";
+    }
+    if (isVersion08(userOp, entryPoint)) {
+        return "0.8";
+    }
+    if (isVersion07(userOp)) {
+        return "0.7";
+    }
+    return "0.6";
+};
+export const getEntryPointSimulationsAddress = ({ version, config }) => {
+    switch (version) {
+        case "0.9":
+            return config.entrypointSimulationContractV9;
+        case "0.8":
+            return config.entrypointSimulationContractV8;
+        default:
+            return config.entrypointSimulationContractV7;
+    }
+};
 //# sourceMappingURL=userop.js.map