viem 1.10.9 → 2.0.0-alpha.1

package/src/utils/abi/decodeEventLog.ts

@@ -1,175 +0,0 @@
-import type { Abi, AbiParameter, ExtractAbiEventNames } from 'abitype'
-
-import {
-  AbiDecodingDataSizeTooSmallError,
-  AbiEventSignatureEmptyTopicsError,
-  AbiEventSignatureNotFoundError,
-  DecodeLogDataMismatch,
-  DecodeLogTopicsMismatch,
-} from '../../errors/abi.js'
-import type {
-  EventDefinition,
-  GetEventArgsFromTopics,
-  InferEventName,
-} 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 | undefined = string,
-  TTopics extends Hex[] = Hex[],
-  TData extends Hex | undefined = undefined,
-  TStrict extends boolean = true,
-> = {
-  abi: 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 | undefined = string,
-  TTopics extends Hex[] = Hex[],
-  TData extends Hex | undefined = undefined,
-  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<
-  const TAbi extends Abi | readonly unknown[],
-  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,
-  TStrict
->): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData, TStrict> {
-  const strict = strict_ ?? true
-  const [signature, ...argTopics] = topics
-  if (!signature)
-    throw new AbiEventSignatureEmptyTopicsError({
-      docsPath,
-    })
-  const abiItem = (abi as Abi).find(
-    (x) =>
-      x.type === 'event' &&
-      signature === getEventSelector(formatAbiItem(x) as EventDefinition),
-  )
-  if (!(abiItem && 'name' in abiItem) || abiItem.type !== 'event')
-    throw new AbiEventSignatureNotFoundError(signature, {
-      docsPath,
-    })
-
-  const { name, inputs } = abiItem
-  const isUnnamed = inputs?.some((x) => !('name' in x && x.name))
-
-  let args: any = isUnnamed ? [] : {}
-
-  // Decode topics (indexed args).
-  const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
-  if (argTopics.length > 0) {
-    for (let i = 0; i < indexedInputs.length; i++) {
-      const param = indexedInputs[i]
-      const topic = argTopics[i]
-      if (!topic)
-        throw new DecodeLogTopicsMismatch({
-          abiItem,
-          param: param as AbiParameter & { indexed: boolean },
-        })
-      args[param.name || i] = decodeTopic({ param, value: topic })
-    }
-  }
-
-  // Decode data (non-indexed args).
-  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
-        }
-      }
-    } 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,
-    TStrict
-  >
-}
-
-function decodeTopic({ param, value }: { param: AbiParameter; value: Hex }) {
-  if (
-    param.type === 'string' ||
-    param.type === 'bytes' ||
-    param.type === 'tuple' ||
-    param.type.match(/^(.*)\[(\d+)?\]$/)
-  )
-    return value
-  const decodedArg = decodeAbiParameters([param], value) || []
-  return decodedArg[0]
-}

package/src/utils/abi/decodeFunctionData.ts

@@ -1,55 +0,0 @@
-import type { Abi, ExtractAbiFunctionNames } from 'abitype'
-
-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'
-
-export type DecodeFunctionDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-> = {
-  abi: TAbi
-  data: Hex
-}
-
-export type DecodeFunctionDataReturnType<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  _FunctionNames extends string = TAbi extends Abi
-    ? Abi extends TAbi
-      ? string
-      : ExtractAbiFunctionNames<TAbi>
-    : string,
-> = {
-  [TName in _FunctionNames]: {
-    args: GetFunctionArgs<TAbi, TName>['args']
-    functionName: TName
-  }
-}[_FunctionNames]
-
-export function decodeFunctionData<TAbi extends Abi | readonly unknown[]>({
-  abi,
-  data,
-}: DecodeFunctionDataParameters<TAbi>) {
-  const signature = slice(data, 0, 4)
-  const description = (abi as Abi).find(
-    (x) =>
-      x.type === 'function' &&
-      signature === getFunctionSelector(formatAbiItem(x)),
-  )
-  if (!description)
-    throw new AbiFunctionSignatureNotFoundError(signature, {
-      docsPath: '/docs/contract/decodeFunctionData',
-    })
-  return {
-    functionName: (description as { name: string }).name,
-    args: ('inputs' in description &&
-    description.inputs &&
-    description.inputs.length > 0
-      ? decodeAbiParameters(description.inputs, slice(data, 4))
-      : undefined) as readonly unknown[] | undefined,
-  } as DecodeFunctionDataReturnType<TAbi>
-}

