viem 0.3.17 → 0.3.19

package/src/utils/abi/decodeDeployData.ts

@@ -1,10 +1,12 @@
-import type { Abi } from 'abitype'
+import type { Abi, Narrow } from 'abitype'
 
 import {
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
-} from '../../errors/index.js'
-import type { Hex } from '../../types/index.js'
+} from '../../errors/abi.js'
+import type { GetConstructorArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 
 const docsPath = '/docs/contract/decodeDeployData'
@@ -12,21 +14,22 @@ const docsPath = '/docs/contract/decodeDeployData'
 export type DecodeDeployDataParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
 > = {
-  abi: TAbi
+  abi: Narrow<TAbi>
   bytecode: Hex
   data: Hex
 }
-export type DecodeDeployDataReturnType = {
-  args?: readonly unknown[] | undefined
+export type DecodeDeployDataReturnType<
+  TAbi extends Abi | readonly unknown[] = Abi,
+> = {
   bytecode: Hex
-}
+} & GetConstructorArgs<TAbi>
 
 export function decodeDeployData<TAbi extends Abi | readonly unknown[]>({
   abi,
   bytecode,
   data,
-}: DecodeDeployDataParameters<TAbi>): DecodeDeployDataReturnType {
-  if (data === bytecode) return { bytecode }
+}: DecodeDeployDataParameters<TAbi>): DecodeDeployDataReturnType<TAbi> {
+  if (data === bytecode) return { bytecode } as DecodeDeployDataReturnType<TAbi>
 
   const description = (abi as Abi).find(
     (x) => 'type' in x && x.type === 'constructor',
@@ -41,5 +44,5 @@ export function decodeDeployData<TAbi extends Abi | readonly unknown[]>({
     description.inputs,
     `0x${data.replace(bytecode, '')}`,
   )
-  return { args, bytecode }
+  return { args, bytecode } as unknown as DecodeDeployDataReturnType<TAbi>
 }

package/src/utils/abi/decodeErrorResult.ts

@@ -1,32 +1,50 @@
-import type { Abi } from 'abitype'
+import type {
+  Abi,
+  ExtractAbiError,
+  ExtractAbiErrorNames,
+  Narrow,
+} from 'abitype'
 
-import { solidityError, solidityPanic } from '../../constants/index.js'
+import { solidityError, solidityPanic } from '../../constants/solidity.js'
 import {
   AbiDecodingZeroDataError,
   AbiErrorSignatureNotFoundError,
-} from '../../errors/index.js'
-import type { AbiItem, Hex } from '../../types/index.js'
-import { slice } from '../data/index.js'
-import { getFunctionSelector } from '../hash/index.js'
+} from '../../errors/abi.js'
+import type { AbiItem, GetErrorArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { slice } from '../data/slice.js'
+import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 
-export type DecodeErrorResultParameters = { abi?: Abi; data: Hex }
+export type DecodeErrorResultParameters<
+  TAbi extends Abi | readonly unknown[] = Abi,
+> = { abi?: Narrow<TAbi>; data: Hex }
 
-export type DecodeErrorResultReturnType = {
-  abiItem: AbiItem
-  errorName: string
-  args?: readonly unknown[]
-}
+export type DecodeErrorResultReturnType<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  _ErrorNames extends string = TAbi extends Abi
+    ? Abi extends TAbi
+      ? string
+      : ExtractAbiErrorNames<TAbi>
+    : string,
+> = {
+  [TName in _ErrorNames]: {
+    abiItem: TAbi extends Abi ? ExtractAbiError<TAbi, TName> : AbiItem
+    args: GetErrorArgs<TAbi, TName>['args']
+    errorName: TName
+  }
+}[_ErrorNames]
 
-export function decodeErrorResult({
+export function decodeErrorResult<TAbi extends Abi | readonly unknown[]>({
   abi,
   data,
-}: DecodeErrorResultParameters): DecodeErrorResultReturnType {
+}: DecodeErrorResultParameters<TAbi>): DecodeErrorResultReturnType<TAbi> {
   const signature = slice(data, 0, 4)
   if (signature === '0x') throw new AbiDecodingZeroDataError()
 
-  const abi_ = [...(abi || []), solidityError, solidityPanic]
+  const abi_ = [...((abi as Abi) || []), solidityError, solidityPanic]
   const abiItem = abi_.find(
     (x) =>
       x.type === 'error' && signature === getFunctionSelector(formatAbiItem(x)),
@@ -41,5 +59,5 @@ export function decodeErrorResult({
       ? decodeAbiParameters(abiItem.inputs, slice(data, 4))
       : undefined) as readonly unknown[] | undefined,
     errorName: (abiItem as { name: string }).name,
-  }
+  } as DecodeErrorResultReturnType<TAbi>
 }

package/src/utils/abi/decodeEventLog.ts

@@ -1,25 +1,27 @@
-import type { Abi, AbiParameter, Narrow } from 'abitype'
+import type { Abi, AbiParameter, ExtractAbiEventNames, Narrow } from 'abitype'
 
-import { DecodeLogDataMismatch } from '../../errors/abi.js'
 import {
   AbiDecodingDataSizeTooSmallError,
   AbiEventSignatureEmptyTopicsError,
   AbiEventSignatureNotFoundError,
+  DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
-} from '../../errors/index.js'
+} from '../../errors/abi.js'
 import type {
   EventDefinition,
   GetEventArgsFromTopics,
-  Hex,
   InferEventName,
-} from '../../types/index.js'
-import { getEventSelector } from '../hash/index.js'
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import type { Prettify } from '../../types/utils.js'
+import { getEventSelector } from '../hash/getEventSelector.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 
 export type DecodeEventLogParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string = string,
+  TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
 > = {
@@ -31,19 +33,34 @@ export type DecodeEventLogParameters<
 
 export type DecodeEventLogReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string = string,
+  TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
-> = {
-  eventName: TEventName
-} & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData>
+  _EventNames extends string = TAbi extends Abi
+    ? Abi extends TAbi
+      ? string
+      : ExtractAbiEventNames<TAbi>
+    : string,
+> = TEventName extends _EventNames[number]
+  ? Prettify<
+      {
+        eventName: TEventName
+      } & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData>
+    >
+  : {
+      [TName in _EventNames]: Prettify<
+        {
+          eventName: TName
+        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData>
+      >
+    }[_EventNames]
 
 const docsPath = '/docs/contract/decodeEventLog'
 
 export function decodeEventLog<
   TAbi extends Abi | readonly unknown[],
-  TEventName extends string,
-  TTopics extends Hex[],
+  TEventName extends string | undefined = undefined,
+  TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
 >({
   abi,

package/src/utils/abi/decodeFunctionData.ts

@@ -1,9 +1,11 @@
 import type { Abi, ExtractAbiFunctionNames } from 'abitype'
 
-import { AbiFunctionSignatureNotFoundError } from '../../errors/index.js'
-import type { GetFunctionArgs, Hex } from '../../types/index.js'
-import { slice } from '../data/index.js'
-import { getFunctionSelector } from '../hash/index.js'
+import { AbiFunctionSignatureNotFoundError } from '../../errors/abi.js'
+import type { GetFunctionArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { slice } from '../data/slice.js'
+import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 

package/src/utils/abi/decodeFunctionResult.ts

@@ -1,38 +1,52 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi, ExtractAbiFunctionNames, Narrow } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
   AbiFunctionOutputsNotFoundError,
-} from '../../errors/index.js'
+} from '../../errors/abi.js'
 import type {
+  AbiItem,
   ContractFunctionResult,
   GetFunctionArgs,
-  Hex,
   InferFunctionName,
-} from '../../types/index.js'
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
-import { getAbiItem } from './getAbiItem.js'
-import type { GetAbiItemParameters } from './getAbiItem.js'
+import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/decodeFunctionResult'
 
 export type DecodeFunctionResultParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
+  TFunctionName extends string | undefined = string,
+  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
 > = {
-  abi: Narrow<TAbi>
-  functionName: InferFunctionName<TAbi, TFunctionName>
+  functionName?: _FunctionName
   data: Hex
-} & Partial<GetFunctionArgs<TAbi, TFunctionName>>
+} & (TFunctionName extends string
+  ? { abi: Narrow<TAbi> } & Partial<GetFunctionArgs<TAbi, TFunctionName>>
+  : _FunctionName extends string
+  ? { abi: [Narrow<TAbi[number]>] } & Partial<
+      GetFunctionArgs<TAbi, _FunctionName>
+    >
+  : never)
 
 export type DecodeFunctionResultReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = ContractFunctionResult<TAbi, TFunctionName>
+  TFunctionName extends string | undefined = string,
+  _FunctionName extends string = TAbi extends Abi
+    ? Abi extends TAbi
+      ? string
+      : ExtractAbiFunctionNames<TAbi>[number]
+    : string,
+> = TFunctionName extends string
+  ? ContractFunctionResult<TAbi, TFunctionName>
+  : ContractFunctionResult<TAbi, _FunctionName>
 
 export function decodeFunctionResult<
   TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  TFunctionName extends string | undefined = undefined,
 >({
   abi,
   args,
@@ -42,17 +56,22 @@ export function decodeFunctionResult<
   TAbi,
   TFunctionName
 >): DecodeFunctionResultReturnType<TAbi, TFunctionName> {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: functionName,
-  } as GetAbiItemParameters)
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName, { docsPath })
-  if (!('outputs' in description))
-    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath })
-
-  const values = decodeAbiParameters(description.outputs, data)
+  let abiItem = abi[0] as AbiItem
+  if (functionName) {
+    abiItem = getAbiItem({
+      abi,
+      args,
+      name: functionName,
+    } as GetAbiItemParameters)
+    if (!abiItem) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+  }
+
+  if (abiItem.type !== 'function')
+    throw new AbiFunctionNotFoundError(undefined, { docsPath })
+  if (!abiItem.outputs)
+    throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath })
+
+  const values = decodeAbiParameters(abiItem.outputs, data)
   if (values && values.length > 1) return values as any
   if (values && values.length === 1) return values[0] as any
   return undefined as any

