viem 2.17.11 → 2.18.1

package/account-abstraction/utils/errors/getBundlerError.ts

@@ -0,0 +1,309 @@
+import type { BaseError } from '../../../errors/base.js'
+import type { ExactPartial } from '../../../types/utils.js'
+import {
+  AccountNotDeployedError,
+  type AccountNotDeployedErrorType,
+  ExecutionRevertedError,
+  type ExecutionRevertedErrorType,
+  FailedToSendToBeneficiaryError,
+  type FailedToSendToBeneficiaryErrorType,
+  GasValuesOverflowError,
+  type GasValuesOverflowErrorType,
+  HandleOpsOutOfGasError,
+  type HandleOpsOutOfGasErrorType,
+  InitCodeFailedError,
+  type InitCodeFailedErrorType,
+  InitCodeMustCreateSenderError,
+  type InitCodeMustCreateSenderErrorType,
+  InitCodeMustReturnSenderError,
+  type InitCodeMustReturnSenderErrorType,
+  InsufficientPrefundError,
+  type InsufficientPrefundErrorType,
+  InternalCallOnlyError,
+  type InternalCallOnlyErrorType,
+  InvalidAccountNonceError,
+  type InvalidAccountNonceErrorType,
+  InvalidAggregatorError,
+  type InvalidAggregatorErrorType,
+  InvalidBeneficiaryError,
+  type InvalidBeneficiaryErrorType,
+  InvalidFieldsError,
+  type InvalidFieldsErrorType,
+  InvalidPaymasterAndDataError,
+  type InvalidPaymasterAndDataErrorType,
+  PaymasterDepositTooLowError,
+  type PaymasterDepositTooLowErrorType,
+  PaymasterFunctionRevertedError,
+  type PaymasterFunctionRevertedErrorType,
+  PaymasterNotDeployedError,
+  type PaymasterNotDeployedErrorType,
+  PaymasterPostOpFunctionRevertedError,
+  type PaymasterPostOpFunctionRevertedErrorType,
+  PaymasterRateLimitError,
+  type PaymasterRateLimitErrorType,
+  PaymasterStakeTooLowError,
+  type PaymasterStakeTooLowErrorType,
+  SenderAlreadyConstructedError,
+  type SenderAlreadyConstructedErrorType,
+  SignatureCheckFailedError,
+  type SignatureCheckFailedErrorType,
+  SmartAccountFunctionRevertedError,
+  type SmartAccountFunctionRevertedErrorType,
+  UnknownBundlerError,
+  type UnknownBundlerErrorType,
+  UnsupportedSignatureAggregatorError,
+  type UnsupportedSignatureAggregatorErrorType,
+  UserOperationExpiredError,
+  type UserOperationExpiredErrorType,
+  UserOperationOutOfTimeRangeError,
+  type UserOperationOutOfTimeRangeErrorType,
+  UserOperationPaymasterExpiredError,
+  type UserOperationPaymasterExpiredErrorType,
+  UserOperationPaymasterSignatureError,
+  type UserOperationPaymasterSignatureErrorType,
+  UserOperationRejectedByEntryPointError,
+  type UserOperationRejectedByEntryPointErrorType,
+  UserOperationRejectedByOpCodeError,
+  type UserOperationRejectedByOpCodeErrorType,
+  UserOperationRejectedByPaymasterError,
+  type UserOperationRejectedByPaymasterErrorType,
+  UserOperationSignatureError,
+  type UserOperationSignatureErrorType,
+  VerificationGasLimitExceededError,
+  type VerificationGasLimitExceededErrorType,
+  VerificationGasLimitTooLowError,
+  type VerificationGasLimitTooLowErrorType,
+} from '../../errors/bundler.js'
+import type { UserOperation } from '../../types/userOperation.js'
+
+const bundlerErrors = [
+  ExecutionRevertedError,
+  InvalidFieldsError,
+  PaymasterDepositTooLowError,
+  PaymasterRateLimitError,
+  PaymasterStakeTooLowError,
+  SignatureCheckFailedError,
+  UnsupportedSignatureAggregatorError,
+  UserOperationOutOfTimeRangeError,
+  UserOperationRejectedByEntryPointError,
+  UserOperationRejectedByPaymasterError,
+  UserOperationRejectedByOpCodeError,
+]
+
+export type GetBundlerErrorParameters = ExactPartial<UserOperation>
+
+export type GetBundlerErrorReturnType =
+  | AccountNotDeployedErrorType
+  | ExecutionRevertedErrorType
+  | FailedToSendToBeneficiaryErrorType
+  | GasValuesOverflowErrorType
+  | HandleOpsOutOfGasErrorType
+  | InitCodeFailedErrorType
+  | InitCodeMustCreateSenderErrorType
+  | InitCodeMustReturnSenderErrorType
+  | InsufficientPrefundErrorType
+  | InternalCallOnlyErrorType
+  | InvalidAccountNonceErrorType
+  | InvalidAggregatorErrorType
+  | InvalidBeneficiaryErrorType
+  | InvalidFieldsErrorType
+  | InvalidPaymasterAndDataErrorType
+  | PaymasterDepositTooLowErrorType
+  | PaymasterFunctionRevertedErrorType
+  | PaymasterNotDeployedErrorType
+  | PaymasterPostOpFunctionRevertedErrorType
+  | PaymasterRateLimitErrorType
+  | PaymasterStakeTooLowErrorType
+  | SignatureCheckFailedErrorType
+  | SenderAlreadyConstructedErrorType
+  | SmartAccountFunctionRevertedErrorType
+  | UnsupportedSignatureAggregatorErrorType
+  | UserOperationOutOfTimeRangeErrorType
+  | UserOperationRejectedByEntryPointErrorType
+  | UserOperationRejectedByOpCodeErrorType
+  | UserOperationRejectedByPaymasterErrorType
+  | UnknownBundlerErrorType
+  | UserOperationExpiredErrorType
+  | UserOperationPaymasterExpiredErrorType
+  | UserOperationPaymasterSignatureErrorType
+  | UserOperationSignatureErrorType
+  | VerificationGasLimitExceededErrorType
+  | VerificationGasLimitTooLowErrorType
+
+export function getBundlerError(
+  err: BaseError,
+  args: GetBundlerErrorParameters,
+): GetBundlerErrorReturnType {
+  const message = (err.details || '').toLowerCase()
+
+  if (AccountNotDeployedError.message.test(message))
+    return new AccountNotDeployedError({
+      cause: err,
+    }) as any
+  if (FailedToSendToBeneficiaryError.message.test(message))
+    return new FailedToSendToBeneficiaryError({
+      cause: err,
+    }) as any
+  if (GasValuesOverflowError.message.test(message))
+    return new GasValuesOverflowError({
+      cause: err,
+    }) as any
+  if (HandleOpsOutOfGasError.message.test(message))
+    return new HandleOpsOutOfGasError({
+      cause: err,
+    }) as any
+  if (InitCodeFailedError.message.test(message))
+    return new InitCodeFailedError({
+      cause: err,
+      factory: args.factory,
+      factoryData: args.factoryData,
+      initCode: args.initCode,
+    }) as any
+  if (InitCodeMustCreateSenderError.message.test(message))
+    return new InitCodeMustCreateSenderError({
+      cause: err,
+      factory: args.factory,
+      factoryData: args.factoryData,
+      initCode: args.initCode,
+    }) as any
+  if (InitCodeMustReturnSenderError.message.test(message))
+    return new InitCodeMustReturnSenderError({
+      cause: err,
+      factory: args.factory,
+      factoryData: args.factoryData,
+      initCode: args.initCode,
+      sender: args.sender,
+    }) as any
+  if (InsufficientPrefundError.message.test(message))
+    return new InsufficientPrefundError({
+      cause: err,
+    }) as any
+  if (InternalCallOnlyError.message.test(message))
+    return new InternalCallOnlyError({
+      cause: err,
+    }) as any
+  if (InvalidAccountNonceError.message.test(message))
+    return new InvalidAccountNonceError({
+      cause: err,
+      nonce: args.nonce,
+    }) as any
+  if (InvalidAggregatorError.message.test(message))
+    return new InvalidAggregatorError({
+      cause: err,
+    }) as any
+  if (InvalidBeneficiaryError.message.test(message))
+    return new InvalidBeneficiaryError({
+      cause: err,
+    }) as any
+  if (InvalidPaymasterAndDataError.message.test(message))
+    return new InvalidPaymasterAndDataError({
+      cause: err,
+    }) as any
+  if (PaymasterDepositTooLowError.message.test(message))
+    return new PaymasterDepositTooLowError({
+      cause: err,
+    }) as any
+  if (PaymasterFunctionRevertedError.message.test(message))
+    return new PaymasterFunctionRevertedError({
+      cause: err,
+    }) as any
+  if (PaymasterNotDeployedError.message.test(message))
+    return new PaymasterNotDeployedError({
+      cause: err,
+    }) as any
+  if (PaymasterPostOpFunctionRevertedError.message.test(message))
+    return new PaymasterPostOpFunctionRevertedError({
+      cause: err,
+    }) as any
+  if (SmartAccountFunctionRevertedError.message.test(message))
+    return new SmartAccountFunctionRevertedError({
+      cause: err,
+    }) as any
+  if (SenderAlreadyConstructedError.message.test(message))
+    return new SenderAlreadyConstructedError({
+      cause: err,
+      factory: args.factory,
+      factoryData: args.factoryData,
+      initCode: args.initCode,
+    }) as any
+  if (UserOperationExpiredError.message.test(message))
+    return new UserOperationExpiredError({
+      cause: err,
+    }) as any
+  if (UserOperationPaymasterExpiredError.message.test(message))
+    return new UserOperationPaymasterExpiredError({
+      cause: err,
+    }) as any
+  if (UserOperationPaymasterSignatureError.message.test(message))
+    return new UserOperationPaymasterSignatureError({
+      cause: err,
+    }) as any
+  if (UserOperationSignatureError.message.test(message))
+    return new UserOperationSignatureError({
+      cause: err,
+    }) as any
+  if (VerificationGasLimitExceededError.message.test(message))
+    return new VerificationGasLimitExceededError({
+      cause: err,
+    }) as any
+  if (VerificationGasLimitTooLowError.message.test(message))
+    return new VerificationGasLimitTooLowError({
+      cause: err,
+    }) as any
+
+  const error = err.walk((e) =>
+    bundlerErrors.some((error) => error.code === (e as { code: number }).code),
+  ) as BaseError & { code: number }
+
+  if (error) {
+    if (error.code === ExecutionRevertedError.code)
+      return new ExecutionRevertedError({
+        cause: err,
+        message: error.details,
+      }) as any
+    if (error.code === InvalidFieldsError.code)
+      return new InvalidFieldsError({
+        cause: err,
+      }) as any
+    if (error.code === PaymasterDepositTooLowError.code)
+      return new PaymasterDepositTooLowError({
+        cause: err,
+      }) as any
+    if (error.code === PaymasterRateLimitError.code)
+      return new PaymasterRateLimitError({
+        cause: err,
+      }) as any
+    if (error.code === PaymasterStakeTooLowError.code)
+      return new PaymasterStakeTooLowError({
+        cause: err,
+      }) as any
+    if (error.code === SignatureCheckFailedError.code)
+      return new SignatureCheckFailedError({
+        cause: err,
+      }) as any
+    if (error.code === UnsupportedSignatureAggregatorError.code)
+      return new UnsupportedSignatureAggregatorError({
+        cause: err,
+      }) as any
+    if (error.code === UserOperationOutOfTimeRangeError.code)
+      return new UserOperationOutOfTimeRangeError({
+        cause: err,
+      }) as any
+    if (error.code === UserOperationRejectedByEntryPointError.code)
+      return new UserOperationRejectedByEntryPointError({
+        cause: err,
+      }) as any
+    if (error.code === UserOperationRejectedByPaymasterError.code)
+      return new UserOperationRejectedByPaymasterError({
+        cause: err,
+      }) as any
+    if (error.code === UserOperationRejectedByOpCodeError.code)
+      return new UserOperationRejectedByOpCodeError({
+        cause: err,
+      }) as any
+  }
+
+  return new UnknownBundlerError({
+    cause: err,
+  }) as any
+}

