viem 1.5.4 → 1.6.2

package/src/constants/number.ts

@@ -1,98 +1,98 @@
-export const maxInt8 = 2n ** (8n - 1n)
-export const maxInt16 = 2n ** (16n - 1n)
-export const maxInt24 = 2n ** (24n - 1n)
-export const maxInt32 = 2n ** (32n - 1n)
-export const maxInt40 = 2n ** (40n - 1n)
-export const maxInt48 = 2n ** (48n - 1n)
-export const maxInt56 = 2n ** (56n - 1n)
-export const maxInt64 = 2n ** (64n - 1n)
-export const maxInt72 = 2n ** (72n - 1n)
-export const maxInt80 = 2n ** (80n - 1n)
-export const maxInt88 = 2n ** (88n - 1n)
-export const maxInt96 = 2n ** (96n - 1n)
-export const maxInt104 = 2n ** (104n - 1n)
-export const maxInt112 = 2n ** (112n - 1n)
-export const maxInt120 = 2n ** (120n - 1n)
-export const maxInt128 = 2n ** (128n - 1n)
-export const maxInt136 = 2n ** (136n - 1n)
-export const maxInt144 = 2n ** (144n - 1n)
-export const maxInt152 = 2n ** (152n - 1n)
-export const maxInt160 = 2n ** (160n - 1n)
-export const maxInt168 = 2n ** (168n - 1n)
-export const maxInt176 = 2n ** (176n - 1n)
-export const maxInt184 = 2n ** (184n - 1n)
-export const maxInt192 = 2n ** (192n - 1n)
-export const maxInt200 = 2n ** (200n - 1n)
-export const maxInt208 = 2n ** (208n - 1n)
-export const maxInt216 = 2n ** (216n - 1n)
-export const maxInt224 = 2n ** (224n - 1n)
-export const maxInt232 = 2n ** (232n - 1n)
-export const maxInt240 = 2n ** (240n - 1n)
-export const maxInt248 = 2n ** (248n - 1n)
-export const maxInt256 = 2n ** (256n - 1n)
+export const maxInt8 = 2n ** (8n - 1n) - 1n
+export const maxInt16 = 2n ** (16n - 1n) - 1n
+export const maxInt24 = 2n ** (24n - 1n) - 1n
+export const maxInt32 = 2n ** (32n - 1n) - 1n
+export const maxInt40 = 2n ** (40n - 1n) - 1n
+export const maxInt48 = 2n ** (48n - 1n) - 1n
+export const maxInt56 = 2n ** (56n - 1n) - 1n
+export const maxInt64 = 2n ** (64n - 1n) - 1n
+export const maxInt72 = 2n ** (72n - 1n) - 1n
+export const maxInt80 = 2n ** (80n - 1n) - 1n
+export const maxInt88 = 2n ** (88n - 1n) - 1n
+export const maxInt96 = 2n ** (96n - 1n) - 1n
+export const maxInt104 = 2n ** (104n - 1n) - 1n
+export const maxInt112 = 2n ** (112n - 1n) - 1n
+export const maxInt120 = 2n ** (120n - 1n) - 1n
+export const maxInt128 = 2n ** (128n - 1n) - 1n
+export const maxInt136 = 2n ** (136n - 1n) - 1n
+export const maxInt144 = 2n ** (144n - 1n) - 1n
+export const maxInt152 = 2n ** (152n - 1n) - 1n
+export const maxInt160 = 2n ** (160n - 1n) - 1n
+export const maxInt168 = 2n ** (168n - 1n) - 1n
+export const maxInt176 = 2n ** (176n - 1n) - 1n
+export const maxInt184 = 2n ** (184n - 1n) - 1n
+export const maxInt192 = 2n ** (192n - 1n) - 1n
+export const maxInt200 = 2n ** (200n - 1n) - 1n
+export const maxInt208 = 2n ** (208n - 1n) - 1n
+export const maxInt216 = 2n ** (216n - 1n) - 1n
+export const maxInt224 = 2n ** (224n - 1n) - 1n
+export const maxInt232 = 2n ** (232n - 1n) - 1n
+export const maxInt240 = 2n ** (240n - 1n) - 1n
+export const maxInt248 = 2n ** (248n - 1n) - 1n
+export const maxInt256 = 2n ** (256n - 1n) - 1n
 
