viem 2.1.1 → 2.3.1

package/_types/constants/abis.d.ts

@@ -36,6 +36,49 @@ export declare const universalResolverResolveAbi: readonly [{
     readonly inputs: readonly [];
     readonly name: "ResolverWildcardNotSupported";
     readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ResolverNotContract";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "returnData";
+        readonly type: "bytes";
+    }];
+    readonly name: "ResolverError";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "status";
+            readonly type: "uint16";
+        }, {
+            readonly name: "message";
+            readonly type: "string";
+        }];
+        readonly name: "errors";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "HttpError";
+    readonly type: "error";
+}, {
+    readonly name: "resolve";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "bytes";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+    }, {
+        readonly name: "address";
+        readonly type: "address";
+    }];
 }, {
     readonly name: "resolve";
     readonly type: "function";
@@ -46,6 +89,9 @@ export declare const universalResolverResolveAbi: readonly [{
     }, {
         readonly name: "data";
         readonly type: "bytes";
+    }, {
+        readonly name: "gateways";
+        readonly type: "string[]";
     }];
     readonly outputs: readonly [{
         readonly name: "";
@@ -63,6 +109,31 @@ export declare const universalResolverReverseAbi: readonly [{
     readonly inputs: readonly [];
     readonly name: "ResolverWildcardNotSupported";
     readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ResolverNotContract";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "returnData";
+        readonly type: "bytes";
+    }];
+    readonly name: "ResolverError";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "status";
+            readonly type: "uint16";
+        }, {
+            readonly name: "message";
+            readonly type: "string";
+        }];
+        readonly name: "errors";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "HttpError";
+    readonly type: "error";
 }, {
     readonly name: "reverse";
     readonly type: "function";
@@ -84,6 +155,30 @@ export declare const universalResolverReverseAbi: readonly [{
         readonly type: "address";
         readonly name: "resolver";
     }];
+}, {
+    readonly name: "reverse";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "reverseName";
+    }, {
+        readonly type: "string[]";
+        readonly name: "gateways";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "string";
+        readonly name: "resolvedName";
+    }, {
+        readonly type: "address";
+        readonly name: "resolvedAddress";
+    }, {
+        readonly type: "address";
+        readonly name: "reverseResolver";
+    }, {
+        readonly type: "address";
+        readonly name: "resolver";
+    }];
 }];
 export declare const textResolverAbi: readonly [{
     readonly name: "text";

package/_types/constants/abis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../../constants/abis.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ChB,CAAA;AAeV,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;EAe9B,CAAA;AAEV,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9B,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAWlB,CAAA;AAEV,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBrB,CAAA;AAIV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAWlB,CAAA;AAKV,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;EAsBjC,CAAA;AAEV,+FAA+F;AAC/F,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2LX,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2LnB,CAAA;AAEV,8GAA8G;AAC9G,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2TZ,CAAA;AAEV,8GAA8G;AAC9G,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqfb,CAAA"}
+{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../../constants/abis.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ChB,CAAA;AAkDV,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B9B,CAAA;AAEV,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B9B,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAWlB,CAAA;AAEV,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBrB,CAAA;AAIV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAWlB,CAAA;AAKV,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;EAsBjC,CAAA;AAEV,+FAA+F;AAC/F,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2LX,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2LnB,CAAA;AAEV,8GAA8G;AAC9G,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2TZ,CAAA;AAEV,8GAA8G;AAC9G,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqfb,CAAA"}

package/_types/errors/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "2.1.1";
+export declare const version = "2.3.1";
 //# sourceMappingURL=version.d.ts.map

package/_types/utils/ens/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../utils/ens/errors.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEtD,MAAM,MAAM,qCAAqC,GAAG,SAAS,CAAA;AAK7D,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,SAAS,GAAG,SAAS,GAC9B,OAAO,CAgBT"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../utils/ens/errors.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEtD,MAAM,MAAM,qCAAqC,GAAG,SAAS,CAAA;AAK7D,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,SAAS,GAAG,SAAS,GAC9B,OAAO,CAmBT"}

package/actions/ens/getEnsAddress.ts

@@ -39,8 +39,12 @@ export type GetEnsAddressParameters = Prettify<
   Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
     /** ENSIP-9 compliant coinType used to resolve addresses for other chains */
     coinType?: number
+    /** Universal Resolver gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
     /** Name to get the address for. */
     name: string
+    /** Whether or not to throw errors propagated from the ENS Universal Resolver Contract. */
+    strict?: boolean
     /** Address of ENS Universal Resolver Contract. */
     universalResolverAddress?: Address
   }
@@ -93,6 +97,8 @@ export async function getEnsAddress<TChain extends Chain | undefined>(
     blockTag,
     coinType,
     name,
+    gatewayUrls,
+    strict,
     universalResolverAddress: universalResolverAddress_,
   }: GetEnsAddressParameters,
 ): Promise<GetEnsAddressReturnType> {
@@ -119,18 +125,23 @@ export async function getEnsAddress<TChain extends Chain | undefined>(
         : { args: [namehash(name)] }),
     })
 
