@ensdomains/ensjs 3.0.1 → 3.2.0

package/src/contracts/universalResolver.ts

@@ -46,92 +46,128 @@ export const universalResolverErrors = [
   },
 ] as const
 
+const universalResolverReverse = {
+  inputs: [
+    {
+      name: 'reverseName',
+      type: 'bytes',
+    },
+  ],
+  name: 'reverse',
+  outputs: [
+    { type: 'string', name: 'resolvedName' },
+    { type: 'address', name: 'resolvedAddress' },
+    { type: 'address', name: 'reverseResolver' },
+    { type: 'address', name: 'resolver' },
+  ],
+  stateMutability: 'view',
+  type: 'function',
+} as const
+
 export const universalResolverReverseSnippet = [
   ...universalResolverErrors,
+  universalResolverReverse,
   {
+    ...universalResolverReverse,
     inputs: [
+      ...universalResolverReverse.inputs,
       {
-        name: 'reverseName',
-        type: 'bytes',
+        name: 'gateways',
+        type: 'string[]',
       },
     ],
-    name: 'reverse',
-    outputs: [
-      { type: 'string', name: 'resolvedName' },
-      { type: 'address', name: 'resolvedAddress' },
-      { type: 'address', name: 'reverseResolver' },
-      { type: 'address', name: 'resolver' },
-    ],
-    stateMutability: 'view',
-    type: 'function',
   },
 ] as const
 
+const universalResolverResolve = {
+  inputs: [
+    {
+      name: 'name',
+      type: 'bytes',
+    },
+    {
+      name: 'data',
+      type: 'bytes',
+    },
+  ],
+  name: 'resolve',
+  outputs: [
+    {
+      name: 'data',
+      type: 'bytes',
+    },
+    {
+      name: 'resolver',
+      type: 'address',
+    },
+  ],
+  stateMutability: 'view',
+  type: 'function',
+} as const
+
 export const universalResolverResolveSnippet = [
   ...universalResolverErrors,
+  universalResolverResolve,
   {
+    ...universalResolverResolve,
     inputs: [
+      ...universalResolverResolve.inputs,
       {
-        name: 'name',
-        type: 'bytes',
-      },
-      {
-        name: 'data',
-        type: 'bytes',
+        name: 'gateways',
+        type: 'string[]',
       },
     ],
-    name: 'resolve',
-    outputs: [
-      {
-        name: 'data',
-        type: 'bytes',
-      },
-      {
-        name: 'resolver',
-        type: 'address',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
   },
 ] as const
 
+const universalResolverResolveArray = {
+  inputs: [
+    {
+      name: 'name',
+      type: 'bytes',
+    },
+    {
+      name: 'data',
+      type: 'bytes[]',
+    },
+  ],
+  name: 'resolve',
+  outputs: [
+    {
+      components: [
+        {
+          name: 'success',
+          type: 'bool',
+        },
+        {
+          name: 'returnData',
+          type: 'bytes',
+        },
+      ],
+      name: '',
+      type: 'tuple[]',
+    },
+    {
+      name: '',
+      type: 'address',
+    },
+  ],
+  stateMutability: 'view',
+  type: 'function',
+} as const
+
 export const universalResolverResolveArraySnippet = [
   ...universalResolverErrors,
+  universalResolverResolveArray,
   {
+    ...universalResolverResolveArray,
     inputs: [
+      ...universalResolverResolveArray.inputs,
       {
-        name: 'name',
-        type: 'bytes',
-      },
-      {
-        name: 'data',
-        type: 'bytes[]',
-      },
-    ],
-    name: 'resolve',
-    outputs: [
-      {
-        components: [
-          {
-            name: 'success',
-            type: 'bool',
-          },
-          {
-            name: 'returnData',
-            type: 'bytes',
-          },
-        ],
-        name: '',
-        type: 'tuple[]',
-      },
-      {
-        name: '',
-        type: 'address',
+        name: 'gateways',
+        type: 'string[]',
       },
     ],
-    stateMutability: 'view',
-    type: 'function',
   },
 ] as const
 

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = 'v3.0.1'
+export const version = 'v3.2.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