-export const minInt8 = -(2n ** 8n)
-export const minInt16 = -(2n ** 16n)
-export const minInt24 = -(2n ** 24n)
-export const minInt32 = -(2n ** 32n)
-export const minInt40 = -(2n ** 40n)
-export const minInt48 = -(2n ** 48n)
-export const minInt56 = -(2n ** 56n)
-export const minInt64 = -(2n ** 64n)
-export const minInt72 = -(2n ** 72n)
-export const minInt80 = -(2n ** 80n)
-export const minInt88 = -(2n ** 88n)
-export const minInt96 = -(2n ** 96n)
-export const minInt104 = -(2n ** 104n)
-export const minInt112 = -(2n ** 112n)
-export const minInt120 = -(2n ** 120n)
-export const minInt128 = -(2n ** 128n)
-export const minInt136 = -(2n ** 136n)
-export const minInt144 = -(2n ** 144n)
-export const minInt152 = -(2n ** 152n)
-export const minInt160 = -(2n ** 160n)
-export const minInt168 = -(2n ** 168n)
-export const minInt176 = -(2n ** 176n)
-export const minInt184 = -(2n ** 184n)
-export const minInt192 = -(2n ** 192n)
-export const minInt200 = -(2n ** 200n)
-export const minInt208 = -(2n ** 208n)
-export const minInt216 = -(2n ** 216n)
-export const minInt224 = -(2n ** 224n)
-export const minInt232 = -(2n ** 232n)
-export const minInt240 = -(2n ** 240n)
-export const minInt248 = -(2n ** 248n)
-export const minInt256 = -(2n ** 256n)
+export const minInt8 = -(2n ** (8n - 1n))
+export const minInt16 = -(2n ** (16n - 1n))
+export const minInt24 = -(2n ** (24n - 1n))
+export const minInt32 = -(2n ** (32n - 1n))
+export const minInt40 = -(2n ** (40n - 1n))
+export const minInt48 = -(2n ** (48n - 1n))
+export const minInt56 = -(2n ** (56n - 1n))
+export const minInt64 = -(2n ** (64n - 1n))
+export const minInt72 = -(2n ** (72n - 1n))
+export const minInt80 = -(2n ** (80n - 1n))
+export const minInt88 = -(2n ** (88n - 1n))
+export const minInt96 = -(2n ** (96n - 1n))
+export const minInt104 = -(2n ** (104n - 1n))
+export const minInt112 = -(2n ** (112n - 1n))
+export const minInt120 = -(2n ** (120n - 1n))
+export const minInt128 = -(2n ** (128n - 1n))
+export const minInt136 = -(2n ** (136n - 1n))
+export const minInt144 = -(2n ** (144n - 1n))
+export const minInt152 = -(2n ** (152n - 1n))
+export const minInt160 = -(2n ** (160n - 1n))
+export const minInt168 = -(2n ** (168n - 1n))
+export const minInt176 = -(2n ** (176n - 1n))
+export const minInt184 = -(2n ** (184n - 1n))
+export const minInt192 = -(2n ** (192n - 1n))
+export const minInt200 = -(2n ** (200n - 1n))
+export const minInt208 = -(2n ** (208n - 1n))
+export const minInt216 = -(2n ** (216n - 1n))
+export const minInt224 = -(2n ** (224n - 1n))
+export const minInt232 = -(2n ** (232n - 1n))
+export const minInt240 = -(2n ** (240n - 1n))
+export const minInt248 = -(2n ** (248n - 1n))
+export const minInt256 = -(2n ** (256n - 1n))
 
