viem 0.0.0-w-20230829165118 → 0.0.0-w-20230904174840

package/src/utils/abi/decodeErrorResult.ts

@@ -1,45 +1,60 @@
-import type { Abi, ExtractAbiError, ExtractAbiErrorNames } from 'abitype'
+import type { Abi, ExtractAbiError } from 'abitype'
 
 import { solidityError, solidityPanic } from '../../constants/solidity.js'
 import {
   AbiDecodingZeroDataError,
   AbiErrorSignatureNotFoundError,
 } from '../../errors/abi.js'
-import type { AbiItem, GetErrorArgs } from '../../types/contract.js'
+import type {
+  AbiItem,
+  ContractErrorArgs,
+  ContractErrorName,
+} from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import { slice } from '../data/slice.js'
 import { getFunctionSelector } from '../hash/getFunctionSelector.js'
 
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 
 export type DecodeErrorResultParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-> = { abi?: TAbi; data: Hex }
+  abi extends Abi | readonly unknown[] = Abi,
+> = { abi?: abi | undefined; data: Hex }
 
 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]
+  abi extends Abi | readonly unknown[] = Abi,
+  ///
+  allErrorNames extends ContractErrorName<abi> = ContractErrorName<abi>,
+> = IsNarrowable<abi, Abi> extends true
+  ? UnionEvaluate<
+      {
+        [errorName in allErrorNames]: {
+          abiItem: abi extends Abi
+            ? Abi extends abi
+              ? AbiItem
+              : ExtractAbiError<abi, errorName>
+            : AbiItem
+          args: ContractErrorArgs<abi, errorName>
+          errorName: errorName
+        }
+      }[allErrorNames]
+    >
+  : {
+      abiItem: AbiItem
+      args: readonly unknown[] | undefined
+      errorName: string
+    }
+
+export function decodeErrorResult<const TAbi extends Abi | readonly unknown[]>(
+  parameters: DecodeErrorResultParameters<TAbi>,
+): DecodeErrorResultReturnType<TAbi> {
+  const { abi, data } = parameters as DecodeErrorResultParameters
 
-export function decodeErrorResult<const TAbi extends Abi | readonly unknown[]>({
-  abi,
-  data,
-}: DecodeErrorResultParameters<TAbi>): DecodeErrorResultReturnType<TAbi> {
   const signature = slice(data, 0, 4)
   if (signature === '0x') throw new AbiDecodingZeroDataError()
 
-  const abi_ = [...((abi as Abi) || []), solidityError, solidityPanic]
+  const abi_ = [...(abi || []), solidityError, solidityPanic]
   const abiItem = abi_.find(
     (x) =>
       x.type === 'error' && signature === getFunctionSelector(formatAbiItem(x)),
@@ -50,9 +65,10 @@ export function decodeErrorResult<const TAbi extends Abi | readonly unknown[]>({
     })
   return {
     abiItem,
-    args: ('inputs' in abiItem && abiItem.inputs && abiItem.inputs.length > 0
-      ? decodeAbiParameters(abiItem.inputs, slice(data, 4))
-      : undefined) as readonly unknown[] | undefined,
+    args:
+      'inputs' in abiItem && abiItem.inputs && abiItem.inputs.length > 0
+        ? decodeAbiParameters(abiItem.inputs, slice(data, 4))
+        : undefined,
     errorName: (abiItem as { name: string }).name,
   } as DecodeErrorResultReturnType<TAbi>
 }

package/src/utils/abi/decodeEventLog.ts

@@ -1,4 +1,4 @@
-import type { Abi, AbiParameter, ExtractAbiEventNames } from 'abitype'
+import type { Abi, AbiParameter } from 'abitype'
 
 import {
   AbiDecodingDataSizeTooSmallError,
@@ -8,91 +8,95 @@ import {
   DecodeLogTopicsMismatch,
 } from '../../errors/abi.js'
 import type {
+  ContractEventArgsFromTopics,
+  ContractEventName,
   EventDefinition,
-  GetEventArgsFromTopics,
-  InferEventName,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
-import type { Prettify } from '../../types/utils.js'
+import type {
+  IsNarrowable,
+  Prettify,
+  UnionEvaluate,
+} 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 extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> | undefined = ContractEventName<abi>,
+  topics extends Hex[] = Hex[],
+  data extends Hex | undefined = undefined,
+  strict extends boolean = true,
 > = {
-  abi: TAbi
-  data?: TData
-  eventName?: InferEventName<TAbi, TEventName>
-  strict?: TStrict
-  topics: [signature: Hex, ...args: TTopics] | []
+  abi: abi
+  data?: data
+  eventName?: eventName | ContractEventName<abi>
+  strict?: strict
+  topics: [signature: Hex, ...args: topics] | []
 }
 
 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<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> | undefined = ContractEventName<abi>,
+  topics extends Hex[] = Hex[],
+  data extends Hex | undefined = undefined,
+  strict extends boolean = true,
+  ///
+  allEventNames extends ContractEventName<abi> = eventName extends ContractEventName<abi>
+    ? eventName
+    : ContractEventName<abi>,
+> = IsNarrowable<abi, Abi> extends true
+  ? {
+      [name in allEventNames]: Prettify<
         {
-          eventName: TName
-        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData, TStrict>
+          eventName: name
+        } & UnionEvaluate<
+          ContractEventArgsFromTopics<abi, name, strict> extends infer allArgs
+            ? topics extends readonly []
+              ? data extends undefined
+                ? { args?: undefined }
+                : { args?: allArgs | undefined }
+              : { args: allArgs }
+            : never
+        >
       >
-    }[_EventNames]
+    }[allEventNames]
+  : {
+      eventName: eventName
+      args: readonly unknown[] | undefined
+    }
 
 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 abi extends Abi | readonly unknown[],
+  eventName extends ContractEventName<abi> | undefined = undefined,
+  topics extends Hex[] = Hex[],
+  data extends Hex | undefined = undefined,
+  strict extends boolean = true,
+>(
+  parameters: DecodeEventLogParameters<abi, eventName, topics, data, strict>,
+): DecodeEventLogReturnType<abi, eventName, topics, data, strict> {
+  const {
+    abi,
+    data,
+    strict: strict_,
+    topics,
+  } = parameters as DecodeEventLogParameters
+
   const strict = strict_ ?? true
   const [signature, ...argTopics] = topics
-  if (!signature)
-    throw new AbiEventSignatureEmptyTopicsError({
-      docsPath,
-    })
-  const abiItem = (abi as Abi).find(
+  if (!signature) throw new AbiEventSignatureEmptyTopicsError({ docsPath })
+
+  const abiItem = 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,
-    })
+    throw new AbiEventSignatureNotFoundError(signature, { docsPath })
 
   const { name, inputs } = abiItem
   const isUnnamed = inputs?.some((x) => !('name' in x && x.name))
@@ -153,13 +157,7 @@ export function decodeEventLog<
   return {
     eventName: name,
     args: Object.values(args).length > 0 ? args : undefined,
-  } as unknown as DecodeEventLogReturnType<
-    TAbi,
-    TEventName,
-    TTopics,
-    TData,
-    TStrict
-  >
+  } as unknown as DecodeEventLogReturnType<abi, eventName, topics, data, strict>
 }
 
 function decodeTopic({ param, value }: { param: AbiParameter; value: Hex }) {

package/src/utils/abi/decodeFunctionData.ts

@@ -1,41 +1,49 @@
-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 {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import { slice } from '../data/slice.js'
 import { getFunctionSelector } from '../hash/getFunctionSelector.js'
 
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { 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 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)),
@@ -51,5 +59,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/src/utils/abi/decodeFunctionResult.ts

@@ -1,67 +1,143 @@
-import type { Abi, ExtractAbiFunctionNames } from 'abitype'
+import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
   AbiFunctionOutputsNotFoundError,
 } 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 { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { decodeAbiParameters } from './decodeAbiParameters.js'
-import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
+import { 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 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')
@@ -70,7 +146,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/src/utils/abi/encodeDeployData.ts

@@ -4,40 +4,51 @@ import {
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
 } from '../../errors/abi.js'
-import type { GetConstructorArgs } from '../../types/contract.js'
+import type { ContractConstructorArgs } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import { concatHex } from '../data/concat.js'
 
+import type { UnionEvaluate } from '../../types/utils.js'
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 
 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 function encodeDeployData<const TAbi extends Abi | readonly unknown[]>({
-  abi,
-  args,
-  bytecode,
-}: EncodeDeployDataParameters<TAbi>) {
+export type EncodeDeployDataReturnType = Hex
+
+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!])
 }