permissionless 0.0.30 → 0.0.32

package/utils/errors/getBundlerError.ts

@@ -0,0 +1,220 @@
+import {
+    type Address,
+    BaseError,
+    ExecutionRevertedError,
+    type ExecutionRevertedErrorType,
+    UnknownNodeError,
+    type UnknownNodeErrorType
+} from "viem"
+import { SenderAlreadyDeployedError } from "../../errors"
+import {
+    InitCodeDidNotDeploySenderError,
+    type InitCodeDidNotDeploySenderErrorType,
+    InitCodeRevertedError,
+    type InitCodeRevertedErrorType,
+    InvalidSmartAccountNonceError,
+    type InvalidSmartAccountNonceErrorType,
+    SenderAddressMismatchError,
+    type SenderAddressMismatchErrorType,
+    type SenderAlreadyDeployedErrorType,
+    SenderNotDeployedError,
+    type SenderNotDeployedErrorType,
+    SmartAccountInsufficientFundsError,
+    type SmartAccountInsufficientFundsErrorType,
+    SmartAccountSignatureValidityPeriodError,
+    type SmartAccountSignatureValidityPeriodErrorType,
+    SmartAccountValidationRevertedError,
+    type SmartAccountValidationRevertedErrorType
+} from "../../errors/account"
+import {
+    PaymasterDataRejectedError,
+    type PaymasterDataRejectedErrorType,
+    PaymasterDepositTooLowError,
+    type PaymasterDepositTooLowErrorType,
+    PaymasterNotDeployedError,
+    type PaymasterNotDeployedErrorType,
+    PaymasterValidationRevertedError,
+    type PaymasterValidationRevertedErrorType,
+    PaymasterValidityPeriodError,
+    type PaymasterValidityPeriodErrorType
+} from "../../errors/paymaster"
+import type { UserOperation } from "../../types"
+
+export type GetBundlerErrorParameters = {
+    userOperation: Partial<UserOperation>
+    entryPoint: Address
+}
+
+export type GetBundlerErrorReturnType =
+    | ExecutionRevertedErrorType
+    | UnknownNodeErrorType
+    | SenderAlreadyDeployedErrorType
+    | InitCodeRevertedErrorType
+    | SenderAddressMismatchErrorType
+    | InitCodeDidNotDeploySenderErrorType
+    | SenderNotDeployedErrorType
+    | SmartAccountInsufficientFundsErrorType
+    | SmartAccountSignatureValidityPeriodErrorType
+    | SmartAccountValidationRevertedErrorType
+    | InvalidSmartAccountNonceErrorType
+    | PaymasterNotDeployedErrorType
+    | PaymasterDepositTooLowErrorType
+    | PaymasterValidityPeriodErrorType
+    | PaymasterValidationRevertedErrorType
+    | PaymasterDataRejectedErrorType
+
+export function getBundlerError(
+    err: BaseError,
+    args: GetBundlerErrorParameters
+) {
+    const message = (err.details || "").toLowerCase()
+
+    const executionRevertedError =
+        err instanceof BaseError
+            ? err.walk(
+                  (e) =>
+                      (e as { code: number }).code ===
+                      ExecutionRevertedError.code
+              )
+            : err
+
+    if (executionRevertedError instanceof BaseError) {
+        return new ExecutionRevertedError({
+            cause: err,
+            message: executionRevertedError.details
+        }) as any
+    }
+
+    // TODO: Add validation Errors
+    if (args.userOperation.sender === undefined)
+        return new UnknownNodeError({ cause: err })
+    if (args.userOperation.nonce === undefined)
+        return new UnknownNodeError({ cause: err })
+
+    if (SenderAlreadyDeployedError.message.test(message)) {
+        return new SenderAlreadyDeployedError({
+            cause: err,
+            sender: args.userOperation.sender,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa10"
+        }) as any
+    }
+
+    if (InitCodeRevertedError.message.test(message)) {
+        return new InitCodeRevertedError({
+            cause: err,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa13"
+        }) as any
+    }
+
+    if (SenderAddressMismatchError.message.test(message)) {
+        return new SenderAddressMismatchError({
+            cause: err,
+            sender: args.userOperation.sender,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa14"
+        }) as any
+    }
+
+    if (InitCodeDidNotDeploySenderError.message.test(message)) {
+        return new InitCodeDidNotDeploySenderError({
+            cause: err,
+            sender: args.userOperation.sender,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa15"
+        }) as any
+    }
+
+    if (SenderNotDeployedError.message.test(message)) {
+        return new SenderNotDeployedError({
+            cause: err,
+            sender: args.userOperation.sender,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa20"
+        }) as any
+    }
+
+    if (SmartAccountInsufficientFundsError.message.test(message)) {
+        return new SmartAccountInsufficientFundsError({
+            cause: err,
+            sender: args.userOperation.sender,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa21"
+        }) as any
+    }
+
+    if (SmartAccountSignatureValidityPeriodError.message.test(message)) {
+        return new SmartAccountSignatureValidityPeriodError({
+            cause: err,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa22"
+        }) as any
+    }
+
+    if (SmartAccountValidationRevertedError.message.test(message)) {
+        return new SmartAccountValidationRevertedError({
+            cause: err,
+            sender: args.userOperation.sender,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa23"
+        }) as any
+    }
+
+    if (InvalidSmartAccountNonceError.message.test(message)) {
+        return new InvalidSmartAccountNonceError({
+            cause: err,
+            sender: args.userOperation.sender,
+            nonce: args.userOperation.nonce,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa25"
+        }) as any
+    }
+
+    if (PaymasterNotDeployedError.message.test(message)) {
+        return new PaymasterNotDeployedError({
+            cause: err,
+            paymasterAndData: args.userOperation.paymasterAndData,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa30"
+        }) as any
+    }
+
+    if (PaymasterDepositTooLowError.message.test(message)) {
+        return new PaymasterDepositTooLowError({
+            cause: err,
+            paymasterAndData: args.userOperation.paymasterAndData,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa31"
+        }) as any
+    }
+
+    if (PaymasterValidityPeriodError.message.test(message)) {
+        return new PaymasterValidityPeriodError({
+            cause: err,
+            paymasterAndData: args.userOperation.paymasterAndData,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa32"
+        }) as any
+    }
+
+    if (PaymasterValidationRevertedError.message.test(message)) {
+        return new PaymasterValidationRevertedError({
+            cause: err,
+            paymasterAndData: args.userOperation.paymasterAndData,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa33"
+        }) as any
+    }
+
+    if (PaymasterDataRejectedError.message.test(message)) {
+        return new PaymasterDataRejectedError({
+            cause: err,
+            paymasterAndData: args.userOperation.paymasterAndData,
+            docsPath:
+                "https://docs.pimlico.io/bundler/reference/entrypoint-errors/aa34"
+        }) as any
+    }
+
+    return new UnknownNodeError({ cause: err }) as any
+}

