@ensdomains/ensjs 3.0.0 → 3.1.0

package/src/functions/public/_getAbi.ts

@@ -19,6 +19,8 @@ import { namehash } from '../../utils/normalise.js'
 export type InternalGetAbiParameters = {
   /** Name to get ABI record for */
   name: string
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
 }
 
 export type InternalGetAbiReturnType = Prettify<DecodedAbi | null>
@@ -28,11 +30,11 @@ export type InternalGetAbiReturnType = Prettify<DecodedAbi | null>
 // ID 2: zlib compressed JSON
 // ID 4: CBOR
 // ID 8: URI
-const supportedContentTypes = BigInt('0xf')
+const supportedContentTypes = 0xfn
 
 const encode = (
   _client: ClientWithEns,
-  { name }: InternalGetAbiParameters,
+  { name }: Omit<InternalGetAbiParameters, 'strict'>,
 ): SimpleTransactionRequest => {
   return {
     to: EMPTY_ADDRESS,
@@ -47,66 +49,72 @@ const encode = (
 const decode = async (
   _client: ClientWithEns,
   data: Hex,
+  { strict }: Pick<InternalGetAbiParameters, 'strict'>,
 ): Promise<InternalGetAbiReturnType> => {
   if (data === '0x') return null
 
-  const [bigintContentType, encodedAbiData] = decodeFunctionResult({
-    abi: publicResolverAbiSnippet,
-    functionName: 'ABI',
-    data,
-  })
-
-  if (!bigintContentType || !encodedAbiData) {
-    return null
-  }
-
-  const contentType = Number(bigintContentType)
-  if (!contentType) {
-    return null
-  }
+  try {
+    const [bigintContentType, encodedAbiData] = decodeFunctionResult({
+      abi: publicResolverAbiSnippet,
+      functionName: 'ABI',
+      data,
+    })
 
-  let abiData: string | object
-  let decoded = false
-  switch (contentType) {
-    // JSON
-    case 1:
-      abiData = JSON.parse(hexToString(encodedAbiData))
-      decoded = true
-      break
-    // zlib compressed JSON
-    case 2: {
-      const { inflate } = await import('pako/dist/pako_inflate.min.js')
-      abiData = JSON.parse(
-        inflate(hexToBytes(encodedAbiData), { to: 'string' }),
-      )
-      decoded = true
-      break
+    if (!bigintContentType || !encodedAbiData) {
+      return null
     }
-    // CBOR
-    case 4: {
-      const { cborDecode } = await import('@ensdomains/address-encoder/utils')
-      abiData = await cborDecode(hexToBytes(encodedAbiData).buffer)
-      decoded = true
-      break
+
+    const contentType = Number(bigintContentType)
+    if (!contentType) {
+      return null
     }
-    // URI
-    case 8:
-      abiData = hexToString(encodedAbiData)
-      decoded = true
-      break
-    default:
-      try {
-        abiData = hexToString(encodedAbiData)
+
+    let abiData: string | object
+    let decoded = false
+    switch (contentType) {
+      // JSON
+      case 1:
+        abiData = JSON.parse(hexToString(encodedAbiData))
         decoded = true
-      } catch {
-        abiData = encodedAbiData
+        break
+      // zlib compressed JSON
+      case 2: {
+        const { inflate } = await import('pako/dist/pako_inflate.min.js')
+        abiData = JSON.parse(
+          inflate(hexToBytes(encodedAbiData), { to: 'string' }),
+        )
+        decoded = true
+        break
       }
-  }
+      // CBOR
+      case 4: {
+        const { cborDecode } = await import('@ensdomains/address-encoder/utils')
+        abiData = await cborDecode(hexToBytes(encodedAbiData).buffer)
+        decoded = true
+        break
+      }
+      // URI
+      case 8:
+        abiData = hexToString(encodedAbiData)
+        decoded = true
+        break
+      default:
+        try {
+          abiData = hexToString(encodedAbiData)
+          decoded = true
+        } catch {
+          abiData = encodedAbiData
+        }
+    }
 
-  return {
-    contentType,
-    decoded,
-    abi: abiData,
+    return {
+      contentType,
+      decoded,
+      abi: abiData,
+    }
+  } catch (error) {
+    if (strict) throw error
+    return null
   }
 }
 

package/src/functions/public/_getAddr.ts

@@ -28,13 +28,15 @@ export type InternalGetAddrParameters = {
   coin?: string | number
   /** Optionally return raw bytes value of address record (default: false) */
   bypassFormat?: boolean
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
 }
 
 export type InternalGetAddrReturnType = Prettify<DecodedAddr | null>
 
 const encode = (
   _client: ClientWithEns,
-  { name, coin = 60, bypassFormat }: InternalGetAddrParameters,
+  { name, coin = 60, bypassFormat }: Omit<InternalGetAddrParameters, 'strict'>,
 ): SimpleTransactionRequest => {
   const coder = getCoderFromCoin(coin)
   if (coder.coinType === 60) {
@@ -72,41 +74,46 @@ const encode = (
 const decode = async (
   _client: ClientWithEns,
   data: Hex,
-  { coin = 60 }: InternalGetAddrParameters,
+  { coin = 60, strict }: Pick<InternalGetAddrParameters, 'coin' | 'strict'>,
 ): Promise<InternalGetAddrReturnType> => {
   if (data === '0x') return null
 
   const coder = getCoderFromCoin(coin)
   let response: Hex
 
-  if (coder.coinType === 60) {
-    response = decodeFunctionResult({
-      abi: publicResolverSingleAddrSnippet,
-      functionName: 'addr',
-      data,
-    })
-  } else {
-    response = decodeFunctionResult({
-      abi: publicResolverMultiAddrSnippet,
-      functionName: 'addr',
-      data,
-    })
-  }
+  try {
+    if (coder.coinType === 60) {
+      response = decodeFunctionResult({
+        abi: publicResolverSingleAddrSnippet,
+        functionName: 'addr',
+        data,
+      })
+    } else {
+      response = decodeFunctionResult({
+        abi: publicResolverMultiAddrSnippet,
+        functionName: 'addr',
+        data,
+      })
+    }
 
-  if (!response) return null
+    if (!response) return null
 
-  const trimmed = trim(response)
-  if (trimmed === '0x' || trimmed === '0x0' || trimmed === '0x00') {
-    return null
-  }
+    const trimmed = trim(response)
+    if (trimmed === '0x' || trimmed === '0x0' || trimmed === '0x00') {
+      return null
+    }
+
+    const decodedAddr = coder.encode(hexToBytes(response))
 
-  const decodedAddr = coder.encode(hexToBytes(response))
+    if (!decodedAddr) {
+      return null
+    }
 
-  if (!decodedAddr) {
+    return { id: coder.coinType, name: coder.name, value: decodedAddr }
+  } catch (error) {
+    if (strict) throw error
     return null
   }
-
-  return { id: coder.coinType, name: coder.name, value: decodedAddr }
 }
 
 const _getAddr = generateFunction({ encode, decode })

package/src/functions/public/_getContentHash.ts

@@ -13,6 +13,8 @@ import { namehash } from '../../utils/normalise.js'
 export type InternalGetContentHashParameters = {
   /** Name to get content hash record for */
   name: string
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
 }
 
 export type InternalGetContentHashReturnType =
@@ -20,7 +22,7 @@ export type InternalGetContentHashReturnType =
 
 const encode = (
   _client: ClientWithEns,
-  { name }: InternalGetContentHashParameters,
+  { name }: Omit<InternalGetContentHashParameters, 'strict'>,
 ): SimpleTransactionRequest => {
   return {
     to: EMPTY_ADDRESS,
@@ -35,16 +37,22 @@ const encode = (
 const decode = async (
   _client: ClientWithEns,
   data: Hex,
+  { strict }: Pick<InternalGetContentHashParameters, 'strict'>,
 ): Promise<InternalGetContentHashReturnType> => {
   if (data === '0x') return null
 
-  const response = decodeFunctionResult({
-    abi: publicResolverContenthashSnippet,
-    functionName: 'contenthash',
-    data,
-  })
+  try {
+    const response = decodeFunctionResult({
+      abi: publicResolverContenthashSnippet,
+      functionName: 'contenthash',
+      data,
+    })
 
-  return decodeContentHash(response)
+    return decodeContentHash(response)
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
 }
 
 const _getContentHash = generateFunction({ encode, decode })

package/src/functions/public/_getText.ts

@@ -11,13 +11,15 @@ export type InternalGetTextParameters = {
   name: string
   /** Text record key to get */
   key: string
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
 }
 
 export type InternalGetTextReturnType = string | null
 
 const encode = (
   _client: ClientWithEns,
-  { name, key }: InternalGetTextParameters,
+  { name, key }: Omit<InternalGetTextParameters, 'strict'>,
 ): SimpleTransactionRequest => {
   return {
     to: EMPTY_ADDRESS,
@@ -32,18 +34,24 @@ const encode = (
 const decode = async (
   _client: ClientWithEns,
   data: Hex,
+  { strict }: Pick<InternalGetTextParameters, 'strict'>,
 ): Promise<InternalGetTextReturnType> => {
   if (data === '0x') return null
 
-  const response = decodeFunctionResult({
-    abi: publicResolverTextSnippet,
-    functionName: 'text',
-    data,
-  })
+  try {
+    const response = decodeFunctionResult({
+      abi: publicResolverTextSnippet,
+      functionName: 'text',
+      data,
+    })
 
-  if (!response) return null
+    if (!response) return null
 
-  return response
+    return response
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
 }
 
 const _getText = generateFunction({ encode, decode })

package/src/functions/public/getAbiRecord.ts

@@ -1,4 +1,4 @@
-import type { Hex } from 'viem'
+import type { BaseError, Hex } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import type {
   GenericPassthrough,
@@ -15,25 +15,38 @@ import _getAbi, {
 } from './_getAbi.js'
 import universalWrapper from './universalWrapper.js'
 
-export type GetAbiRecordParameters = Prettify<InternalGetAbiParameters>
+export type GetAbiRecordParameters = Prettify<
+  InternalGetAbiParameters & {
+    /** Batch gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
+  }
+>
 
 export type GetAbiRecordReturnType = Prettify<InternalGetAbiReturnType>
 
 const encode = (
   client: ClientWithEns,
-  { name }: GetAbiRecordParameters,
+  { name, gatewayUrls }: Omit<GetAbiRecordParameters, 'strict'>,
 ): SimpleTransactionRequest => {
   const prData = _getAbi.encode(client, { name })
-  return universalWrapper.encode(client, { name, data: prData.data })
+  return universalWrapper.encode(client, {
+    name,
+    data: prData.data,
+    gatewayUrls,
+  })
 }
 
 const decode = async (
   client: ClientWithEns,
-  data: Hex,
+  data: Hex | BaseError,
   passthrough: GenericPassthrough,
+  { strict }: Pick<GetAbiRecordParameters, 'strict'>,
 ): Promise<GetAbiRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough)
-  return _getAbi.decode(client, urData.data)
+  const urData = await universalWrapper.decode(client, data, passthrough, {
+    strict,
+  })
+  if (!urData) return null
+  return _getAbi.decode(client, urData.data, { strict })
 }
 
 type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
@@ -59,7 +72,7 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  */
 const getAbiRecord = generateFunction({ encode, decode }) as ((
   client: ClientWithEns,
-  { name }: GetAbiRecordParameters,
+  { name, strict }: GetAbiRecordParameters,
 ) => Promise<GetAbiRecordReturnType>) &
   BatchableFunctionObject
 

package/src/functions/public/getAddressRecord.ts

@@ -1,4 +1,4 @@
-import type { Hex } from 'viem'
+import type { BaseError, Hex } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import type {
   GenericPassthrough,
@@ -15,26 +15,42 @@ import _getAddr, {
 } from './_getAddr.js'
 import universalWrapper from './universalWrapper.js'
 
-export type GetAddressRecordParameters = Prettify<InternalGetAddrParameters>
+export type GetAddressRecordParameters = Prettify<
+  InternalGetAddrParameters & {
+    /** Batch gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
+  }
+>
 
 export type GetAddressRecordReturnType = Prettify<InternalGetAddrReturnType>
 
 const encode = (
   client: ClientWithEns,
-  { name, coin }: GetAddressRecordParameters,
+  {
+    name,
+    coin,
+    gatewayUrls,
+  }: Omit<GetAddressRecordParameters, 'strict' | 'bypassFormat'>,
 ): SimpleTransactionRequest => {
   const prData = _getAddr.encode(client, { name, coin })
-  return universalWrapper.encode(client, { name, data: prData.data })
+  return universalWrapper.encode(client, {
+    name,
+    data: prData.data,
+    gatewayUrls,
+  })
 }
 
 const decode = async (
   client: ClientWithEns,
-  data: Hex,
+  data: Hex | BaseError,
   passthrough: GenericPassthrough,
-  args: GetAddressRecordParameters,
+  { coin, strict }: Pick<GetAddressRecordParameters, 'coin' | 'strict'>,
 ): Promise<GetAddressRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough)
-  return _getAddr.decode(client, urData.data, args)
+  const urData = await universalWrapper.decode(client, data, passthrough, {
+    strict,
+  })
+  if (!urData) return null
+  return _getAddr.decode(client, urData.data, { coin, strict })
 }
 
 type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
@@ -60,7 +76,7 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  */
 const getAddressRecord = generateFunction({ encode, decode }) as ((
   client: ClientWithEns,
-  { name, coin, bypassFormat }: GetAddressRecordParameters,
+  { name, coin, bypassFormat, strict }: GetAddressRecordParameters,
 ) => Promise<GetAddressRecordReturnType>) &
   BatchableFunctionObject
 

package/src/functions/public/getContentHashRecord.ts

@@ -15,27 +15,39 @@ import _getContentHash, {
 } from './_getContentHash.js'
 import universalWrapper from './universalWrapper.js'
 
-export type GetContentHashRecordParameters =
-  Prettify<InternalGetContentHashParameters>
+export type GetContentHashRecordParameters = Prettify<
+  InternalGetContentHashParameters & {
+    /** Batch gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
+  }
+>
 
 export type GetContentHashRecordReturnType =
   Prettify<InternalGetContentHashReturnType>
 
 const encode = (
   client: ClientWithEns,
-  { name }: GetContentHashRecordParameters,
+  { name, gatewayUrls }: Omit<GetContentHashRecordParameters, 'strict'>,
 ): TransactionRequestWithPassthrough => {
   const prData = _getContentHash.encode(client, { name })
-  return universalWrapper.encode(client, { name, data: prData.data })
+  return universalWrapper.encode(client, {
+    name,
+    data: prData.data,
+    gatewayUrls,
+  })
 }
 
 const decode = async (
   client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: GenericPassthrough,
+  { strict }: Pick<GetContentHashRecordParameters, 'strict'>,
 ): Promise<GetContentHashRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough)
-  return _getContentHash.decode(client, urData.data)
+  const urData = await universalWrapper.decode(client, data, passthrough, {
+    strict,
+  })
+  if (!urData) return null
+  return _getContentHash.decode(client, urData.data, { strict })
 }
 
 type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
@@ -61,7 +73,7 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  */
 const getContentHashRecord = generateFunction({ encode, decode }) as ((
   client: ClientWithEns,
-  { name }: GetContentHashRecordParameters,
+  { name, strict }: GetContentHashRecordParameters,
 ) => Promise<GetContentHashRecordReturnType>) &
   BatchableFunctionObject
 

package/src/functions/public/getName.ts

@@ -1,9 +1,7 @@
 import {
   BaseError,
-  decodeErrorResult,
   decodeFunctionResult,
   encodeFunctionData,
-  getContractError,
   toHex,
   type Address,
   type Hex,
@@ -15,16 +13,22 @@ import type {
   GenericPassthrough,
   TransactionRequestWithPassthrough,
 } from '../../types.js'
+import { checkSafeUniversalResolverData } from '../../utils/checkSafeUniversalResolverData.js'
 import {
   generateFunction,
   type GeneratedFunction,
 } from '../../utils/generateFunction.js'
-import { getRevertErrorData } from '../../utils/getRevertErrorData.js'
 import { packetToBytes } from '../../utils/hexEncodedName.js'
 
 export type GetNameParameters = {
   /** Address to get name for */
   address: Address
+  /** Whether or not to allow mismatched forward resolution */
+  allowMismatch?: boolean
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
+  /** Batch gateway URLs to use for resolving CCIP-read requests. */
+  gatewayUrls?: string[]
 }
 
 export type GetNameReturnType = {
@@ -40,7 +44,7 @@ export type GetNameReturnType = {
 
 const encode = (
   client: ClientWithEns,
-  { address }: GetNameParameters,
+  { address, gatewayUrls }: Omit<GetNameParameters, 'allowMismatch' | 'strict'>,
 ): TransactionRequestWithPassthrough => {
   const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
   const to = getChainContractAddress({
@@ -48,14 +52,32 @@ const encode = (
     contract: 'ensUniversalResolver',
   })
   const args = [toHex(packetToBytes(reverseNode))] as const
+
   return {
     to,
-    data: encodeFunctionData({
-      abi: universalResolverReverseSnippet,
-      functionName: 'reverse',
-      args,
-    }),
-    passthrough: { address, args },
+    ...(gatewayUrls?.length
+      ? {
+          data: encodeFunctionData({
+            abi: universalResolverReverseSnippet,
+            functionName: 'reverse',
+            args: [...args, gatewayUrls] as const,
+          }),
+          passthrough: {
+            args: [...args, gatewayUrls],
+            address: to,
+          },
+        }
+      : {
+          data: encodeFunctionData({
+            abi: universalResolverReverseSnippet,
+            functionName: 'reverse',
+            args,
+          }),
+          passthrough: {
+            args,
+            address: to,
+          },
+        }),
   }
 }
 
@@ -63,39 +85,35 @@ const decode = async (
   _client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: GenericPassthrough,
-  { address }: GetNameParameters,
+  { address, allowMismatch, strict }: GetNameParameters,
 ): Promise<GetNameReturnType | null> => {
-  if (typeof data === 'object') {
-    const errorData = getRevertErrorData(data)
-    if (errorData) {
-      const decodedError = decodeErrorResult({
-        abi: universalResolverReverseSnippet,
-        data: errorData,
-      })
-      if (
-        decodedError.errorName === 'ResolverNotFound' ||
-        decodedError.errorName === 'ResolverWildcardNotSupported'
-      )
-        return null
-    }
-    throw getContractError(data, {
-      abi: universalResolverReverseSnippet,
-      functionName: 'reverse',
-      args: passthrough.args,
-      address: passthrough.address,
-    }) as BaseError
-  }
-  const result = decodeFunctionResult({
+  const isSafe = checkSafeUniversalResolverData(data, {
+    strict,
     abi: universalResolverReverseSnippet,
+    args: passthrough.args,
     functionName: 'reverse',
-    data,
+    address: passthrough.address,
   })
-  if (!result[0]) return null
-  return {
-    name: result[0],
-    match: result[1].toLowerCase() === address.toLowerCase(),
-    reverseResolverAddress: result[2],
-    resolverAddress: result[3],
+  if (!isSafe) return null
+
+  try {
+    const result = decodeFunctionResult({
+      abi: universalResolverReverseSnippet,
+      functionName: 'reverse',
+      data,
+    })
+    if (!result[0]) return null
+    const match = result[1].toLowerCase() === address.toLowerCase()
+    if (!match && !allowMismatch) return null
+    return {
+      name: result[0],
+      match: result[1].toLowerCase() === address.toLowerCase(),
+      reverseResolverAddress: result[2],
+      resolverAddress: result[3],
+    }
+  } catch (error) {
+    if (strict) throw error
+    return null
   }
 }
 
@@ -122,7 +140,7 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  */
 const getName = generateFunction({ encode, decode }) as ((
   client: ClientWithEns,
-  { address }: GetNameParameters,
+  { address, allowMismatch, strict }: GetNameParameters,
 ) => Promise<GetNameReturnType>) &
   BatchableFunctionObject