viem 0.0.0-main.20240103T193024 → 0.0.0-main.20240103T193934

package/utils/abi/decodeFunctionData.ts

@@ -1,15 +1,18 @@
-import type { Abi, ExtractAbiFunctionNames } from 'abitype'
+import type { Abi, AbiStateMutability } from 'abitype'
 
 import { AbiFunctionSignatureNotFoundError } from '../../errors/abi.js'
-import type { GetFunctionArgs } from '../../types/contract.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { type SliceErrorType, slice } from '../data/slice.js'
 import {
   type GetFunctionSelectorErrorType,
   getFunctionSelector,
 } from '../hash/getFunctionSelector.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import {
   type DecodeAbiParametersErrorType,
   decodeAbiParameters,
@@ -17,25 +20,30 @@ import {
 import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
 
 export type DecodeFunctionDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
+  abi extends Abi | readonly unknown[] = Abi,
 > = {
-  abi: TAbi
+  abi: abi
   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]
+  abi extends Abi | readonly unknown[] = Abi,
+  ///
+  allFunctionNames extends
+    ContractFunctionName<abi> = ContractFunctionName<abi>,
+> = IsNarrowable<abi, Abi> extends true
+  ? UnionEvaluate<
+      {
+        [functionName in allFunctionNames]: {
+          args: ContractFunctionArgs<abi, AbiStateMutability, functionName>
+          functionName: functionName
+        }
+      }[allFunctionNames]
+    >
+  : {
+      args: readonly unknown[] | undefined
+      functionName: string
+    }
 
 export type DecodeFunctionDataErrorType =
   | AbiFunctionSignatureNotFoundError
@@ -45,12 +53,12 @@ export type DecodeFunctionDataErrorType =
   | SliceErrorType
   | ErrorType
 
-export function decodeFunctionData<TAbi extends Abi | readonly unknown[]>({
-  abi,
-  data,
-}: DecodeFunctionDataParameters<TAbi>) {
+export function decodeFunctionData<const abi extends Abi | readonly unknown[]>(
+  parameters: DecodeFunctionDataParameters<abi>,
+) {
+  const { abi, data } = parameters as DecodeFunctionDataParameters
   const signature = slice(data, 0, 4)
-  const description = (abi as Abi).find(
+  const description = abi.find(
     (x) =>
       x.type === 'function' &&
       signature === getFunctionSelector(formatAbiItem(x)),
@@ -66,5 +74,5 @@ export function decodeFunctionData<TAbi extends Abi | readonly unknown[]>({
     description.inputs.length > 0
       ? decodeAbiParameters(description.inputs, slice(data, 4))
       : undefined) as readonly unknown[] | undefined,
-  } as DecodeFunctionDataReturnType<TAbi>
+  } as DecodeFunctionDataReturnType<abi>
 }

package/utils/abi/decodeFunctionResult.ts

@@ -1,4 +1,4 @@
-import type { Abi, ExtractAbiFunctionNames } from 'abitype'
+import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
@@ -7,50 +7,115 @@ import {
   type AbiFunctionOutputsNotFoundErrorType,
 } from '../../errors/abi.js'
 import type {
-  AbiItem,
-  ContractFunctionResult,
-  GetFunctionArgs,
-  InferFunctionName,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionReturnType,
+  Widen,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 
 import type { ErrorType } from '../../errors/utils.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import {
   type DecodeAbiParametersErrorType,
   decodeAbiParameters,
 } from './decodeAbiParameters.js'
-import {
-  type GetAbiItemErrorType,
-  type GetAbiItemParameters,
-  getAbiItem,
-} from './getAbiItem.js'
+import { type GetAbiItemErrorType, 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>,
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends
+    | ContractFunctionName<abi>
+    | undefined = ContractFunctionName<abi>,
+  args extends ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  > = ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : 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
+  abi: abi
   data: Hex
-} & (TFunctionName extends string
-  ? { abi: TAbi } & Partial<GetFunctionArgs<TAbi, TFunctionName>>
-  : _FunctionName extends string
-    ? { abi: [TAbi[number]] } & Partial<GetFunctionArgs<TAbi, _FunctionName>>
-    : never)
+} & 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 // 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
+        }
+  > &
+  (hasFunctions extends true ? unknown : 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>
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends
+    | ContractFunctionName<abi>
+    | undefined = ContractFunctionName<abi>,
+  args extends ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  > = ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  >,
+> = ContractFunctionReturnType<
+  abi,
+  AbiStateMutability,
+  functionName extends ContractFunctionName<abi>
+    ? functionName
+    : ContractFunctionName<abi>,
+  args
+>
 
 export type DecodeFunctionResultErrorType =
   | AbiFunctionNotFoundErrorType
@@ -60,25 +125,32 @@ export type DecodeFunctionResultErrorType =
   | ErrorType
 
 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
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi> | undefined = undefined,
+  args extends ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  > = ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  >,
+>(
+  parameters: DecodeFunctionResultParameters<abi, functionName, args>,
+): DecodeFunctionResultReturnType<abi, functionName, args> {
+  const { abi, args, functionName, data } =
+    parameters as DecodeFunctionResultParameters
+
+  let abiItem = abi[0]
   if (functionName) {
-    abiItem = getAbiItem({
-      abi,
-      args,
-      name: functionName,
-    } as GetAbiItemParameters)
-    if (!abiItem) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+    const item = getAbiItem({ abi, args, name: functionName })
+    if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'function')
@@ -87,7 +159,9 @@ export function decodeFunctionResult<
     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
+  if (values && values.length > 1)
+    return values as DecodeFunctionResultReturnType<abi, functionName, args>
+  if (values && values.length === 1)
+    return values[0] as DecodeFunctionResultReturnType<abi, functionName, args>
+  return undefined as DecodeFunctionResultReturnType<abi, functionName, args>
 }

package/utils/abi/encodeDeployData.ts

@@ -5,11 +5,11 @@ import {
   type AbiConstructorNotFoundErrorType,
   AbiConstructorParamsNotFoundError,
 } from '../../errors/abi.js'
-import type { GetConstructorArgs } from '../../types/contract.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { ContractConstructorArgs } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { UnionEvaluate } from '../../types/utils.js'
 import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,
@@ -18,11 +18,27 @@ import {
 const docsPath = '/docs/contract/encodeDeployData'
 
 export type EncodeDeployDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
+  abi extends Abi | readonly unknown[] = Abi,
+  ///
+  hasConstructor = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [Extract<abi[number], { type: 'constructor' }>] extends [never]
+        ? false
+        : true
+    : true,
+  allArgs = ContractConstructorArgs<abi>,
 > = {
-  abi: TAbi
+  abi: abi
   bytecode: Hex
-} & GetConstructorArgs<TAbi>
+} & UnionEvaluate<
+  readonly [] extends allArgs
+    ? { args?: allArgs | undefined }
+    : { args: allArgs }
+> &
+  (hasConstructor extends true ? unknown : never)
+
+export type EncodeDeployDataReturnType = Hex
 
 export type EncodeDeployDataErrorType =
   | AbiConstructorNotFoundErrorType
@@ -30,25 +46,19 @@ export type EncodeDeployDataErrorType =
   | EncodeAbiParametersErrorType
   | ErrorType
 
-export function encodeDeployData<const TAbi extends Abi | readonly unknown[]>({
-  abi,
-  args,
-  bytecode,
-}: EncodeDeployDataParameters<TAbi>) {
+export function encodeDeployData<const abi extends Abi | readonly unknown[]>(
+  parameters: EncodeDeployDataParameters<abi>,
+): EncodeDeployDataReturnType {
+  const { abi, args, bytecode } = parameters as EncodeDeployDataParameters
   if (!args || args.length === 0) return bytecode
 
-  const description = (abi as Abi).find(
-    (x) => 'type' in x && x.type === 'constructor',
-  )
+  const description = 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[],
-  )
+  const data = encodeAbiParameters(description.inputs, args)
   return concatHex([bytecode, data!])
 }

package/utils/abi/encodeErrorResult.ts

@@ -1,13 +1,12 @@
-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 { type ConcatHexErrorType, concatHex } from '../data/concat.js'
@@ -17,30 +16,47 @@ import {
 } from '../hash/getFunctionSelector.js'
 
 import type { ErrorType } from '../../errors/utils.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,
 } from './encodeAbiParameters.js'
 import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
-import {
-  type GetAbiItemErrorType,
-  type GetAbiItemParameters,
-  getAbiItem,
-} from './getAbiItem.js'
+import { type GetAbiItemErrorType, 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 type EncodeErrorResultErrorType =
   | GetAbiItemErrorType
@@ -51,17 +67,18 @@ export type EncodeErrorResultErrorType =
   | ErrorType
 
 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')
@@ -71,10 +88,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/utils/abi/encodeEventTopics.ts

@@ -1,4 +1,9 @@
-import type { Abi, AbiParameter, AbiParameterToPrimitiveType } from 'abitype'
+import type {
+  Abi,
+  AbiParameter,
+  AbiParameterToPrimitiveType,
+  ExtractAbiEvents,
+} from 'abitype'
 
 import {
   AbiEventNotFoundError,
@@ -8,68 +13,82 @@ import {
   FilterTypeNotSupportedError,
   type FilterTypeNotSupportedErrorType,
 } from '../../errors/log.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
-  AbiItem,
+  ContractEventArgs,
+  ContractEventName,
   EventDefinition,
-  GetEventArgs,
-  InferEventName,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
 import {
   type GetEventSelectorErrorType,
   getEventSelector,
 } from '../hash/getEventSelector.js'
 import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,
 } from './encodeAbiParameters.js'
 import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
+import { type GetAbiItemErrorType, 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 type EncodeEventTopicsErrorType =
   | AbiEventNotFoundErrorType
   | EncodeArgErrorType
   | FormatAbiItemErrorType
+  | GetAbiItemErrorType
   | GetEventSelectorErrorType
   | ErrorType
 
 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)