viem 0.4.0-main.20230430T212953 → 1.0.0

package/src/utils/abi/decodeEventLog.ts

@@ -1,59 +1,84 @@
-import type { Abi, AbiParameter, Narrow } from 'abitype'
+import type { Abi, AbiParameter, ExtractAbiEventNames, Narrow } from 'abitype'
+
 import {
   AbiDecodingDataSizeTooSmallError,
   AbiEventSignatureEmptyTopicsError,
   AbiEventSignatureNotFoundError,
+  DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
-} from '../../errors/index.js'
+} from '../../errors/abi.js'
 import type {
   EventDefinition,
   GetEventArgsFromTopics,
   InferEventName,
-  Hex,
-} 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'
-import { DecodeLogDataMismatch } from '../../errors/abi.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,
+  TStrict extends boolean = true,
 > = {
   abi: Narrow<TAbi>
   data?: TData
   eventName?: InferEventName<TAbi, TEventName>
+  strict?: TStrict
   topics: [signature: Hex, ...args: TTopics] | []
 }
 
 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>
+  TStrict extends boolean = true,
+  _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, TStrict>
+    >
+  : {
+      [TName in _EventNames]: Prettify<
+        {
+          eventName: TName
+        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData, TStrict>
+      >
+    }[_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,
+  TStrict extends boolean = true,
 >({
   abi,
   data,
+  strict: strict_,
   topics,
 }: DecodeEventLogParameters<
   TAbi,
   TEventName,
   TTopics,
-  TData
->): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData> {
+  TData,
+  TStrict
+>): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData, TStrict> {
+  const strict = strict_ ?? true
   const [signature, ...argTopics] = topics
   if (!signature)
     throw new AbiEventSignatureEmptyTopicsError({
@@ -64,7 +89,7 @@ export function decodeEventLog<
       x.type === 'event' &&
       signature === getEventSelector(formatAbiItem(x) as EventDefinition),
   )
-  if (!(abiItem && 'name' in abiItem))
+  if (!(abiItem && 'name' in abiItem) || abiItem.type !== 'event')
     throw new AbiEventSignatureNotFoundError(signature, {
       docsPath,
     })
@@ -75,8 +100,8 @@ export function decodeEventLog<
   let args: any = isUnnamed ? [] : {}
 
   // Decode topics (indexed args).
+  const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
   if (argTopics.length > 0) {
-    const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
     for (let i = 0; i < indexedInputs.length; i++) {
       const param = indexedInputs[i]
       const topic = argTopics[i]
@@ -90,33 +115,51 @@ export function decodeEventLog<
   }
 
   // Decode data (non-indexed args).
-  if (data && data !== '0x') {
-    const params = inputs.filter((x) => !('indexed' in x && x.indexed))
-    try {
-      const decodedData = decodeAbiParameters(params, data)
-      if (decodedData) {
-        if (isUnnamed) args = [...args, ...decodedData]
-        else {
-          for (let i = 0; i < params.length; i++) {
-            args[params[i].name!] = decodedData[i]
+  const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed))
+  if (nonIndexedInputs.length > 0) {
+    if (data && data !== '0x') {
+      try {
+        const decodedData = decodeAbiParameters(nonIndexedInputs, data)
+        if (decodedData) {
+          if (isUnnamed) args = [...args, ...decodedData]
+          else {
+            for (let i = 0; i < nonIndexedInputs.length; i++) {
+              args[nonIndexedInputs[i].name!] = decodedData[i]
+            }
           }
         }
+      } catch (err) {
+        if (strict) {
+          if (err instanceof AbiDecodingDataSizeTooSmallError)
+            throw new DecodeLogDataMismatch({
+              abiItem,
+              data: err.data,
+              params: err.params,
+              size: err.size,
+            })
+          throw err
+        }
       }
-    } catch (err) {
-      if (err instanceof AbiDecodingDataSizeTooSmallError)
-        throw new DecodeLogDataMismatch({
-          data: err.data,
-          params: err.params,
-          size: err.size,
-        })
-      throw err
+    } else if (strict) {
+      throw new DecodeLogDataMismatch({
+        abiItem,
+        data: '0x',
+        params: nonIndexedInputs,
+        size: 0,
+      })
     }
   }
 
   return {
     eventName: name,
     args: Object.values(args).length > 0 ? args : undefined,
-  } as unknown as DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData>
+  } as unknown as DecodeEventLogReturnType<
+    TAbi,
+    TEventName,
+    TTopics,
+    TData,
+    TStrict
+  >
 }
 
 function decodeTopic({ param, value }: { param: AbiParameter; value: Hex }) {

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,37 +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,
   InferFunctionName,
-  ContractFunctionResult,
-  Hex,
-} 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,
@@ -41,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

@@ -1,7 +1,7 @@
 import type {
   AbiParameter,
-  AbiParametersToPrimitiveTypes,
   AbiParameterToPrimitiveType,
+  AbiParametersToPrimitiveTypes,
   Narrow,
 } from 'abitype'
 
@@ -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

@@ -1,44 +1,61 @@
 import type { Abi, Narrow } from 'abitype'
+
 import {
   AbiErrorInputsNotFoundError,
   AbiErrorNotFoundError,
-} from '../../errors/index.js'
-import type { GetErrorArgs, InferErrorName, Hex } 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,57 +5,74 @@ 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,
   InferEventName,
-  Hex,
-} 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)
 
   let topics: Hex[] = []
   if (args && 'inputs' in abiItem) {
+    const indexedInputs = abiItem.inputs?.filter(
+      (param) => 'indexed' in param && param.indexed,
+    )
     const args_ = Array.isArray(args)
       ? args
-      : abiItem.inputs?.map((x: any) => (args as any)[x.name]) ?? []
-    topics =
-      abiItem.inputs
-        ?.filter((param) => 'indexed' in param && param.indexed)
-        .map((param, i) =>
+      : Object.values(args).length > 0
+      ? indexedInputs?.map((x: any) => (args as any)[x.name]) ?? []
+      : []
+
+    if (args_.length > 0) {
+      topics =
+        indexedInputs?.map((param, i) =>
           Array.isArray(args_[i])
             ? args_[i].map((_: any, j: number) =>
                 encodeArg({ param, value: args_[i][j] }),
@@ -64,6 +81,7 @@ export function encodeEventTopics<
             ? encodeArg({ param, value: args_[i] })
             : null,
         ) ?? []
+    }
   }
   return [signature, ...topics]
 }

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'])
 }