-export const maxUint8 = 2n ** 8n
-export const maxUint16 = 2n ** 16n
-export const maxUint24 = 2n ** 24n
-export const maxUint32 = 2n ** 32n
-export const maxUint40 = 2n ** 40n
-export const maxUint48 = 2n ** 48n
-export const maxUint56 = 2n ** 56n
-export const maxUint64 = 2n ** 64n
-export const maxUint72 = 2n ** 72n
-export const maxUint80 = 2n ** 80n
-export const maxUint88 = 2n ** 88n
-export const maxUint96 = 2n ** 96n
-export const maxUint104 = 2n ** 104n
-export const maxUint112 = 2n ** 112n
-export const maxUint120 = 2n ** 120n
-export const maxUint128 = 2n ** 128n
-export const maxUint136 = 2n ** 136n
-export const maxUint144 = 2n ** 144n
-export const maxUint152 = 2n ** 152n
-export const maxUint160 = 2n ** 160n
-export const maxUint168 = 2n ** 168n
-export const maxUint176 = 2n ** 176n
-export const maxUint184 = 2n ** 184n
-export const maxUint192 = 2n ** 192n
-export const maxUint200 = 2n ** 200n
-export const maxUint208 = 2n ** 208n
-export const maxUint216 = 2n ** 216n
-export const maxUint224 = 2n ** 224n
-export const maxUint232 = 2n ** 232n
-export const maxUint240 = 2n ** 240n
-export const maxUint248 = 2n ** 248n
-export const maxUint256 = 2n ** 256n
+export const maxUint8 = 2n ** 8n - 1n
+export const maxUint16 = 2n ** 16n - 1n
+export const maxUint24 = 2n ** 24n - 1n
+export const maxUint32 = 2n ** 32n - 1n
+export const maxUint40 = 2n ** 40n - 1n
+export const maxUint48 = 2n ** 48n - 1n
+export const maxUint56 = 2n ** 56n - 1n
+export const maxUint64 = 2n ** 64n - 1n
+export const maxUint72 = 2n ** 72n - 1n
+export const maxUint80 = 2n ** 80n - 1n
+export const maxUint88 = 2n ** 88n - 1n
+export const maxUint96 = 2n ** 96n - 1n
+export const maxUint104 = 2n ** 104n - 1n
+export const maxUint112 = 2n ** 112n - 1n
+export const maxUint120 = 2n ** 120n - 1n
+export const maxUint128 = 2n ** 128n - 1n
+export const maxUint136 = 2n ** 136n - 1n
+export const maxUint144 = 2n ** 144n - 1n
+export const maxUint152 = 2n ** 152n - 1n
+export const maxUint160 = 2n ** 160n - 1n
+export const maxUint168 = 2n ** 168n - 1n
+export const maxUint176 = 2n ** 176n - 1n
+export const maxUint184 = 2n ** 184n - 1n
+export const maxUint192 = 2n ** 192n - 1n
+export const maxUint200 = 2n ** 200n - 1n
+export const maxUint208 = 2n ** 208n - 1n
+export const maxUint216 = 2n ** 216n - 1n
+export const maxUint224 = 2n ** 224n - 1n
+export const maxUint232 = 2n ** 232n - 1n
+export const maxUint240 = 2n ** 240n - 1n
+export const maxUint248 = 2n ** 248n - 1n
+export const maxUint256 = 2n ** 256n - 1n

package/src/errors/node.ts

