viem 0.0.0-w-20230828183856 → 0.0.0-w-20230904174840

package/src/utils/abi/encodeErrorResult.ts

@@ -1,48 +1,69 @@
-import type { Abi } from 'abitype'
+import type { Abi, ExtractAbiErrors } from 'abitype'
 
 import {
   AbiErrorInputsNotFoundError,
   AbiErrorNotFoundError,
 } from '../../errors/abi.js'
 import type {
-  AbiItem,
-  GetErrorArgs,
-  InferErrorName,
+  ContractErrorArgs,
+  ContractErrorName,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import { concatHex } from '../data/concat.js'
 import { getFunctionSelector } from '../hash/getFunctionSelector.js'
 
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
+import { getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeErrorResult'
 
 export type EncodeErrorResultParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TErrorName extends string | undefined = string,
-  _ErrorName = InferErrorName<TAbi, TErrorName>,
+  abi extends Abi | readonly unknown[] = Abi,
+  errorName extends ContractErrorName<abi> | undefined = ContractErrorName<abi>,
+  ///
+  hasErrors = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [ExtractAbiErrors<abi>] extends [never]
+      ? false
+      : true
+    : true,
+  allArgs = ContractErrorArgs<
+    abi,
+    errorName extends ContractErrorName<abi>
+      ? errorName
+      : ContractErrorName<abi>
+  >,
+  allErrorNames = ContractErrorName<abi>,
 > = {
-  errorName?: _ErrorName
-} & (TErrorName extends string
-  ? { abi: TAbi } & GetErrorArgs<TAbi, TErrorName>
-  : _ErrorName extends string
-  ? { abi: [TAbi[number]] } & GetErrorArgs<TAbi, _ErrorName>
-  : never)
+  abi: abi
+  args?: allArgs | undefined
+} & UnionEvaluate<
+  IsNarrowable<abi, Abi> extends true
+    ? abi['length'] extends 1
+      ? { errorName?: errorName | allErrorNames }
+      : { errorName: errorName | allErrorNames }
+    : { errorName?: errorName | allErrorNames }
+> &
+  (hasErrors extends true ? unknown : never)
+
+export type EncodeErrorResultReturnType = Hex
 
 export function encodeErrorResult<
-  const TAbi extends Abi | readonly unknown[],
-  TErrorName extends string | undefined = undefined,
->({ abi, errorName, args }: EncodeErrorResultParameters<TAbi, TErrorName>) {
-  let abiItem = abi[0] as AbiItem
+  const abi extends Abi | readonly unknown[],
+  errorName extends ContractErrorName<abi> | undefined = undefined,
+>(
+  parameters: EncodeErrorResultParameters<abi, errorName>,
+): EncodeErrorResultReturnType {
+  const { abi, errorName, args } = parameters as EncodeErrorResultParameters
+
+  let abiItem = abi[0]
   if (errorName) {
-    abiItem = getAbiItem({
-      abi,
-      args,
-      name: errorName,
-    } as GetAbiItemParameters)
-    if (!abiItem) throw new AbiErrorNotFoundError(errorName, { docsPath })
+    const item = getAbiItem({ abi, args, name: errorName })
+    if (!item) throw new AbiErrorNotFoundError(errorName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'error')
@@ -52,10 +73,10 @@ export function encodeErrorResult<
   const signature = getFunctionSelector(definition)
 
   let data: Hex = '0x'
-  if (args && (args as readonly unknown[]).length > 0) {
+  if (args && args.length > 0) {
     if (!abiItem.inputs)
       throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath })
-    data = encodeAbiParameters(abiItem.inputs, args as readonly unknown[])
+    data = encodeAbiParameters(abiItem.inputs, args)
   }
   return concatHex([signature, data])
 }

package/src/utils/abi/encodeEventTopics.ts

@@ -1,55 +1,74 @@
-import type { Abi, AbiParameter, AbiParameterToPrimitiveType } from 'abitype'
+import type {
+  Abi,
+  AbiParameter,
+  AbiParameterToPrimitiveType,
+  ExtractAbiEvents,
+} from 'abitype'
 
 import { AbiEventNotFoundError } from '../../errors/abi.js'
 import { FilterTypeNotSupportedError } from '../../errors/log.js'
 import type {
-  AbiItem,
+  ContractEventArgs,
+  ContractEventName,
   EventDefinition,
-  GetEventArgs,
-  InferEventName,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import { toBytes } from '../encoding/toBytes.js'
 import { getEventSelector } from '../hash/getEventSelector.js'
 import { keccak256 } from '../hash/keccak256.js'
 
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
+import { getAbiItem } from './getAbiItem.js'
+
+const docsPath = '/docs/contract/encodeEventTopics'
 
 export type EncodeEventTopicsParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string | undefined = string,
-  _EventName = InferEventName<TAbi, TEventName>,
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> | undefined = ContractEventName<abi>,
+  ///
+  hasEvents = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [ExtractAbiEvents<abi>] extends [never]
+      ? false
+      : true
+    : true,
+  allArgs = ContractEventArgs<
+    abi,
+    eventName extends ContractEventName<abi>
+      ? eventName
+      : ContractEventName<abi>
+  >,
+  allErrorNames = ContractEventName<abi>,
 > = {
-  eventName?: _EventName
-} & (TEventName extends string
-  ? { abi: TAbi; args?: GetEventArgs<TAbi, TEventName> }
-  : _EventName extends string
-  ? { abi: [TAbi[number]]; args?: GetEventArgs<TAbi, _EventName> }
-  : never)
+  abi: abi
+  args?: allArgs | undefined
+} & UnionEvaluate<
+  IsNarrowable<abi, Abi> extends true
+    ? abi['length'] extends 1
+      ? { eventName?: eventName | allErrorNames }
+      : { eventName: eventName | allErrorNames }
+    : { eventName?: eventName | allErrorNames }
+> &
+  (hasEvents extends true ? unknown : never)
 
 export function encodeEventTopics<
-  const TAbi extends Abi | readonly unknown[],
-  TEventName extends string | undefined = undefined,
->({ abi, eventName, args }: EncodeEventTopicsParameters<TAbi, TEventName>) {
-  let abiItem = abi[0] as AbiItem
+  const abi extends Abi | readonly unknown[],
+  eventName extends ContractEventName<abi> | undefined = undefined,
+>(parameters: EncodeEventTopicsParameters<abi, eventName>) {
+  const { abi, eventName, args } = parameters as EncodeEventTopicsParameters
+
+  let abiItem = abi[0]
   if (eventName) {
-    abiItem = getAbiItem({
-      abi,
-      args,
-      name: eventName,
-    } as GetAbiItemParameters)
-    if (!abiItem)
-      throw new AbiEventNotFoundError(eventName, {
-        docsPath: '/docs/contract/encodeEventTopics',
-      })
+    const item = getAbiItem({ abi, name: eventName })
+    if (!item) throw new AbiEventNotFoundError(eventName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'event')
-    throw new AbiEventNotFoundError(undefined, {
-      docsPath: '/docs/contract/encodeEventTopics',
-    })
+    throw new AbiEventNotFoundError(undefined, { docsPath })
 
   const definition = formatAbiItem(abiItem)
   const signature = getEventSelector(definition as EventDefinition)

package/src/utils/abi/encodeFunctionData.ts

@@ -1,61 +1,87 @@
-import type { Abi } from 'abitype'
+import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import { AbiFunctionNotFoundError } from '../../errors/abi.js'
 import type {
-  AbiItem,
-  GetFunctionArgs,
-  InferFunctionName,
+  ContractFunctionArgs,
+  ContractFunctionName,
 } from '../../types/contract.js'
 import { concatHex } from '../data/concat.js'
 import { getFunctionSelector } from '../hash/getFunctionSelector.js'
 
+import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
+import { getAbiItem } from './getAbiItem.js'
+
+const docsPath = '/docs/contract/encodeFunctionData'
 
 export type EncodeFunctionDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string | undefined = string,
-  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends
+    | ContractFunctionName<abi>
+    | undefined = ContractFunctionName<abi>,
+  ///
+  hasFunctions = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [ExtractAbiFunctions<abi>] extends [never]
+      ? false
+      : true
+    : true,
+  allArgs = ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  >,
+  allFunctionNames = ContractFunctionName<abi>,
 > = {
-  functionName?: _FunctionName
-} & (TFunctionName extends string
-  ? { abi: TAbi } & GetFunctionArgs<TAbi, TFunctionName>
-  : _FunctionName extends string
-  ? { abi: [TAbi[number]] } & GetFunctionArgs<TAbi, _FunctionName>
-  : never)
+  abi: abi
+} & UnionEvaluate<
+  IsNarrowable<abi, Abi> extends true
+    ? abi['length'] extends 1
+      ? { functionName?: functionName | allFunctionNames }
+      : { functionName: functionName | allFunctionNames }
+    : { functionName?: functionName | allFunctionNames }
+> &
+  UnionEvaluate<
+    readonly [] extends allArgs
+      ? { args?: allArgs | undefined }
+      : { args: allArgs }
+  > &
+  (hasFunctions extends true ? unknown : never)
+
+export type EncodeFunctionDataReturnType = Hex
 
 export function encodeFunctionData<
-  const TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string | undefined = undefined,
->({
-  abi,
-  args,
-  functionName,
-}: EncodeFunctionDataParameters<TAbi, TFunctionName>) {
-  let abiItem = abi[0] as AbiItem
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi> | undefined = undefined,
+>(
+  parameters: EncodeFunctionDataParameters<abi, functionName>,
+): EncodeFunctionDataReturnType {
+  const { abi, args, functionName } = parameters as EncodeFunctionDataParameters
+
+  let abiItem = abi[0]
   if (functionName) {
-    abiItem = getAbiItem({
+    const item = getAbiItem({
       abi,
       args,
       name: functionName,
-    } as GetAbiItemParameters)
-    if (!abiItem)
-      throw new AbiFunctionNotFoundError(functionName, {
-        docsPath: '/docs/contract/encodeFunctionData',
-      })
+    })
+    if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'function')
-    throw new AbiFunctionNotFoundError(undefined, {
-      docsPath: '/docs/contract/encodeFunctionData',
-    })
+    throw new AbiFunctionNotFoundError(undefined, { docsPath })
 
   const definition = formatAbiItem(abiItem)
   const signature = getFunctionSelector(definition)
   const data =
     'inputs' in abiItem && abiItem.inputs
-      ? encodeAbiParameters(abiItem.inputs, (args ?? []) as readonly unknown[])
+      ? encodeAbiParameters(abiItem.inputs, args ?? [])
       : undefined
   return concatHex([signature, data ?? '0x'])
 }

package/src/utils/abi/encodeFunctionResult.ts

@@ -1,59 +1,76 @@
-import type { Abi } from 'abitype'
+import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
   AbiFunctionOutputsNotFoundError,
 } from '../../errors/abi.js'
 import type {
-  AbiItem,
-  ContractFunctionResult,
-  InferFunctionName,
+  ContractFunctionName,
+  ContractFunctionReturnType,
 } from '../../types/contract.js'
 
+import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { encodeAbiParameters } from './encodeAbiParameters.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
+import { getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeFunctionResult'
 
 export type EncodeFunctionResultParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string | undefined = string,
-  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends
+    | ContractFunctionName<abi>
+    | undefined = ContractFunctionName<abi>,
+  ///
+  hasFunctions = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [ExtractAbiFunctions<abi>] extends [never]
+      ? false
+      : true
+    : true,
+  allFunctionNames = ContractFunctionName<abi>,
 > = {
-  functionName?: _FunctionName
-} & (TFunctionName extends string
-  ? { abi: TAbi; result?: ContractFunctionResult<TAbi, TFunctionName> }
-  : _FunctionName extends string
-  ? {
-      abi: [TAbi[number]]
-      result?: ContractFunctionResult<TAbi, _FunctionName>
-    }
-  : never)
+  abi: abi
+  result?:
+    | ContractFunctionReturnType<
+        abi,
+        AbiStateMutability,
+        functionName extends ContractFunctionName<abi>
+          ? functionName
+          : ContractFunctionName<abi>,
+        never // allow all args. required for overloads to work.
+      >
+    | undefined
+} & UnionEvaluate<
+  IsNarrowable<abi, Abi> extends true
+    ? abi['length'] extends 1
+      ? { functionName?: functionName | allFunctionNames }
+      : { functionName: functionName | allFunctionNames }
+    : { functionName?: functionName | allFunctionNames }
+> &
+  (hasFunctions extends true ? unknown : never)
+
+export type EncodeFunctionResultReturnType = Hex
 
 export function encodeFunctionResult<
-  const TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string | undefined = undefined,
->({
-  abi,
-  functionName,
-  result,
-}: EncodeFunctionResultParameters<TAbi, TFunctionName>) {
-  let abiItem = abi[0] as AbiItem
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi> | undefined = undefined,
+>(
+  parameters: EncodeFunctionResultParameters<abi, functionName>,
+): EncodeFunctionResultReturnType {
+  const { abi, functionName, result } =
+    parameters as EncodeFunctionResultParameters
+
+  let abiItem = abi[0]
   if (functionName) {
-    abiItem = getAbiItem({
-      abi,
-      name: functionName,
-    } as GetAbiItemParameters)
-    if (!abiItem)
-      throw new AbiFunctionNotFoundError(functionName, {
-        docsPath: '/docs/contract/encodeFunctionResult',
-      })
+    const item = getAbiItem({ abi, name: functionName })
+    if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'function')
-    throw new AbiFunctionNotFoundError(undefined, {
-      docsPath: '/docs/contract/encodeFunctionResult',
-    })
+    throw new AbiFunctionNotFoundError(undefined, { docsPath })
 
   if (!abiItem.outputs)
     throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath })

package/src/utils/abi/getAbiItem.ts

@@ -1,59 +1,95 @@
 import type { Abi, AbiParameter, Address } from 'abitype'
 
-import type { GetFunctionArgs, InferItemName } from '../../types/contract.js'
+import type {
+  AbiItem,
+  AbiItemArgs,
+  AbiItemName,
+  ExtractAbiItemForArgs,
+  Widen,
+} from '../../types/contract.js'
+import type { UnionEvaluate } from '../../types/utils.js'
 import { isAddress } from '../address/isAddress.js'
 
 export type GetAbiItemParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TItemName extends string = string,
+  abi extends Abi | readonly unknown[] = Abi,
+  name extends AbiItemName<abi> = AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name> | undefined = AbiItemArgs<abi, name>,
+  ///
+  allArgs = AbiItemArgs<abi, name>,
+  allNames = AbiItemName<abi>,
 > = {
-  abi: TAbi
-  name: InferItemName<TAbi, TItemName>
-} & Partial<GetFunctionArgs<TAbi, TItemName>>
+  abi: abi
+  name:
+    | allNames // show all options
+    | (name extends allNames ? name : never) // infer value
+} & UnionEvaluate<
+  readonly [] extends allArgs
+    ? {
+        args?:
+          | allArgs // show all options
+          // infer value, widen inferred value of `args` conditionally to match `allArgs`
+          | (abi extends Abi
+              ? args extends allArgs
+                ? Widen<args>
+                : never
+              : never)
+          | undefined
+      }
+    : {
+        args?:
+          | allArgs // show all options
+          | (Widen<args> & (args extends allArgs ? unknown : never)) // infer value, widen inferred value of `args` match `allArgs` (e.g. avoid union `args: readonly [123n] | readonly [bigint]`)
+          | undefined
+      }
+>
 
 export type GetAbiItemReturnType<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TItemName extends string = string,
-> = Extract<
-  TAbi[number],
-  {
-    name: TItemName
-  }
->
+  abi extends Abi | readonly unknown[] = Abi,
+  name extends AbiItemName<abi> = AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name> | undefined = AbiItemArgs<abi, name>,
+> = abi extends Abi
+  ? Abi extends abi
+    ? AbiItem | undefined
+    : ExtractAbiItemForArgs<
+        abi,
+        name,
+        args extends AbiItemArgs<abi, name> ? args : AbiItemArgs<abi, name>
+      >
+  : AbiItem | undefined
 
 export function getAbiItem<
-  const TAbi extends Abi | readonly unknown[],
-  TItemName extends string,
->({
-  abi,
-  args = [],
-  name,
-}: GetAbiItemParameters<TAbi, TItemName>): GetAbiItemReturnType<
-  TAbi,
-  TItemName
-> {
-  const abiItems = (abi as Abi).filter((x) => 'name' in x && x.name === name)
+  const abi extends Abi | readonly unknown[],
+  name extends AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name> | undefined = undefined,
+>(
+  parameters: GetAbiItemParameters<abi, name, args>,
+): GetAbiItemReturnType<abi, name, args> {
+  const { abi, args = [], name } = parameters as unknown as GetAbiItemParameters
+  const abiItems = abi.filter((x) => 'name' in x && x.name === name)
 
-  if (abiItems.length === 0) return undefined as any
-  if (abiItems.length === 1) return abiItems[0] as any
+  if (abiItems.length === 0)
+    return undefined as GetAbiItemReturnType<abi, name, args>
+  if (abiItems.length === 1)
+    return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 
   for (const abiItem of abiItems) {
     if (!('inputs' in abiItem)) continue
     if (!args || args.length === 0) {
-      if (!abiItem.inputs || abiItem.inputs.length === 0) return abiItem as any
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem as GetAbiItemReturnType<abi, name, args>
       continue
     }
     if (!abiItem.inputs) continue
     if (abiItem.inputs.length === 0) continue
     if (abiItem.inputs.length !== args.length) continue
-    const matched = (args as readonly unknown[]).every((arg, index) => {
+    const matched = args.every((arg, index) => {
       const abiParameter = 'inputs' in abiItem && abiItem.inputs![index]
       if (!abiParameter) return false
-      return isArgOfType(arg, abiParameter as AbiParameter)
+      return isArgOfType(arg, abiParameter)
     })
-    if (matched) return abiItem as any
+    if (matched) return abiItem as GetAbiItemReturnType<abi, name, args>
   }
-  return abiItems[0] as any
+  return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 }
 
 export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {

package/src/utils/buildRequest.ts

@@ -126,6 +126,10 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
             // 4902
             case SwitchChainError.code:
               throw new SwitchChainError(err)
+            // CAIP-25: User Rejected Error
+            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
+            case 5000:
+              throw new UserRejectedRequestError(err)
             default:
               if (err_ instanceof BaseError) throw err_
               throw new UnknownRpcError(err as Error)

package/src/utils/ccip.ts

@@ -10,7 +10,6 @@ import {
 } from '../errors/ccip.js'
 import { HttpRequestError } from '../errors/request.js'
 import type { Chain } from '../types/chain.js'
-import type { GetErrorArgs } from '../types/contract.js'
 import type { Hex } from '../types/misc.js'
 
 import type { Client } from '../clients/createClient.js'
@@ -64,10 +63,7 @@ export async function offchainLookup<TChain extends Chain | undefined,>(
   const { args } = decodeErrorResult({
     data,
     abi: [offchainLookupAbiItem],
-  }) as unknown as GetErrorArgs<
-    [typeof offchainLookupAbiItem],
-    'OffchainLookup'
-  >
+  })
   const [sender, urls, callData, callbackSelector, extraData] = args
 
   try {

package/src/utils/chain.ts

@@ -26,7 +26,7 @@ export function assertCurrentChain({
 }
 
 export function defineChain<
-  chain extends Chain,
+  const chain extends Chain,
   formatters extends ChainFormatters,
 >(
   chain: chain,

package/src/utils/errors/getCallError.ts

@@ -1,13 +1,10 @@
 import type { CallParameters } from '../../actions/public/call.js'
 import type { BaseError } from '../../errors/base.js'
 import { CallExecutionError } from '../../errors/contract.js'
+import { UnknownNodeError } from '../../errors/node.js'
 import type { Chain } from '../../types/chain.js'
 
-import {
-  type GetNodeErrorParameters,
-  containsNodeError,
-  getNodeError,
-} from './getNodeError.js'
+import { type GetNodeErrorParameters, getNodeError } from './getNodeError.js'
 
 export function getCallError(
   err: BaseError,
@@ -19,9 +16,8 @@ export function getCallError(
     docsPath?: string
   },
 ) {
-  let cause = err
-  if (containsNodeError(err))
-    cause = getNodeError(err, args as GetNodeErrorParameters)
+  let cause = getNodeError(err, args as GetNodeErrorParameters)
+  if (cause instanceof UnknownNodeError) cause = err
   return new CallExecutionError(cause, {
     docsPath,
     ...args,

package/src/utils/errors/getContractError.ts

@@ -8,6 +8,7 @@ import {
   ContractFunctionZeroDataError,
   RawContractError,
 } from '../../errors/contract.js'
+import { InternalRpcError } from '../../errors/rpc.js'
 
 const EXECUTION_REVERTED_ERROR_CODE = 3
 
@@ -41,7 +42,7 @@ export function getContractError(
   if (err instanceof AbiDecodingZeroDataError) {
     cause = new ContractFunctionZeroDataError({ functionName })
   } else if (
-    code === EXECUTION_REVERTED_ERROR_CODE &&
+    [EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) &&
     (data || message || shortMessage)
   ) {
     cause = new ContractFunctionRevertedError({