package/src/utils/abi/encodeAbiParameters.ts

@@ -10,13 +10,16 @@ import {
   AbiEncodingBytesSizeMismatchError,
   AbiEncodingLengthMismatchError,
   InvalidAbiEncodingTypeError,
-  InvalidAddressError,
   InvalidArrayError,
-} from '../../errors/index.js'
-import type { Hex } from '../../types/index.js'
-import { isAddress } from '../address/index.js'
-import { concat, padHex, size, slice } from '../data/index.js'
-import { boolToHex, numberToHex, stringToHex } from '../encoding/index.js'
+} from '../../errors/abi.js'
+import { InvalidAddressError } from '../../errors/address.js'
+import type { Hex } from '../../types/misc.js'
+import { isAddress } from '../address/isAddress.js'
+import { concat } from '../data/concat.js'
+import { padHex } from '../data/pad.js'
+import { size } from '../data/size.js'
+import { slice } from '../data/slice.js'
+import { boolToHex, numberToHex, stringToHex } from '../encoding/toHex.js'
 
 export type EncodeAbiParametersReturnType = Hex
 

package/src/utils/abi/encodeDeployData.ts

@@ -3,9 +3,11 @@ import type { Abi, Narrow } from 'abitype'
 import {
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
-} from '../../errors/index.js'
-import type { GetConstructorArgs, Hex } from '../../types/index.js'
-import { concatHex } from '../data/index.js'
+} from '../../errors/abi.js'
+import type { GetConstructorArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { concatHex } from '../data/concat.js'
+
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 
 const docsPath = '/docs/contract/encodeDeployData'

package/src/utils/abi/encodeErrorResult.ts

@@ -3,43 +3,59 @@ import type { Abi, Narrow } from 'abitype'
 import {
   AbiErrorInputsNotFoundError,
   AbiErrorNotFoundError,
-} from '../../errors/index.js'
-import type { GetErrorArgs, Hex, InferErrorName } from '../../types/index.js'
-import { concatHex } from '../data/index.js'
-import { getFunctionSelector } from '../hash/index.js'
+} from '../../errors/abi.js'
+import type {
+  AbiItem,
+  GetErrorArgs,
+  InferErrorName,
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { concatHex } from '../data/concat.js'
+import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
-import { getAbiItem } from './getAbiItem.js'
-import type { GetAbiItemParameters } from './getAbiItem.js'
+import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeErrorResult'
 
 export type EncodeErrorResultParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TErrorName extends string = string,
+  TErrorName extends string | undefined = string,
+  _ErrorName = InferErrorName<TAbi, TErrorName>,
 > = {
-  abi: Narrow<TAbi>
-  errorName: InferErrorName<TAbi, TErrorName>
-} & GetErrorArgs<TAbi, TErrorName>
+  errorName?: _ErrorName
+} & (TErrorName extends string
+  ? { abi: Narrow<TAbi> } & GetErrorArgs<TAbi, TErrorName>
+  : _ErrorName extends string
+  ? { abi: [Narrow<TAbi[number]>] } & GetErrorArgs<TAbi, _ErrorName>
+  : never)
 
 export function encodeErrorResult<
   TAbi extends Abi | readonly unknown[],