@@ -88,7 +88,8 @@ export class NonceTooHighError extends BaseError {
 }
 
 export class NonceTooLowError extends BaseError {
-  static nodeMessage = /nonce too low|transaction already imported/
+  static nodeMessage =
+    /nonce too low|transaction already imported|already known/
   override name = 'NonceTooLowError'
   constructor({ cause, nonce }: { cause?: BaseError; nonce?: number } = {}) {
     super(

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '1.5.4'
+export const version = '1.6.2'

package/src/index.ts

@@ -571,7 +571,30 @@ export type {
   Signature,
   SignableMessage,
 } from './types/misc.js'
-export type { Chain } from './types/chain.js'
+export type {
+  Chain,
+  ChainContract,
+  ChainFees,
+  ChainFormatter,
+  /** @deprecated use `ChainFormatter` instead. */
+  ChainFormatter as Formatter,
+  ChainFormatters,
+  /** @deprecated use `ChainFormatters` instead. */
+  ChainFormatters as Formatters,
+  ChainSerializers,
+  /** @deprecated use `ChainSerializers` instead. */
+  ChainSerializers as Serializers,
+  ExtractChainFormatterExclude,
+  /** @deprecated use `ExtractChainFormatterExclude` instead. */
+  ExtractChainFormatterExclude as ExtractFormatterExclude,
+  ExtractChainFormatterParameters,
+  /** @deprecated use `ExtractChainFormatterParameters` instead. */
+  ExtractChainFormatterParameters as ExtractFormatterParameters,
+  ExtractChainFormatterReturnType,
+  /** @deprecated use `ExtractChainFormatterReturnType` instead. */
+  ExtractChainFormatterReturnType as ExtractFormatterReturnType,
+  GetChain,
+} from './types/chain.js'
 export type {
   AddEthereumChainParameter,
   EIP1193Events,
@@ -599,13 +622,6 @@ export type {
   FeeValuesLegacy,
 } from './types/fee.js'
 export type { Filter } from './types/filter.js'
-export type {
-  Formatter,
-  Formatters,
-  ExtractFormatterParameters,
-  ExtractFormatterReturnType,
-} from './types/formatter.js'
-export type { Serializers } from './types/serializer.js'
 export type {
   GetTypedDataDomain,
   GetTypedDataMessage,
@@ -617,6 +633,7 @@ export type { GetTransportConfig } from './types/transport.js'
 export type { HDKey } from '@scure/bip32'
 export type { Log } from './types/log.js'
 export type {
+  MulticallContract,
   MulticallContracts,
   MulticallResult,
   MulticallResults,

package/src/types/chain.ts

@@ -1,17 +1,24 @@
 import type { Address } from 'abitype'
 
-import type { Formatters } from './formatter.js'
-import type { Serializers } from './serializer.js'
-import type { IsUndefined } from './utils.js'
+import type { FormattedBlock } from '../utils/formatters/block.js'
+import type { PrepareRequestParameters } from '../utils/transaction/prepareRequest.js'
+import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import type {
+  TransactionSerializable,
+  TransactionSerializableGeneric,
+} from './transaction.js'
+import type { IsUndefined, Prettify } from './utils.js'
 
 export type Chain<
-  formatters extends Formatters | undefined = Formatters | undefined,
-  serializers extends Serializers<formatters> | undefined =
-    | Serializers<formatters>
-    | undefined,
-> = import('@wagmi/chains').Chain & {
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = import('@wagmi/chains').Chain & ChainConfig<formatters>
+
+export type ChainConfig<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
   formatters?: formatters | undefined
-  serializers?: serializers | undefined
+  serializers?: ChainSerializers<formatters> | undefined
+  fees?: ChainFees<formatters> | undefined
 }
 
 export type ChainContract = {
@@ -19,9 +26,79 @@ export type ChainContract = {
   blockCreated?: number
 }
 
+export type ChainFees<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
+  defaultPriorityFee:
+    | bigint
+    | ((args: {
+        block: Prettify<FormattedBlock<{ formatters: formatters }>>
+        request: PrepareRequestParameters<
+          Omit<Chain, 'formatters'> & { formatters: formatters }
+        >
+      }) => Promise<bigint> | bigint)
+}
+
+export type ChainFormatters = {
+  block?: ChainFormatter<'block'>
+  transaction?: ChainFormatter<'transaction'>
+  transactionReceipt?: ChainFormatter<'transactionReceipt'>
+  transactionRequest?: ChainFormatter<'transactionRequest'>
+}
+
+export type ChainFormatter<type extends string = string> = {
+  format: (args: any) => any
+  type: type
+}
+
+export type ChainSerializers<
+  formatters extends ChainFormatters | undefined = undefined,
+> = {
+  transaction?: SerializeTransactionFn<
+    formatters extends ChainFormatters
+      ? formatters['transactionRequest'] extends ChainFormatter
+        ? TransactionSerializableGeneric &
+            Parameters<formatters['transactionRequest']['format']>[0]
+        : TransactionSerializable
+      : TransactionSerializable
+  >
+}
+
+/////////////////////////////////////////////////////////////////////
+// Utils
+
+export type ExtractChainFormatterExclude<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends { exclude: infer Exclude }
+    ? Extract<Exclude, string[]>[number]
+    : ''
+  : ''
+
+export type ExtractChainFormatterParameters<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+  fallback,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends ChainFormatter
+    ? Parameters<_Formatters[type]['format']>[0]
+    : fallback
+  : fallback
+
+export type ExtractChainFormatterReturnType<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+  fallback,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends ChainFormatter
+    ? ReturnType<_Formatters[type]['format']>
+    : fallback
+  : fallback
+
 export type GetChain<
-  TChain extends Chain | undefined,
-  TChainOverride extends Chain | undefined = undefined,
-> = IsUndefined<TChain> extends true
-  ? { chain: TChainOverride | null }
-  : { chain?: TChainOverride | null }
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined = undefined,
+> = IsUndefined<chain> extends true
+  ? { chain: chainOverride | null }
+  : { chain?: chainOverride | null }

package/src/types/multicall.ts

@@ -1,4 +1,4 @@
-import type { Abi } from 'abitype'
+import type { Abi, ExtractAbiFunctionNames } from 'abitype'
 
 import type {
   ContractFunctionConfig,
@@ -7,13 +7,16 @@ import type {
 
 type MAXIMUM_DEPTH = 20
 
-export type Contract<
+export type MulticallContract<
   TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[],
-  TFunctionName extends string = string,
+  TFunctionName extends ExtractAbiFunctionNames<
+    TAbi extends Abi ? TAbi : Abi,
+    'pure' | 'view'
+  > = string,
 > = { abi: TAbi; functionName: TFunctionName }
 
 export type MulticallContracts<
-  TContracts extends Contract[],
+  TContracts extends readonly MulticallContract[],
   TProperties extends Record<string, any> = object,
   Result extends any[] = [],
   Depth extends readonly number[] = [],
@@ -21,14 +24,14 @@ export type MulticallContracts<
   ? (ContractFunctionConfig & TProperties)[]
   : TContracts extends []
   ? []
-  : TContracts extends [infer Head extends Contract]
+  : TContracts extends [infer Head extends MulticallContract]
   ? [
       ...Result,
       ContractFunctionConfig<Head['abi'], Head['functionName']> & TProperties,
     ]
   : TContracts extends [
-      infer Head extends Contract,
-      ...infer Tail extends Contract[],
+      infer Head extends MulticallContract,
+      ...infer Tail extends readonly MulticallContract[],
     ]
   ? MulticallContracts<
       [...Tail],
@@ -65,7 +68,7 @@ export type MulticallResult<
   : Result
 
 export type MulticallResults<
-  TContracts extends Contract[],
+  TContracts extends readonly MulticallContract[],
   TAllowFailure extends boolean = true,
   Result extends any[] = [],
   Depth extends readonly number[] = [],
@@ -73,7 +76,7 @@ export type MulticallResults<
   ? MulticallResult<ContractFunctionResult, TAllowFailure>[]
   : TContracts extends []
   ? []
-  : TContracts extends [infer Head extends Contract]
+  : TContracts extends [infer Head extends MulticallContract]
   ? [
       ...Result,
       MulticallResult<
@@ -82,8 +85,8 @@ export type MulticallResults<
       >,
     ]
   : TContracts extends [
-      infer Head extends Contract,
-      ...infer Tail extends Contract[],
+      infer Head extends MulticallContract,
+      ...infer Tail extends readonly MulticallContract[],
     ]
   ? MulticallResults<
       [...Tail],

package/src/types/rpc.ts

@@ -26,12 +26,8 @@ export type TransactionType = '0x0' | '0x1' | '0x2' | (string & {})
 export type RpcBlock<
   TBlockTag extends BlockTag = BlockTag,
   TIncludeTransactions extends boolean = boolean,
-> = Block<
-  Quantity,
-  TIncludeTransactions,
-  TBlockTag,
-  RpcTransaction<TBlockTag extends 'pending' ? true : false>
->
+  TTransaction = RpcTransaction<TBlockTag extends 'pending' ? true : false>,
+> = Block<Quantity, TIncludeTransactions, TBlockTag, TTransaction>
 export type RpcBlockNumber = BlockNumber<Quantity>
 export type RpcBlockIdentifier = BlockIdentifier<Quantity>
 export type RpcUncle = Uncle<Quantity>

package/src/types/typedData.ts

@@ -1,5 +1,4 @@
 import type {
-  Narrow,
   TypedData,
   TypedDataDomain,
   TypedDataToPrimitiveTypes,
@@ -74,8 +73,8 @@ export type GetTypedDataTypes<
   TPrimaryType extends string = string,
 > = TPrimaryType extends 'EIP712Domain'
   ? {
-      types?: Narrow<TTypedData>
+      types?: TTypedData
     }
   : {
-      types: Narrow<TTypedData>
+      types: TTypedData
     }

package/src/types/utils.ts

@@ -155,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`.
  *

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,
@@ -26,7 +26,7 @@ export type DecodeEventLogParameters<
   TData extends Hex | undefined = undefined,
   TStrict extends boolean = true,
 > = {
-  abi: Narrow<TAbi>
+  abi: TAbi
   data?: TData
   eventName?: InferEventName<TAbi, TEventName>
   strict?: TStrict
@@ -61,7 +61,7 @@ export type DecodeEventLogReturnType<
 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,