package/src/utils/abi/decodeFunctionResult.ts

@@ -1,76 +0,0 @@
-import type { Abi, ExtractAbiFunctionNames } from 'abitype'
-
-import {
-  AbiFunctionNotFoundError,
-  AbiFunctionOutputsNotFoundError,
-} from '../../errors/abi.js'
-import type {
-  AbiItem,
-  ContractFunctionResult,
-  GetFunctionArgs,
-  InferFunctionName,
-} from '../../types/contract.js'
-import type { Hex } from '../../types/misc.js'
-
-import { decodeAbiParameters } from './decodeAbiParameters.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 | undefined = string,
-  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
-> = {
-  functionName?: _FunctionName
-  data: Hex
-} & (TFunctionName extends string
-  ? { abi: TAbi } & Partial<GetFunctionArgs<TAbi, TFunctionName>>
-  : _FunctionName extends string
-  ? { abi: [TAbi[number]] } & Partial<GetFunctionArgs<TAbi, _FunctionName>>
-  : never)
-
-export type DecodeFunctionResultReturnType<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  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<
-  const TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string | undefined = undefined,
->({
-  abi,
-  args,
-  functionName,
-  data,
-}: DecodeFunctionResultParameters<
-  TAbi,
-  TFunctionName
->): DecodeFunctionResultReturnType<TAbi, TFunctionName> {
-  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/encodeDeployData.ts

@@ -1,43 +0,0 @@
-import type { Abi } from 'abitype'
-
-import {
-  AbiConstructorNotFoundError,
-  AbiConstructorParamsNotFoundError,
-} 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'
-
-export type EncodeDeployDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-> = {
-  abi: TAbi
-  bytecode: Hex
-} & GetConstructorArgs<TAbi>
-
-export function encodeDeployData<const TAbi extends Abi | readonly unknown[]>({
-  abi,
-  args,
-  bytecode,
-}: EncodeDeployDataParameters<TAbi>) {
-  if (!args || args.length === 0) return bytecode
-
-  const description = (abi as Abi).find(
-    (x) => 'type' in x && x.type === 'constructor',
-  )
-  if (!description) throw new AbiConstructorNotFoundError({ docsPath })
-  if (!('inputs' in description))
-    throw new AbiConstructorParamsNotFoundError({ docsPath })
-  if (!description.inputs || description.inputs.length === 0)
-    throw new AbiConstructorParamsNotFoundError({ docsPath })
-
-  const data = encodeAbiParameters(
-    description.inputs,
-    args as readonly unknown[],
-  )
-  return concatHex([bytecode, data!])
-}

package/src/utils/abi/encodeErrorResult.ts

@@ -1,61 +0,0 @@
-import type { Abi } from 'abitype'
-
-import {
-  AbiErrorInputsNotFoundError,
-  AbiErrorNotFoundError,
-} 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 { type GetAbiItemParameters, 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>,
-> = {
-  errorName?: _ErrorName
-} & (TErrorName extends string
-  ? { abi: TAbi } & GetErrorArgs<TAbi, TErrorName>
-  : _ErrorName extends string
-  ? { abi: [TAbi[number]] } & GetErrorArgs<TAbi, _ErrorName>
-  : never)
-
-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
-  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 (!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

@@ -1,93 +0,0 @@
-import type { Abi, AbiParameter, AbiParameterToPrimitiveType } from 'abitype'
-
-import { AbiEventNotFoundError } from '../../errors/abi.js'
-import { FilterTypeNotSupportedError } from '../../errors/log.js'
-import type {
-  AbiItem,
-  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 { encodeAbiParameters } from './encodeAbiParameters.js'
-import { formatAbiItem } from './formatAbiItem.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
-
-export type EncodeEventTopicsParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string | undefined = string,
-  _EventName = InferEventName<TAbi, TEventName>,
-> = {
-  eventName?: _EventName
-} & (TEventName extends string
-  ? { abi: TAbi; args?: GetEventArgs<TAbi, TEventName> }
-  : _EventName extends string
-  ? { abi: [TAbi[number]]; args?: GetEventArgs<TAbi, _EventName> }
-  : 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
-  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
-      : 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] }),
-              )
-            : args_[i]
-            ? encodeArg({ param, value: args_[i] })
-            : null,
-        ) ?? []
-    }
-  }
-  return [signature, ...topics]
-}
-
-function encodeArg({
-  param,
-  value,
-}: { param: AbiParameter; value: AbiParameterToPrimitiveType<AbiParameter> }) {
-  if (param.type === 'string' || param.type === 'bytes')
-    return keccak256(toBytes(value as string))
-  if (param.type === 'tuple' || param.type.match(/^(.*)\[(\d+)?\]$/))
-    throw new FilterTypeNotSupportedError(param.type)
-  return encodeAbiParameters([param], [value])
-}