-  TErrorName extends string,
+  TErrorName extends string | undefined = undefined,
 >({ abi, errorName, args }: EncodeErrorResultParameters<TAbi, TErrorName>) {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: errorName,
-  } as GetAbiItemParameters)
-  if (!description) throw new AbiErrorNotFoundError(errorName, { docsPath })
-  const definition = formatAbiItem(description)
+  let abiItem = abi[0] as AbiItem
+  if (errorName) {
+    abiItem = getAbiItem({
+      abi,
+      args,
+      name: errorName,
+    } as GetAbiItemParameters)
+    if (!abiItem) throw new AbiErrorNotFoundError(errorName, { docsPath })
+  }
+
+  if (abiItem.type !== 'error')
+    throw new AbiErrorNotFoundError(undefined, { docsPath })
+
+  const definition = formatAbiItem(abiItem)
   const signature = getFunctionSelector(definition)
 
   let data: Hex = '0x'
   if (args && (args as readonly unknown[]).length > 0) {
-    if (!('inputs' in description && description.inputs))
-      throw new AbiErrorInputsNotFoundError(errorName, { docsPath })
-    data = encodeAbiParameters(description.inputs, args as readonly unknown[])
+    if (!abiItem.inputs)
+      throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath })
+    data = encodeAbiParameters(abiItem.inputs, args as readonly unknown[])
   }
   return concatHex([signature, data])
 }