package/account-abstraction/utils/errors/getUserOperationError.ts

@@ -0,0 +1,153 @@
+import type { Address } from 'abitype'
+import { BaseError } from '../../../errors/base.js'
+import {
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+} from '../../../errors/contract.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { ContractFunctionParameters } from '../../../types/contract.js'
+import type { Hex } from '../../../types/misc.js'
+import type { OneOf } from '../../../types/utils.js'
+import { decodeErrorResult } from '../../../utils/abi/decodeErrorResult.js'
+import type { GetContractErrorReturnType } from '../../../utils/errors/getContractError.js'
+import { ExecutionRevertedError } from '../../errors/bundler.js'
+import {
+  UserOperationExecutionError,
+  type UserOperationExecutionErrorType,
+} from '../../errors/userOperation.js'
+import type {
+  UserOperation,
+  UserOperationCall,
+} from '../../types/userOperation.js'
+import {
+  type GetBundlerErrorParameters,
+  getBundlerError,
+} from './getBundlerError.js'
+
+type Call = OneOf<
+  | UserOperationCall
+  | (ContractFunctionParameters & {
+      to: Address
+    })
+>
+
+type GetNodeErrorReturnType = ErrorType
+
+export type GetUserOperationErrorParameters = UserOperation & {
+  calls?: readonly unknown[] | undefined
+  docsPath?: string | undefined
+}
+
+export type GetUserOperationErrorReturnType<cause = ErrorType> = Omit<
+  UserOperationExecutionErrorType,
+  'cause'
+> & { cause: cause | GetNodeErrorReturnType }
+
+export type GetUserOperationErrorErrorType = ErrorType
+
+export function getUserOperationError<err extends ErrorType<string>>(
+  err: err,
+  { calls, docsPath, ...args }: GetUserOperationErrorParameters,
+): GetUserOperationErrorReturnType<err> {
+  const cause = (() => {
+    const cause = getBundlerError(
+      err as {} as BaseError,
+      args as GetBundlerErrorParameters,
+    )
+    if (cause instanceof ExecutionRevertedError) {
+      const revertData = getRevertData(cause)
+      const contractCalls = calls?.filter(
+        (call: any) => call.abi || call.data,
+      ) as readonly Call[]
+      if (revertData && contractCalls.length > 0)
+        return getContractError({ calls: contractCalls, revertData })
+    }
+    return cause
+  })()
+  return new UserOperationExecutionError(cause, {
+    docsPath,
+    ...args,
+  }) as GetUserOperationErrorReturnType<err>
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+
+function getRevertData(error: BaseError) {
+  let revertData: Hex | undefined
+  error.walk((e) => {
+    const error = e as any
+    if (
+      typeof error.data === 'string' ||
+      typeof error.data?.revertData === 'string' ||
+      (!(error instanceof BaseError) && typeof error.message === 'string')
+    ) {
+      const match = (
+        error.data?.revertData ||
+        error.data ||
+        error.message
+      ).match?.(/(0x[A-Za-z0-9]*)/)
+      if (match) {
+        revertData = match[1]
+        return true
+      }
+    }
+    return false
+  })
+  return revertData
+}
+
+function getContractError(parameters: {
+  calls: readonly Call[]
+  revertData: Hex
+}) {
+  const { calls, revertData } = parameters
+
+  const { abi, functionName, args, to } = (() => {
+    const contractCalls = calls?.filter((call) =>
+      Boolean(call.abi),
+    ) as readonly (ContractFunctionParameters & { to: Address })[]
+
+    if (contractCalls.length === 1) return contractCalls[0]
+
+    const compatContractCalls = contractCalls.filter((call) => {
+      try {
+        return Boolean(
+          decodeErrorResult({
+            abi: call.abi,
+            data: revertData,
+          }),
+        )
+      } catch {
+        return false
+      }
+    })
+    if (compatContractCalls.length === 1) return compatContractCalls[0]
+
+    return {
+      abi: [],
+      functionName: contractCalls.reduce(
+        (acc, call) => `${acc ? `${acc} | ` : ''}${call.functionName}`,
+        '',
+      ),
+      args: undefined,
+      to: undefined,
+    }
+  })()
+
+  const cause = (() => {
+    if (revertData === '0x')
+      return new ContractFunctionZeroDataError({ functionName })
+    return new ContractFunctionRevertedError({
+      abi,
+      data: revertData,
+      functionName,
+    })
+  })()
+  return new ContractFunctionExecutionError(cause as BaseError, {
+    abi,
+    args,
+    contractAddress: to,
+    functionName,
+  }) as GetContractErrorReturnType
+}

package/account-abstraction/utils/formatters/userOperation.ts

@@ -0,0 +1,31 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { RpcUserOperation } from '../../types/rpc.js'
+import type { UserOperation } from '../../types/userOperation.js'
+
+export type FormatUserOperationErrorType = ErrorType
+
+export function formatUserOperation(parameters: RpcUserOperation) {
+  const userOperation = { ...parameters } as unknown as UserOperation
+
+  if (parameters.callGasLimit)
+    userOperation.callGasLimit = BigInt(parameters.callGasLimit)
+  if (parameters.maxFeePerGas)
+    userOperation.maxFeePerGas = BigInt(parameters.maxFeePerGas)
+  if (parameters.maxPriorityFeePerGas)
+    userOperation.maxPriorityFeePerGas = BigInt(parameters.maxPriorityFeePerGas)
+  if (parameters.nonce) userOperation.nonce = BigInt(parameters.nonce)
+  if (parameters.paymasterPostOpGasLimit)
+    userOperation.paymasterPostOpGasLimit = BigInt(
+      parameters.paymasterPostOpGasLimit,
+    )
+  if (parameters.paymasterVerificationGasLimit)
+    userOperation.paymasterVerificationGasLimit = BigInt(
+      parameters.paymasterVerificationGasLimit,
+    )
+  if (parameters.preVerificationGas)
+    userOperation.preVerificationGas = BigInt(parameters.preVerificationGas)
+  if (parameters.verificationGasLimit)
+    userOperation.verificationGasLimit = BigInt(parameters.verificationGasLimit)
+
+  return userOperation
+}

package/account-abstraction/utils/formatters/userOperationGas.ts

@@ -0,0 +1,26 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { RpcEstimateUserOperationGasReturnType } from '../../types/rpc.js'
+import type { EstimateUserOperationGasReturnType } from '../../types/userOperation.js'
+
+export type FormatUserOperationGasErrorType = ErrorType
+
+export function formatUserOperationGas(
+  parameters: RpcEstimateUserOperationGasReturnType,
+): EstimateUserOperationGasReturnType {
+  const gas = {} as EstimateUserOperationGasReturnType
+
+  if (parameters.callGasLimit)
+    gas.callGasLimit = BigInt(parameters.callGasLimit)
+  if (parameters.preVerificationGas)
+    gas.preVerificationGas = BigInt(parameters.preVerificationGas)
+  if (parameters.verificationGasLimit)
+    gas.verificationGasLimit = BigInt(parameters.verificationGasLimit)
+  if (parameters.paymasterPostOpGasLimit)
+    gas.paymasterPostOpGasLimit = BigInt(parameters.paymasterPostOpGasLimit)
+  if (parameters.paymasterVerificationGasLimit)
+    gas.paymasterVerificationGasLimit = BigInt(
+      parameters.paymasterVerificationGasLimit,
+    )
+
+  return gas
+}

package/account-abstraction/utils/formatters/userOperationReceipt.ts

@@ -0,0 +1,24 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import { formatLog } from '../../../utils/formatters/log.js'
+import { formatTransactionReceipt } from '../../../utils/formatters/transactionReceipt.js'
+import type { RpcUserOperationReceipt } from '../../types/rpc.js'
+import type { UserOperationReceipt } from '../../types/userOperation.js'
+
+export type FormatUserOperationReceiptErrorType = ErrorType
+
+export function formatUserOperationReceipt(
+  parameters: RpcUserOperationReceipt,
+) {
+  const receipt = { ...parameters } as unknown as UserOperationReceipt
+
+  if (parameters.actualGasCost)
+    receipt.actualGasCost = BigInt(parameters.actualGasCost)
+  if (parameters.actualGasUsed)
+    receipt.actualGasUsed = BigInt(parameters.actualGasUsed)
+  if (parameters.logs)
+    receipt.logs = parameters.logs.map((log) => formatLog(log)) as any
+  if (parameters.receipt)
+    receipt.receipt = formatTransactionReceipt(receipt.receipt as any)
+
+  return receipt
+}

package/account-abstraction/utils/formatters/userOperationRequest.ts

@@ -0,0 +1,53 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { ExactPartial } from '../../../types/utils.js'
+import { numberToHex } from '../../../utils/encoding/toHex.js'
+import type { RpcUserOperation } from '../../types/rpc.js'
+import type { UserOperation } from '../../types/userOperation.js'
+
+export type FormatUserOperationRequestErrorType = ErrorType
+
+export function formatUserOperationRequest(
+  request: ExactPartial<UserOperation>,
+) {
+  const rpcRequest = {} as RpcUserOperation
+
+  if (typeof request.callData !== 'undefined')
+    rpcRequest.callData = request.callData
+  if (typeof request.callGasLimit !== 'undefined')
+    rpcRequest.callGasLimit = numberToHex(request.callGasLimit)
+  if (typeof request.factory !== 'undefined')
+    rpcRequest.factory = request.factory
+  if (typeof request.factoryData !== 'undefined')
+    rpcRequest.factoryData = request.factoryData
+  if (typeof request.initCode !== 'undefined')
+    rpcRequest.initCode = request.initCode
+  if (typeof request.maxFeePerGas !== 'undefined')
+    rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas)
+  if (typeof request.maxPriorityFeePerGas !== 'undefined')
+    rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas)
+  if (typeof request.nonce !== 'undefined')
+    rpcRequest.nonce = numberToHex(request.nonce)
+  if (typeof request.paymaster !== 'undefined')
+    rpcRequest.paymaster = request.paymaster
+  if (typeof request.paymasterAndData !== 'undefined')
+    rpcRequest.paymasterAndData = request.paymasterAndData || '0x'
+  if (typeof request.paymasterData !== 'undefined')
+    rpcRequest.paymasterData = request.paymasterData
+  if (typeof request.paymasterPostOpGasLimit !== 'undefined')
+    rpcRequest.paymasterPostOpGasLimit = numberToHex(
+      request.paymasterPostOpGasLimit,
+    )
+  if (typeof request.paymasterVerificationGasLimit !== 'undefined')
+    rpcRequest.paymasterVerificationGasLimit = numberToHex(
+      request.paymasterVerificationGasLimit,
+    )
+  if (typeof request.preVerificationGas !== 'undefined')
+    rpcRequest.preVerificationGas = numberToHex(request.preVerificationGas)
+  if (typeof request.sender !== 'undefined') rpcRequest.sender = request.sender
+  if (typeof request.signature !== 'undefined')
+    rpcRequest.signature = request.signature
+  if (typeof request.verificationGasLimit !== 'undefined')
+    rpcRequest.verificationGasLimit = numberToHex(request.verificationGasLimit)
+
+  return rpcRequest
+}