viem 1.2.14 → 1.3.0

package/src/actions/ens/getEnsName.ts

@@ -2,15 +2,12 @@ import type { Address } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import { panicReasons } from '../../constants/solidity.js'
-import {
-  ContractFunctionExecutionError,
-  type ContractFunctionRevertedError,
-} from '../../errors/contract.js'
+import { universalResolverReverseAbi } from '../../constants/abis.js'
 import type { Chain } from '../../types/chain.js'
 import type { Prettify } from '../../types/utils.js'
 import { getChainContractAddress } from '../../utils/chain.js'
 import { toHex } from '../../utils/encoding/toHex.js'
+import { isNullUniversalResolverError } from '../../utils/ens/errors.js'
 import { packetToBytes } from '../../utils/ens/packetToBytes.js'
 import {
   type ReadContractParameters,
@@ -81,33 +78,15 @@ export async function getEnsName<TChain extends Chain | undefined>(
   try {
     const res = await readContract(client, {
       address: universalResolverAddress,
-      abi: [
-        {
-          name: 'reverse',
-          type: 'function',
-          stateMutability: 'view',
-          inputs: [{ type: 'bytes', name: 'reverseName' }],
-          outputs: [
-            { type: 'string', name: 'resolvedName' },
-            { type: 'address', name: 'resolvedAddress' },
-            { type: 'address', name: 'reverseResolver' },
-            { type: 'address', name: 'resolver' },
-          ],
-        },
-      ],
+      abi: universalResolverReverseAbi,
       functionName: 'reverse',
       args: [toHex(packetToBytes(reverseNode))],
       blockNumber,
       blockTag,
     })
     return res[0]
-  } catch (error) {
-    if (
-      error instanceof ContractFunctionExecutionError &&
-      (error.cause as ContractFunctionRevertedError).reason === panicReasons[50]
-    )
-      // No primary name set for address.
-      return null
-    throw error
+  } catch (err) {
+    if (isNullUniversalResolverError(err, 'reverse')) return null
+    throw err
   }
 }

package/src/actions/ens/getEnsText.ts

@@ -2,13 +2,17 @@ import type { Address } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import { textResolverAbi, universalResolverAbi } from '../../constants/abis.js'
+import {
+  textResolverAbi,
+  universalResolverResolveAbi,
+} from '../../constants/abis.js'
 import type { Chain } from '../../types/chain.js'
 import type { Prettify } from '../../types/utils.js'
 import { decodeFunctionResult } from '../../utils/abi/decodeFunctionResult.js'
 import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
 import { getChainContractAddress } from '../../utils/chain.js'
 import { toHex } from '../../utils/encoding/toHex.js'
+import { isNullUniversalResolverError } from '../../utils/ens/errors.js'
 import { namehash } from '../../utils/ens/namehash.js'
 import { packetToBytes } from '../../utils/ens/packetToBytes.js'
 import {
@@ -82,29 +86,34 @@ export async function getEnsText<TChain extends Chain | undefined>(
     })
   }
 
-  const res = await readContract(client, {
-    address: universalResolverAddress,
-    abi: universalResolverAbi,
-    functionName: 'resolve',
-    args: [
-      toHex(packetToBytes(name)),
-      encodeFunctionData({
-        abi: textResolverAbi,
-        functionName: 'text',
-        args: [namehash(name), key],
-      }),
-    ],
-    blockNumber,
-    blockTag,
-  })
+  try {
+    const res = await readContract(client, {
+      address: universalResolverAddress,
+      abi: universalResolverResolveAbi,
+      functionName: 'resolve',
+      args: [
+        toHex(packetToBytes(name)),
+        encodeFunctionData({
+          abi: textResolverAbi,
+          functionName: 'text',
+          args: [namehash(name), key],
+        }),
+      ],
+      blockNumber,
+      blockTag,
+    })
 
-  if (res[0] === '0x') return null
+    if (res[0] === '0x') return null
 
-  const record = decodeFunctionResult({
-    abi: textResolverAbi,
-    functionName: 'text',
-    data: res[0],
-  })
+    const record = decodeFunctionResult({
+      abi: textResolverAbi,
+      functionName: 'text',
+      data: res[0],
+    })
 
-  return record === '' ? null : record
+    return record === '' ? null : record
+  } catch (err) {
+    if (isNullUniversalResolverError(err, 'resolve')) return null
+    throw err
+  }
 }