package/src/utils/abi/encodeEventTopics.ts

@@ -5,45 +5,57 @@ import type {
   Narrow,
 } from 'abitype'
 
-import {
-  AbiEventNotFoundError,
-  FilterTypeNotSupportedError,
-} from '../../errors/index.js'
+import { AbiEventNotFoundError } from '../../errors/abi.js'
+import { FilterTypeNotSupportedError } from '../../errors/log.js'
 import type {
+  AbiItem,
   EventDefinition,
   GetEventArgs,
-  Hex,
   InferEventName,
-} from '../../types/index.js'
-import { toBytes } from '../encoding/index.js'
-import { getEventSelector, keccak256 } from '../hash/index.js'
+} 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 { encodeAbiParameters } from './encodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
-import { getAbiItem } from './getAbiItem.js'
-import type { GetAbiItemParameters } from './getAbiItem.js'
+import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
 
 export type EncodeEventTopicsParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string = string,
+  TEventName extends string | undefined = string,
+  _EventName = InferEventName<TAbi, TEventName>,
 > = {
-  abi: Narrow<TAbi>
-  args?: GetEventArgs<TAbi, TEventName>
-  eventName: InferEventName<TAbi, TEventName>
-}
+  eventName?: _EventName
+} & (TEventName extends string
+  ? { abi: Narrow<TAbi>; args?: GetEventArgs<TAbi, TEventName> }
+  : _EventName extends string
+  ? { abi: [Narrow<TAbi[number]>]; args?: GetEventArgs<TAbi, _EventName> }
+  : never)
 
 export function encodeEventTopics<
   TAbi extends Abi | readonly unknown[],