-    const res = await getAction(
-      client,
-      readContract,
-      'readContract',
-    )({
+    const readContractParameters = {
       address: universalResolverAddress,
       abi: universalResolverResolveAbi,
       functionName: 'resolve',
       args: [toHex(packetToBytes(name)), functionData],
       blockNumber,
       blockTag,
-    })
+    } as const
+
+    const readContractAction = getAction(client, readContract, 'readContract')
+
+    const res = gatewayUrls
+      ? await readContractAction({
+          ...readContractParameters,
+          args: [...readContractParameters.args, gatewayUrls],
+        })
+      : await readContractAction(readContractParameters)
 
     if (res[0] === '0x') return null
 
@@ -145,6 +156,7 @@ export async function getEnsAddress<TChain extends Chain | undefined>(
     if (trim(address) === '0x00') return null
     return address
   } catch (err) {
+    if (strict) throw err
     if (isNullUniversalResolverError(err, 'resolve')) return null
     throw err
   }

package/actions/ens/getEnsAvatar.ts

@@ -19,7 +19,7 @@ import {
 export type GetEnsAvatarParameters = Prettify<
   Omit<GetEnsTextParameters, 'key'> & {
     /** Gateway urls to resolve IPFS and/or Arweave assets. */
-    gatewayUrls?: AssetGatewayUrls
+    assetGatewayUrls?: AssetGatewayUrls
   }
 >
 
@@ -63,8 +63,10 @@ export async function getEnsAvatar<TChain extends Chain | undefined>(
   {
     blockNumber,
     blockTag,
-    gatewayUrls,
+    assetGatewayUrls,
     name,
+    gatewayUrls,
+    strict,
     universalResolverAddress,
   }: GetEnsAvatarParameters,
 ): Promise<GetEnsAvatarReturnType> {
@@ -78,10 +80,15 @@ export async function getEnsAvatar<TChain extends Chain | undefined>(
     key: 'avatar',
     name,
     universalResolverAddress,
+    gatewayUrls,
+    strict,
   })
   if (!record) return null
   try {
-    return await parseAvatarRecord(client, { record, gatewayUrls })
+    return await parseAvatarRecord(client, {
+      record,
+      gatewayUrls: assetGatewayUrls,
+    })
   } catch {
     return null
   }

package/actions/ens/getEnsName.ts

@@ -27,6 +27,10 @@ export type GetEnsNameParameters = Prettify<
   Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
     /** Address to get ENS name for. */
     address: Address
+    /** Universal Resolver gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
+    /** Whether or not to throw errors propagated from the ENS Universal Resolver Contract. */
+    strict?: boolean
     /** Address of ENS Universal Resolver Contract. */
     universalResolverAddress?: Address
   }
