viem 0.0.0-portable-types-20230523145621 → 0.0.0-refactor-generics-20230831161903

package/src/types/utils.ts

@@ -107,13 +107,24 @@ export type MaybeRequired<T, TRequired extends boolean> = TRequired extends true
   : T
 
 /**
- * @description Merges the intersection properties of T and U.
+ * @description Makes the attribute on the type T allow undefined if TUndefinedish is true.
  *
  * @example
- * MergeIntersectionProperties<{ a: string, b: number }, { a: number, c: boolean }>
- * => { a: number, b: number }
+ * MaybeUndefined<string, true>
+ * => string | undefined
+ *
+ * MaybeUndefined<string, false>
+ * => string
  */
-export type MergeIntersectionProperties<T, U> = {
+export type MaybeUndefined<
+  T,
+  TUndefinedish extends boolean,
+> = TUndefinedish extends true ? T | undefined : T
+
+/**
+ * @private Helper for `Assign`. This is a workaround for tsc generating errorneous type definitions.
+ */
+export type Assign_<T, U> = {
   [K in
     keyof T as K extends keyof U
       ? U[K] extends void
@@ -122,6 +133,15 @@ export type MergeIntersectionProperties<T, U> = {
       : K]: K extends keyof U ? U[K] : T[K]
 }
 
+/**
+ * @description Assigns the properties of U onto T.
+ *
+ * @example
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * => { a: undefined, b: number, c: boolean }
+ */
+export type Assign<T, U> = Assign_<T, U> & U
+
 /**
  * @description Makes nullable properties from T optional.
  *
@@ -135,6 +155,17 @@ export type OptionalNullable<T> = {
   [K in keyof T as T[K] extends NonNullable<unknown> ? never : K]?: T[K]
 }
 
+/**
+ * @description Make properties K of type T never.
+ *
+ * @example
+ * NeverBy<{ a: string, b: boolean, c: number }, 'a' | 'c'>
+ * => { a: never, b: boolean, c: never }
+ */
+export type NeverBy<T, K extends keyof T> = {
+  [U in keyof T]: U extends K ? never : T[U]
+}
+
 /**
  * @description Constructs a type by excluding `undefined` from `T`.
  *
@@ -144,6 +175,16 @@ export type OptionalNullable<T> = {
  */
 export type NoUndefined<T> = T extends undefined ? never : T
 
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionOmit<T, K extends keyof any> = T extends any
+  ? Omit<T, K>
+  : never
+
 /**
  * @description Creates a type that is a partial of T, but with the required keys K.
  *
@@ -156,9 +197,9 @@ export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
 /**
  * @description Combines members of an intersection into a readable type.
  *
- * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
  * @example
- * Prettify<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
  * => { a: string, b: string, c: number, d: bigint }
  */
 export type Prettify<T> = {
@@ -201,3 +242,32 @@ export type Trim<T, Chars extends string = ' '> = TrimLeft<
  * => string | number
  */
 export type ValueOf<T> = T[keyof T]
+
+export type UnionEvaluate<type> = type extends object ? Prettify<type> : type
+
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never]
+  ? readonly []
+  : readonly [...UnionToTuple<Exclude<union, last>>, last]
+
+type LastInUnion<U> = UnionToIntersection<
+  U extends unknown ? (x: U) => 0 : never
+> extends (x: infer l) => 0
+  ? l
+  : never
+type UnionToIntersection<union> = (
+  union extends unknown
+    ? (arg: union) => 0
+    : never
+) extends (arg: infer i) => 0
+  ? i
+  : never
+
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never

package/src/utils/abi/decodeAbiParameters.ts

@@ -2,7 +2,6 @@ import type {
   AbiParameter,
   AbiParameterToPrimitiveType,
   AbiParametersToPrimitiveTypes,
-  Narrow,
 } from 'abitype'
 
 import {
@@ -33,8 +32,8 @@ export type DecodeAbiParametersReturnType<
 >
 
 export function decodeAbiParameters<
-  TParams extends readonly AbiParameter[] | readonly unknown[],
->(params: Narrow<TParams>, data: Hex): DecodeAbiParametersReturnType<TParams> {
+  const TParams extends readonly AbiParameter[] | readonly unknown[],
+>(params: TParams, data: Hex): DecodeAbiParametersReturnType<TParams> {
   if (data === '0x' && (params as unknown[]).length > 0)
     throw new AbiDecodingZeroDataError()
   if (size(data) && size(data) < 32)
@@ -53,7 +52,7 @@ export function decodeAbiParameters<
 
 type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
 
-function decodeParams<TParams extends readonly AbiParameter[]>({
+function decodeParams<const TParams extends readonly AbiParameter[]>({
   data,
   params,
 }: { data: Hex; params: TParams }) {
@@ -126,7 +125,7 @@ function decodeAddress(value: Hex) {
   return { consumed: 32, value: checksumAddress(slice(value, -20)) }
 }
 
-function decodeArray<TParam extends AbiParameter>(
+function decodeArray<const TParam extends AbiParameter>(
   data: Hex,
   {
     param,
@@ -211,7 +210,7 @@ function decodeBool(value: Hex) {
   return { consumed: 32, value: hexToBool(value) }
 }
 
-function decodeBytes<TParam extends AbiParameter>(
+function decodeBytes<const TParam extends AbiParameter>(
   data: Hex,
   { param, position }: { param: TParam; position: number },
 ) {
@@ -239,7 +238,7 @@ function decodeBytes<TParam extends AbiParameter>(
   return { consumed: 32, value }
 }
 
-function decodeNumber<TParam extends AbiParameter>(
+function decodeNumber<const TParam extends AbiParameter>(
   value: Hex,
   { param }: { param: TParam },
 ) {
@@ -268,7 +267,7 @@ function decodeString(data: Hex, { position }: { position: number }) {
 }
 
 function decodeTuple<
-  TParam extends AbiParameter & { components: readonly AbiParameter[] },
+  const TParam extends AbiParameter & { components: readonly AbiParameter[] },
 >(data: Hex, { param, position }: { param: TParam; position: number }) {
   // Tuples can have unnamed components (i.e. they are arrays), so we must
   // determine whether the tuple is named or unnamed. In the case of a named

package/src/utils/abi/decodeDeployData.ts

@@ -1,4 +1,4 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi } from 'abitype'
 
 import {
   AbiConstructorNotFoundError,
@@ -14,7 +14,7 @@ const docsPath = '/docs/contract/decodeDeployData'
 export type DecodeDeployDataParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
 > = {
-  abi: Narrow<TAbi>
+  abi: TAbi
   bytecode: Hex
   data: Hex
 }
@@ -24,7 +24,7 @@ export type DecodeDeployDataReturnType<
   bytecode: Hex
 } & GetConstructorArgs<TAbi>
 
-export function decodeDeployData<TAbi extends Abi | readonly unknown[]>({
+export function decodeDeployData<const TAbi extends Abi | readonly unknown[]>({
   abi,
   bytecode,
   data,

package/src/utils/abi/decodeErrorResult.ts

@@ -1,9 +1,4 @@
-import type {
-  Abi,
-  ExtractAbiError,
-  ExtractAbiErrorNames,
-  Narrow,
-} from 'abitype'
+import type { Abi, ExtractAbiError, ExtractAbiErrorNames } from 'abitype'
 
 import { solidityError, solidityPanic } from '../../constants/solidity.js'
 import {
@@ -20,7 +15,7 @@ import { formatAbiItem } from './formatAbiItem.js'
 
 export type DecodeErrorResultParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-> = { abi?: Narrow<TAbi>; data: Hex }
+> = { abi?: TAbi; data: Hex }
 
 export type DecodeErrorResultReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
@@ -37,7 +32,7 @@ export type DecodeErrorResultReturnType<
   }
 }[_ErrorNames]
 
-export function decodeErrorResult<TAbi extends Abi | readonly unknown[]>({
+export function decodeErrorResult<const TAbi extends Abi | readonly unknown[]>({
   abi,
   data,
 }: DecodeErrorResultParameters<TAbi>): DecodeErrorResultReturnType<TAbi> {

package/src/utils/abi/decodeEventLog.ts

@@ -1,4 +1,4 @@
-import type { Abi, AbiParameter, ExtractAbiEventNames, Narrow } from 'abitype'
+import type { Abi, AbiParameter, ExtractAbiEventNames } from 'abitype'
 
 import {
   AbiDecodingDataSizeTooSmallError,
@@ -24,10 +24,12 @@ export type DecodeEventLogParameters<
   TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
+  TStrict extends boolean = true,
 > = {
-  abi: Narrow<TAbi>
+  abi: TAbi
   data?: TData
   eventName?: InferEventName<TAbi, TEventName>
+  strict?: TStrict
   topics: [signature: Hex, ...args: TTopics] | []
 }
 
@@ -36,6 +38,7 @@ export type DecodeEventLogReturnType<
   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
@@ -45,33 +48,37 @@ export type DecodeEventLogReturnType<
   ? Prettify<
       {
         eventName: TEventName
-      } & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData>
+      } & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData, TStrict>
     >
   : {
       [TName in _EventNames]: Prettify<
         {
           eventName: TName
-        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData>
+        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData, TStrict>
       >
     }[_EventNames]
 
 const docsPath = '/docs/contract/decodeEventLog'
 
 export function decodeEventLog<
-  TAbi extends Abi | readonly unknown[],
+  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
->): 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({
@@ -82,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,
     })
@@ -109,32 +116,50 @@ export function decodeEventLog<
 
   // Decode data (non-indexed args).
   const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed))
-  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]
+  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/decodeFunctionResult.ts

@@ -1,4 +1,4 @@
-import type { Abi, ExtractAbiFunctionNames, Narrow } from 'abitype'
+import type { Abi, ExtractAbiFunctionNames } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
@@ -25,11 +25,9 @@ export type DecodeFunctionResultParameters<
   functionName?: _FunctionName
   data: Hex
 } & (TFunctionName extends string
-  ? { abi: Narrow<TAbi> } & Partial<GetFunctionArgs<TAbi, TFunctionName>>
+  ? { abi: TAbi } & Partial<GetFunctionArgs<TAbi, TFunctionName>>
   : _FunctionName extends string
-  ? { abi: [Narrow<TAbi[number]>] } & Partial<
-      GetFunctionArgs<TAbi, _FunctionName>
-    >
+  ? { abi: [TAbi[number]] } & Partial<GetFunctionArgs<TAbi, _FunctionName>>
   : never)
 
 export type DecodeFunctionResultReturnType<
@@ -45,7 +43,7 @@ export type DecodeFunctionResultReturnType<
   : ContractFunctionResult<TAbi, _FunctionName>
 
 export function decodeFunctionResult<
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TFunctionName extends string | undefined = undefined,
 >({
   abi,

package/src/utils/abi/encodeAbiParameters.ts

@@ -2,7 +2,6 @@ import type {
   AbiParameter,
   AbiParameterToPrimitiveType,
   AbiParametersToPrimitiveTypes,
-  Narrow,
 } from 'abitype'
 
 import {
@@ -27,9 +26,9 @@ export type EncodeAbiParametersReturnType = Hex
  * @description Encodes a list of primitive values into an ABI-encoded hex value.
  */
 export function encodeAbiParameters<
-  TParams extends readonly AbiParameter[] | readonly unknown[],
+  const TParams extends readonly AbiParameter[] | readonly unknown[],
 >(
-  params: Narrow<TParams>,
+  params: TParams,
   values: TParams extends readonly AbiParameter[]
     ? AbiParametersToPrimitiveTypes<TParams>
     : never,
@@ -56,11 +55,11 @@ type PreparedParam = { dynamic: boolean; encoded: Hex }
 type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
 type Tuple = AbiParameterToPrimitiveType<TupleAbiParameter>
 
-function prepareParams<TParams extends readonly AbiParameter[]>({
+function prepareParams<const TParams extends readonly AbiParameter[]>({
   params,
   values,
 }: {
-  params: Narrow<TParams>
+  params: TParams
   values: AbiParametersToPrimitiveTypes<TParams>
 }) {
   const preparedParams: PreparedParam[] = []
@@ -70,7 +69,7 @@ function prepareParams<TParams extends readonly AbiParameter[]>({
   return preparedParams
 }
 
-function prepareParam<TParam extends AbiParameter>({
+function prepareParam<const TParam extends AbiParameter>({
   param,
   value,
 }: {
@@ -145,7 +144,7 @@ function encodeAddress(value: Hex): PreparedParam {
   return { dynamic: false, encoded: padHex(value.toLowerCase() as Hex) }
 }
 
-function encodeArray<TParam extends AbiParameter>(
+function encodeArray<const TParam extends AbiParameter>(
   value: AbiParameterToPrimitiveType<TParam>,
   {
     length,
@@ -190,32 +189,29 @@ function encodeArray<TParam extends AbiParameter>(
   }
 }
 
-function encodeBytes<TParam extends AbiParameter>(
+function encodeBytes<const TParam extends AbiParameter>(
   value: Hex,
   { param }: { param: TParam },
 ): PreparedParam {
-  const [_, size_] = param.type.split('bytes')
-  if (!size_) {
-    const partsLength = Math.ceil(size(value) / 32)
-    const parts: Hex[] = []
-    for (let i = 0; i < partsLength; i++) {
-      parts.push(
-        padHex(slice(value, i * 32, (i + 1) * 32), {
-          dir: 'right',
-        }),
-      )
-    }
+  const [, paramSize] = param.type.split('bytes')
+  const bytesSize = size(value)
+  if (!paramSize) {
+    let value_ = value
+    // If the size is not divisible by 32 bytes, pad the end
+    // with empty bytes to the ceiling 32 bytes.
+    if (bytesSize % 32 !== 0)
+      value_ = padHex(value_, {
+        dir: 'right',
+        size: Math.ceil((value.length - 2) / 2 / 32) * 32,
+      })
     return {
       dynamic: true,
-      encoded: concat([
-        padHex(numberToHex(size(value), { size: 32 })),
-        ...parts,
-      ]),
+      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
     }
   }
-  if (size(value) !== parseInt(size_))
+  if (bytesSize !== parseInt(paramSize))
     throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: parseInt(size_),
+      expectedSize: parseInt(paramSize),
       value,
     })
   return { dynamic: false, encoded: padHex(value, { dir: 'right' }) }
@@ -259,7 +255,7 @@ function encodeString(value: string): PreparedParam {
 }
 
 function encodeTuple<
-  TParam extends AbiParameter & { components: readonly AbiParameter[] },
+  const TParam extends AbiParameter & { components: readonly AbiParameter[] },
 >(
   value: AbiParameterToPrimitiveType<TParam>,
   { param }: { param: TParam },

package/src/utils/abi/encodeDeployData.ts

@@ -1,4 +1,4 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi } from 'abitype'
 
 import {
   AbiConstructorNotFoundError,
@@ -15,11 +15,11 @@ const docsPath = '/docs/contract/encodeDeployData'
 export type EncodeDeployDataParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
 > = {
-  abi: Narrow<TAbi>
+  abi: TAbi
   bytecode: Hex
 } & GetConstructorArgs<TAbi>
 
-export function encodeDeployData<TAbi extends Abi | readonly unknown[]>({
+export function encodeDeployData<const TAbi extends Abi | readonly unknown[]>({
   abi,
   args,
   bytecode,

package/src/utils/abi/encodeErrorResult.ts

@@ -1,4 +1,4 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi } from 'abitype'
 
 import {
   AbiErrorInputsNotFoundError,
@@ -26,13 +26,13 @@ export type EncodeErrorResultParameters<
 > = {
   errorName?: _ErrorName
 } & (TErrorName extends string
-  ? { abi: Narrow<TAbi> } & GetErrorArgs<TAbi, TErrorName>
+  ? { abi: TAbi } & GetErrorArgs<TAbi, TErrorName>
   : _ErrorName extends string
-  ? { abi: [Narrow<TAbi[number]>] } & GetErrorArgs<TAbi, _ErrorName>
+  ? { abi: [TAbi[number]] } & GetErrorArgs<TAbi, _ErrorName>
   : never)
 
 export function encodeErrorResult<
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TErrorName extends string | undefined = undefined,
 >({ abi, errorName, args }: EncodeErrorResultParameters<TAbi, TErrorName>) {
   let abiItem = abi[0] as AbiItem

package/src/utils/abi/encodeEventTopics.ts

@@ -1,9 +1,4 @@
-import type {
-  Abi,
-  AbiParameter,
-  AbiParameterToPrimitiveType,
-  Narrow,
-} from 'abitype'
+import type { Abi, AbiParameter, AbiParameterToPrimitiveType } from 'abitype'
 
 import { AbiEventNotFoundError } from '../../errors/abi.js'
 import { FilterTypeNotSupportedError } from '../../errors/log.js'
@@ -29,13 +24,13 @@ export type EncodeEventTopicsParameters<
 > = {
   eventName?: _EventName
 } & (TEventName extends string
-  ? { abi: Narrow<TAbi>; args?: GetEventArgs<TAbi, TEventName> }
+  ? { abi: TAbi; args?: GetEventArgs<TAbi, TEventName> }
   : _EventName extends string
-  ? { abi: [Narrow<TAbi[number]>]; args?: GetEventArgs<TAbi, _EventName> }
+  ? { abi: [TAbi[number]]; args?: GetEventArgs<TAbi, _EventName> }
   : never)
 
 export function encodeEventTopics<
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TEventName extends string | undefined = undefined,
 >({ abi, eventName, args }: EncodeEventTopicsParameters<TAbi, TEventName>) {
   let abiItem = abi[0] as AbiItem
@@ -66,17 +61,22 @@ export function encodeEventTopics<
     )
     const args_ = Array.isArray(args)
       ? args
-      : indexedInputs?.map((x: any) => (args as any)[x.name]) ?? []
-    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,
-      ) ?? []
+      : 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]
 }

package/src/utils/abi/encodeFunctionData.ts

@@ -1,4 +1,4 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi } from 'abitype'
 
 import { AbiFunctionNotFoundError } from '../../errors/abi.js'
 import type {
@@ -20,13 +20,13 @@ export type EncodeFunctionDataParameters<
 > = {
   functionName?: _FunctionName
 } & (TFunctionName extends string
-  ? { abi: Narrow<TAbi> } & GetFunctionArgs<TAbi, TFunctionName>
+  ? { abi: TAbi } & GetFunctionArgs<TAbi, TFunctionName>
   : _FunctionName extends string
-  ? { abi: [Narrow<TAbi[number]>] } & GetFunctionArgs<TAbi, _FunctionName>
+  ? { abi: [TAbi[number]] } & GetFunctionArgs<TAbi, _FunctionName>
   : never)
 
 export function encodeFunctionData<
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TFunctionName extends string | undefined = undefined,
 >({
   abi,

package/src/utils/abi/encodeFunctionResult.ts

@@ -1,4 +1,4 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
@@ -22,16 +22,16 @@ export type EncodeFunctionResultParameters<
 > = {
   functionName?: _FunctionName
 } & (TFunctionName extends string
-  ? { abi: Narrow<TAbi>; result?: ContractFunctionResult<TAbi, TFunctionName> }
+  ? { abi: TAbi; result?: ContractFunctionResult<TAbi, TFunctionName> }
   : _FunctionName extends string
   ? {
-      abi: [Narrow<TAbi[number]>]
+      abi: [TAbi[number]]
       result?: ContractFunctionResult<TAbi, _FunctionName>
     }
   : never)
 
 export function encodeFunctionResult<
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TFunctionName extends string | undefined = undefined,
 >({
   abi,