-  TEventName extends string,
+  TEventName extends string | undefined = undefined,
 >({ abi, eventName, args }: EncodeEventTopicsParameters<TAbi, TEventName>) {
-  const abiItem = getAbiItem({
-    abi,
-    args,
-    name: eventName,
-  } as GetAbiItemParameters)
-  if (!abiItem)
-    throw new AbiEventNotFoundError(eventName, {
+  let abiItem = abi[0] as AbiItem
+  if (eventName) {
+    abiItem = getAbiItem({
+      abi,
+      args,
+      name: eventName,
+    } as GetAbiItemParameters)
+    if (!abiItem)
+      throw new AbiEventNotFoundError(eventName, {
+        docsPath: '/docs/contract/encodeEventTopics',
+      })
+  }
+
+  if (abiItem.type !== 'event')
+    throw new AbiEventNotFoundError(undefined, {
       docsPath: '/docs/contract/encodeEventTopics',
     })
+
   const definition = formatAbiItem(abiItem)
   const signature = getEventSelector(definition as EventDefinition)
 

package/src/utils/abi/encodeFunctionData.ts

@@ -1,47 +1,61 @@
 import type { Abi, Narrow } from 'abitype'
 
-import { AbiFunctionNotFoundError } from '../../errors/index.js'
-import type { GetFunctionArgs, InferFunctionName } from '../../types/index.js'
-import { concatHex } from '../data/index.js'
-import { getFunctionSelector } from '../hash/index.js'
+import { AbiFunctionNotFoundError } from '../../errors/abi.js'
+import type {
+  AbiItem,
+  GetFunctionArgs,
+  InferFunctionName,
+} from '../../types/contract.js'
+import { concatHex } from '../data/concat.js'
+import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
-import { getAbiItem } from './getAbiItem.js'
-import type { GetAbiItemParameters } from './getAbiItem.js'
+import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
 
 export type EncodeFunctionDataParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
+  TFunctionName extends string | undefined = string,
+  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
 > = {
-  abi: Narrow<TAbi>
-  functionName: InferFunctionName<TAbi, TFunctionName>
-} & GetFunctionArgs<TAbi, TFunctionName>
+  functionName?: _FunctionName
+} & (TFunctionName extends string
+  ? { abi: Narrow<TAbi> } & GetFunctionArgs<TAbi, TFunctionName>
+  : _FunctionName extends string
+  ? { abi: [Narrow<TAbi[number]>] } & GetFunctionArgs<TAbi, _FunctionName>
+  : never)
 
 export function encodeFunctionData<
   TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  TFunctionName extends string | undefined = undefined,
 >({
   abi,
   args,
   functionName,
 }: EncodeFunctionDataParameters<TAbi, TFunctionName>) {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: functionName,
-  } as GetAbiItemParameters)
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName, {
+  let abiItem = abi[0] as AbiItem
+  if (functionName) {
+    abiItem = getAbiItem({
+      abi,
+      args,
+      name: functionName,
+    } as GetAbiItemParameters)
+    if (!abiItem)
+      throw new AbiFunctionNotFoundError(functionName, {
+        docsPath: '/docs/contract/encodeFunctionData',
+      })
+  }
+
+  if (abiItem.type !== 'function')
+    throw new AbiFunctionNotFoundError(undefined, {
       docsPath: '/docs/contract/encodeFunctionData',
     })
-  const definition = formatAbiItem(description)
+
+  const definition = formatAbiItem(abiItem)
   const signature = getFunctionSelector(definition)
   const data =
-    'inputs' in description && description.inputs
-      ? encodeAbiParameters(
-          description.inputs,
-          (args ?? []) as readonly unknown[],
-        )
+    'inputs' in abiItem && abiItem.inputs
+      ? encodeAbiParameters(abiItem.inputs, (args ?? []) as readonly unknown[])
       : undefined
   return concatHex([signature, data ?? '0x'])
 }