@@ -73,6 +77,8 @@ export async function getEnsName<TChain extends Chain | undefined>(
     address,
     blockNumber,
     blockTag,
+    gatewayUrls,
+    strict,
     universalResolverAddress: universalResolverAddress_,
   }: GetEnsNameParameters,
 ): Promise<GetEnsNameReturnType> {
@@ -92,21 +98,28 @@ export async function getEnsName<TChain extends Chain | undefined>(
 
   const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
   try {
-    const [name, resolvedAddress] = await getAction(
-      client,
-      readContract,
-      'readContract',
-    )({
+    const readContractParameters = {
       address: universalResolverAddress,
       abi: universalResolverReverseAbi,
       functionName: 'reverse',
       args: [toHex(packetToBytes(reverseNode))],
       blockNumber,
       blockTag,
-    })
+    } as const
+
+    const readContractAction = getAction(client, readContract, 'readContract')
+
+    const [name, resolvedAddress] = gatewayUrls
+      ? await readContractAction({
+          ...readContractParameters,
+          args: [...readContractParameters.args, gatewayUrls],
+        })
+      : await readContractAction(readContractParameters)
+
     if (address.toLowerCase() !== resolvedAddress.toLowerCase()) return null
     return name
   } catch (err) {
+    if (strict) throw err
     if (isNullUniversalResolverError(err, 'reverse')) return null
     throw err
   }

package/actions/ens/getEnsText.ts

@@ -38,8 +38,12 @@ export type GetEnsTextParameters = Prettify<
   Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
     /** ENS name to get Text for. */
     name: string
+    /** Universal Resolver gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
     /** Text record to retrieve. */
     key: string
+    /** Whether or not to throw errors propagated from the ENS Universal Resolver Contract. */
+    strict?: boolean
     /** Address of ENS Universal Resolver Contract. */
     universalResolverAddress?: Address
   }
@@ -92,6 +96,8 @@ export async function getEnsText<TChain extends Chain | undefined>(
     blockTag,
     name,
     key,
+    gatewayUrls,
+    strict,
     universalResolverAddress: universalResolverAddress_,
   }: GetEnsTextParameters,
 ): Promise<GetEnsTextReturnType> {
@@ -110,11 +116,7 @@ export async function getEnsText<TChain extends Chain | undefined>(
   }
 
   try {
-    const res = await getAction(
-      client,
-      readContract,
-      'readContract',
-    )({
+    const readContractParameters = {
       address: universalResolverAddress,
       abi: universalResolverResolveAbi,
       functionName: 'resolve',
@@ -128,7 +130,16 @@ export async function getEnsText<TChain extends Chain | undefined>(
       ],
       blockNumber,
       blockTag,
-    })
+    } as const
+
+    const readContractAction = getAction(client, readContract, 'readContract')
+
+    const res = gatewayUrls
+      ? await readContractAction({
+          ...readContractParameters,
+          args: [...readContractParameters.args, gatewayUrls],
+        })
+      : await readContractAction(readContractParameters)
 
     if (res[0] === '0x') return null
 
@@ -140,6 +151,7 @@ export async function getEnsText<TChain extends Chain | undefined>(
 
     return record === '' ? null : record
   } catch (err) {
+    if (strict) throw err
     if (isNullUniversalResolverError(err, 'resolve')) return null
     throw err
   }

package/actions/public/estimateFeesPerGas.ts

@@ -143,16 +143,17 @@ export async function internal_estimateFeesPerGas<
     if (typeof block.baseFeePerGas !== 'bigint')
       throw new Eip1559FeesNotSupportedError()
 
-    const maxPriorityFeePerGas = request?.maxPriorityFeePerGas
-      ? request.maxPriorityFeePerGas
-      : await internal_estimateMaxPriorityFeePerGas(
-          client as Client<Transport, Chain>,
-          {
-            block: block as Block,
-            chain,
-            request,
-          },
-        )
+    const maxPriorityFeePerGas =
+      typeof request?.maxPriorityFeePerGas === 'bigint'
+        ? request.maxPriorityFeePerGas
+        : await internal_estimateMaxPriorityFeePerGas(
+            client as Client<Transport, Chain>,
+            {
+              block: block as Block,
+              chain,
+              request,
+            },
+          )
 
     const baseFeePerGas = multiply(block.baseFeePerGas)
     const maxFeePerGas =

package/actions/public/watchContractEvent.ts

@@ -292,8 +292,8 @@ export function watchContractEvent<
               })
               onLogs([formatted] as any)
             } catch (err) {
-              let eventName
-              let isUnnamed
+              let eventName: string | undefined
+              let isUnnamed: boolean | undefined
               if (
                 err instanceof DecodeLogDataMismatch ||
                 err instanceof DecodeLogTopicsMismatch

package/actions/public/watchEvent.ts

@@ -317,8 +317,8 @@ export function watchEvent<
               const formatted = formatLog(log, { args, eventName })
               onLogs([formatted] as any)
             } catch (err) {
-              let eventName
-              let isUnnamed
+              let eventName: string | undefined
+              let isUnnamed: boolean | undefined
               if (
                 err instanceof DecodeLogDataMismatch ||
                 err instanceof DecodeLogTopicsMismatch

package/actions/wallet/sendTransaction.ts

@@ -150,7 +150,7 @@ export async function sendTransaction<
   try {
     assertRequest(args as AssertRequestParameters)
 
-    let chainId
+    let chainId: number | undefined
     if (chain !== null) {
       chainId = await getAction(client, getChainId, 'getChainId')({})
       assertCurrentChain({

package/chains/definitions/baseSepolia.ts

@@ -16,9 +16,9 @@ export const baseSepolia = /*#__PURE__*/ defineChain({
   },
   blockExplorers: {
     default: {
-      name: 'Blockscout',
-      url: 'https://base-sepolia.blockscout.com',
-      apiUrl: 'https://base-sepolia.blockscout.com/api',
+      name: 'Basescan',
+      url: 'https://sepolia.basescan.org',
+      apiUrl: 'https://api-sepolia.basescan.org/api',
     },
   },
   contracts: {

package/chains/definitions/gnosis.ts

@@ -16,8 +16,9 @@ export const gnosis = /*#__PURE__*/ defineChain({
   },
   blockExplorers: {
     default: {
-      name: 'Gnosis Chain Explorer',
-      url: 'https://blockscout.com/xdai/mainnet',
+      name: 'Gnosisscan',
+      url: 'https://gnosisscan.io',
+      apiUrl: 'https://api.gnosisscan.io/api',
     },
   },
   contracts: {

package/chains/definitions/goerli.ts

@@ -21,8 +21,8 @@ export const goerli = /*#__PURE__*/ defineChain({
       address: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
     },
     ensUniversalResolver: {
-      address: '0x56522D00C410a43BFfDF00a9A569489297385790',
-      blockCreated: 8765204,
+      address: '0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1',
+      blockCreated: 10_339_206,
     },
     multicall3: {
       address: '0xca11bde05977b3631167028862be2a173976ca11',

package/chains/definitions/mainnet.ts

@@ -21,8 +21,8 @@ export const mainnet = /*#__PURE__*/ defineChain({
       address: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
     },
     ensUniversalResolver: {
-      address: '0xc0497E381f536Be9ce14B0dD3817cBcAe57d2F62',
-      blockCreated: 16_966_585,
+      address: '0x8cab227b1162f03b8338331adaad7aadc83b895e',
+      blockCreated: 18_958_930,
     },
     multicall3: {
       address: '0xca11bde05977b3631167028862be2a173976ca11',

package/chains/definitions/sepolia.ts

@@ -23,8 +23,8 @@ export const sepolia = /*#__PURE__*/ defineChain({
     },
     ensRegistry: { address: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e' },
     ensUniversalResolver: {
-      address: '0x21B000Fd62a880b2125A61e36a284BB757b76025',
-      blockCreated: 3914906,
+      address: '0xBaBC7678D7A63104f1658c11D6AE9A21cdA09725',
+      blockCreated: 5_043_334,
     },
   },
   testnet: true,

package/clients/transports/fallback.ts

@@ -220,8 +220,8 @@ export function rankTransports({
         const transport_ = transport({ chain, retryCount: 0, timeout })
 
         const start = Date.now()
-        let end
-        let success
+        let end: number
+        let success: number
         try {
           await transport_.request({ method: 'net_listening' })
           success = 1

package/constants/abis.ts

@@ -54,6 +54,41 @@ const universalResolverErrors = [
     name: 'ResolverWildcardNotSupported',
     type: 'error',
   },
+  {
+    inputs: [],
+    name: 'ResolverNotContract',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        name: 'returnData',
+        type: 'bytes',
+      },
+    ],
+    name: 'ResolverError',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            name: 'status',
+            type: 'uint16',
+          },
+          {
+            name: 'message',
+            type: 'string',
+          },
+        ],
+        name: 'errors',
+        type: 'tuple[]',
+      },
+    ],
+    name: 'HttpError',
+    type: 'error',
+  },
 ] as const
 
 export const universalResolverResolveAbi = [
@@ -71,6 +106,20 @@ export const universalResolverResolveAbi = [
       { name: 'address', type: 'address' },
     ],
   },
+  {
+    name: 'resolve',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'name', type: 'bytes' },
+      { name: 'data', type: 'bytes' },
+      { name: 'gateways', type: 'string[]' },
+    ],
+    outputs: [
+      { name: '', type: 'bytes' },
+      { name: 'address', type: 'address' },
+    ],
+  },
 ] as const
 
 export const universalResolverReverseAbi = [
@@ -87,6 +136,21 @@ export const universalResolverReverseAbi = [
       { type: 'address', name: 'resolver' },
     ],
   },
+  {
+    name: 'reverse',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'bytes', name: 'reverseName' },
+      { type: 'string[]', name: 'gateways' },
+    ],
+    outputs: [
+      { type: 'string', name: 'resolvedName' },
+      { type: 'address', name: 'resolvedAddress' },
+      { type: 'address', name: 'reverseResolver' },
+      { type: 'address', name: 'resolver' },
+    ],
+  },
 ] as const
 
 export const textResolverAbi = [

package/errors/contract.ts

@@ -176,8 +176,8 @@ export class ContractFunctionRevertedError extends BaseError {
   }: { abi: Abi; data?: Hex; functionName: string; message?: string }) {
     let cause: Error | undefined
     let decodedData: DecodeErrorResultReturnType | undefined = undefined
-    let metaMessages
-    let reason
+    let metaMessages: string[] | undefined
+    let reason: string | undefined
     if (data && data !== '0x') {
       try {
         decodedData = decodeErrorResult({ abi, data })

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.1.1'
+export const version = '2.3.1'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.1.1",
+  "version": "2.3.1",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -122,7 +122,7 @@
     "@noble/hashes": "1.3.2",
     "@scure/bip32": "1.3.2",
     "@scure/bip39": "1.2.1",
-    "abitype": "0.10.0",
+    "abitype": "1.0.0",
     "isows": "1.0.3",
     "ws": "8.13.0"
   },

package/utils/abi/parseEventLogs.ts

@@ -103,8 +103,8 @@ export function parseEventLogs<
         if (eventName && !eventName.includes(event.eventName!)) return null
         return { ...event, ...log }
       } catch (err) {
-        let eventName
-        let isUnnamed
+        let eventName: string | undefined
+        let isUnnamed: boolean | undefined
 
         if (err instanceof AbiEventSignatureNotFoundError) return null
         if (

package/utils/ccip.ts

@@ -124,7 +124,7 @@ export async function ccipFetch({
         },
       )
 
-      let result
+      let result: any
       if (
         response.headers.get('Content-Type')?.startsWith('application/json')
       ) {

package/utils/encoding/toHex.ts

@@ -187,7 +187,7 @@ export function numberToHex(
 
   const value = BigInt(value_)
 
-  let maxValue
+  let maxValue: bigint | number | undefined
   if (size) {
     if (signed) maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n
     else maxValue = 2n ** (BigInt(size) * 8n) - 1n

package/utils/ens/errors.ts

@@ -17,6 +17,9 @@ export function isNullUniversalResolverError(
   if (!(cause instanceof ContractFunctionRevertedError)) return false
   if (cause.data?.errorName === 'ResolverNotFound') return true
   if (cause.data?.errorName === 'ResolverWildcardNotSupported') return true
+  if (cause.data?.errorName === 'ResolverNotContract') return true
+  if (cause.data?.errorName === 'ResolverError') return true
+  if (cause.data?.errorName === 'HttpError') return true
   // Backwards compatibility for older UniversalResolver contracts
   if (
     cause.reason?.includes(

package/utils/rpc.ts

@@ -117,7 +117,7 @@ async function http<TBody extends RpcRequest | RpcRequest[]>(
       },
     )
 
-    let data
+    let data: any
     if (response.headers.get('Content-Type')?.startsWith('application/json')) {
       data = await response.json()
     } else {