@ensdomains/ensjs 3.0.1 → 3.2.0

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