package/src/chains/index.ts

@@ -11,6 +11,7 @@ export const aurora = /*#__PURE__*/ defineChain(chains.aurora)
 export const auroraTestnet = /*#__PURE__*/ defineChain(chains.auroraTestnet)
 export const avalanche = /*#__PURE__*/ defineChain(chains.avalanche)
 export const avalancheFuji = /*#__PURE__*/ defineChain(chains.avalancheFuji)
+export const base = /*#__PURE__*/ defineChain(chains.base)
 export const baseGoerli = /*#__PURE__*/ defineChain(chains.baseGoerli)
 export const boba = /*#__PURE__*/ defineChain(chains.boba)
 export const bronos = /*#__PURE__*/ defineChain(chains.bronos)
@@ -63,6 +64,8 @@ export const localhost = /*#__PURE__*/ defineChain(chains.localhost)
 export const mainnet = /*#__PURE__*/ defineChain(chains.mainnet)
 export const metis = /*#__PURE__*/ defineChain(chains.metis)
 export const metisGoerli = /*#__PURE__*/ defineChain(chains.metisGoerli)
+export const mev = /*#__PURE__*/ defineChain(chains.mev)
+export const mevTestnet = /*#__PURE__*/ defineChain(chains.mevTestnet)
 export const moonbaseAlpha = /*#__PURE__*/ defineChain(chains.moonbaseAlpha)
 export const moonbeam = /*#__PURE__*/ defineChain(chains.moonbeam)
 export const moonriver = /*#__PURE__*/ defineChain(chains.moonriver)

package/src/constants/abis.ts

@@ -43,7 +43,21 @@ export const multicall3Abi = [
   },
 ] as const
 
-export const universalResolverAbi = [
+const universalResolverErrors = [
+  {
+    inputs: [],
+    name: 'ResolverNotFound',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'ResolverWildcardNotSupported',
+    type: 'error',
+  },
+] as const
+
+export const universalResolverResolveAbi = [
+  ...universalResolverErrors,
   {
     name: 'resolve',
     type: 'function',
@@ -59,6 +73,22 @@ export const universalResolverAbi = [
   },
 ] as const
 
+export const universalResolverReverseAbi = [
+  ...universalResolverErrors,
+  {
+    name: 'reverse',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ type: 'bytes', name: 'reverseName' }],
+    outputs: [
+      { type: 'string', name: 'resolvedName' },
+      { type: 'address', name: 'resolvedAddress' },
+      { type: 'address', name: 'reverseResolver' },
+      { type: 'address', name: 'resolver' },
+    ],
+  },
+] as const
+
 export const textResolverAbi = [
   {
     name: 'text',

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '1.2.14'
+export const version = '1.2.15'

package/src/utils/ens/errors.ts

@@ -0,0 +1,27 @@
+import { panicReasons } from '../../constants/solidity.js'
+import { BaseError } from '../../errors/base.js'
+import { ContractFunctionRevertedError } from '../../errors/contract.js'
+
+/*
+ * @description Checks if error is a valid null result UniversalResolver error
+ */
+export function isNullUniversalResolverError(
+  err: unknown,
+  callType: 'resolve' | 'reverse',
+): boolean {
+  if (!(err instanceof BaseError)) return false
+  const cause = err.walk((e) => e instanceof ContractFunctionRevertedError)
+  if (!(cause instanceof ContractFunctionRevertedError)) return false
+  if (cause.data?.errorName === 'ResolverNotFound') return true
+  if (cause.data?.errorName === 'ResolverWildcardNotSupported') return true
+  // Backwards compatibility for older UniversalResolver contracts
+  if (
+    cause.reason?.includes(
+      'Wildcard on non-extended resolvers is not supported',
+    )
+  )
+    return true
+  // No primary name set for address.
+  if (callType === 'reverse' && cause.reason === panicReasons[50]) return true
+  return false
+}