package/src/utils/abi/encodeFunctionData.ts

@@ -1,61 +0,0 @@
-import type { Abi } from 'abitype'
-
-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 { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
-
-export type EncodeFunctionDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string | undefined = string,
-  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
-> = {
-  functionName?: _FunctionName
-} & (TFunctionName extends string
-  ? { abi: TAbi } & GetFunctionArgs<TAbi, TFunctionName>
-  : _FunctionName extends string
-  ? { abi: [TAbi[number]] } & GetFunctionArgs<TAbi, _FunctionName>
-  : never)
-
-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
-  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(abiItem)
-  const signature = getFunctionSelector(definition)
-  const data =
-    'inputs' in abiItem && abiItem.inputs
-      ? encodeAbiParameters(abiItem.inputs, (args ?? []) as readonly unknown[])
-      : undefined
-  return concatHex([signature, data ?? '0x'])
-}

package/src/utils/abi/encodeFunctionResult.ts

@@ -1,65 +0,0 @@
-import type { Abi } from 'abitype'
-
-import {
-  AbiFunctionNotFoundError,
-  AbiFunctionOutputsNotFoundError,
-} from '../../errors/abi.js'
-import type {
-  AbiItem,
-  ContractFunctionResult,
-  InferFunctionName,
-} from '../../types/contract.js'
-
-import { encodeAbiParameters } from './encodeAbiParameters.js'
-import { type GetAbiItemParameters, 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>,
-> = {
-  functionName?: _FunctionName
-} & (TFunctionName extends string
-  ? { abi: TAbi; result?: ContractFunctionResult<TAbi, TFunctionName> }
-  : _FunctionName extends string
-  ? {
-      abi: [TAbi[number]]
-      result?: ContractFunctionResult<TAbi, _FunctionName>
-    }
-  : never)
-
-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
-  if (functionName) {
-    abiItem = getAbiItem({
-      abi,
-      name: functionName,
-    } as GetAbiItemParameters)
-    if (!abiItem)
-      throw new AbiFunctionNotFoundError(functionName, {
-        docsPath: '/docs/contract/encodeFunctionResult',
-      })
-  }
-
-  if (abiItem.type !== 'function')
-    throw new AbiFunctionNotFoundError(undefined, {
-      docsPath: '/docs/contract/encodeFunctionResult',
-    })
-
-  if (!abiItem.outputs)
-    throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath })
-
-  let values = Array.isArray(result) ? result : [result]
-  if (abiItem.outputs.length === 0 && !values[0]) values = []
-
-  return encodeAbiParameters(abiItem.outputs, values)
-}