package/utils/errors/getEstimateUserOperationGasError.ts

@@ -0,0 +1,37 @@
+import { BaseError, UnknownNodeError } from "viem"
+import type { EstimateUserOperationGasParameters } from "../../actions/bundler/estimateUserOperationGas"
+import {
+    EstimateUserOperationGasError,
+    type EstimateUserOperationGasErrorType
+} from "../../errors/estimateUserOperationGas"
+import { type ErrorType } from "../../errors/utils"
+import {
+    type GetBundlerErrorParameters,
+    type GetBundlerErrorReturnType,
+    getBundlerError
+} from "./getBundlerError"
+
+export type GetEstimateUserOperationGasErrorReturnType<cause = ErrorType> =
+    Omit<EstimateUserOperationGasErrorType, "cause"> & {
+        cause: cause | GetBundlerErrorReturnType
+    }
+
+export function getEstimateUserOperationGasError<err extends ErrorType<string>>(
+    error: err,
+    args: EstimateUserOperationGasParameters
+) {
+    const cause = (() => {
+        const cause = getBundlerError(
+            // biome-ignore lint/complexity/noBannedTypes: <explanation>
+            error as {} as BaseError,
+            args as GetBundlerErrorParameters
+        )
+        // biome-ignore lint/complexity/noBannedTypes: <explanation>
+        if (cause instanceof UnknownNodeError) return error as {} as BaseError
+        return cause
+    })()
+
+    throw new EstimateUserOperationGasError(cause, {
+        ...args
+    }) as GetEstimateUserOperationGasErrorReturnType<err>
+}

package/utils/errors/getSendUserOperationError.ts

@@ -0,0 +1,25 @@
+import { BaseError, UnknownNodeError } from "viem"
+import type { SendUserOperationParameters } from "../../actions/bundler/sendUserOperation"
+import { SendUserOperationError } from "../../errors"
+import {
+    type GetBundlerErrorParameters,
+    getBundlerError
+} from "./getBundlerError"
+
+export function getSendUserOperationError(
+    err: BaseError,
+    args: SendUserOperationParameters
+) {
+    const cause = (() => {
+        const cause = getBundlerError(
+            err as BaseError,
+            args as GetBundlerErrorParameters
+        )
+        if (cause instanceof UnknownNodeError) return err as BaseError
+        return cause
+    })()
+
+    throw new SendUserOperationError(cause, {
+        ...args
+    })
+}

package/utils/getAddressFromInitCodeOrPaymasterAndData.ts

@@ -0,0 +1,13 @@
+import { type Address, type Hex, getAddress } from "viem"
+
+export function getAddressFromInitCodeOrPaymasterAndData(
+    data: Hex
+): Address | undefined {
+    if (!data) {
+        return undefined
+    }
+    if (data.length >= 42) {
+        return getAddress(data.slice(0, 42))
+    }
+    return undefined
+}

package/utils/index.ts

@@ -1,6 +1,7 @@
 import type { Account, Address } from "viem"
 import { deepHexlify, transactionReceiptStatus } from "./deepHexlify.js"
 import { getAction } from "./getAction.js"
+import { getAddressFromInitCodeOrPaymasterAndData } from "./getAddressFromInitCodeOrPaymasterAndData.js"
 import {
     type GetRequiredPrefundReturnType,
     getRequiredPrefund
@@ -9,7 +10,7 @@ import {
     type GetUserOperationHashParams,
     getUserOperationHash
 } from "./getUserOperationHash.js"
-import { isSmartAccountDeployed } from "./isSmartAccountDeployed"
+import { isSmartAccountDeployed } from "./isSmartAccountDeployed.js"
 import {
     AccountOrClientNotFoundError,
     type SignUserOperationHashWithECDSAParams,
@@ -35,5 +36,6 @@ export {
     signUserOperationHashWithECDSA,
     type SignUserOperationHashWithECDSAParams,
     AccountOrClientNotFoundError,
-    isSmartAccountDeployed
+    isSmartAccountDeployed,
+    getAddressFromInitCodeOrPaymasterAndData
 }