@ensdomains/ensjs 3.0.1 → 3.1.0

package/src/functions/public/getTextRecord.ts

@@ -15,25 +15,38 @@ import _getText, {
 } from './_getText.js'
 import universalWrapper from './universalWrapper.js'
 
-export type GetTextRecordParameters = Prettify<InternalGetTextParameters>
+export type GetTextRecordParameters = Prettify<
+  InternalGetTextParameters & {
+    /** Batch gateway URLs to use for resolving CCIP-read requests. */
+    gatewayUrls?: string[]
+  }
+>
 
 export type GetTextRecordReturnType = Prettify<InternalGetTextReturnType>
 
 const encode = (
   client: ClientWithEns,
-  { name, key }: GetTextRecordParameters,
+  { name, key, gatewayUrls }: Omit<GetTextRecordParameters, 'strict'>,
 ): SimpleTransactionRequest => {
   const prData = _getText.encode(client, { name, key })
-  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<GetTextRecordParameters, 'strict'>,
 ): Promise<GetTextRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough)
-  return _getText.decode(client, urData.data)
+  const urData = await universalWrapper.decode(client, data, passthrough, {
+    strict,
+  })
+  if (!urData) return null
+  return _getText.decode(client, urData.data, { strict })
 }
 
 type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
@@ -59,7 +72,7 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  */
 const getTextRecord = generateFunction({ encode, decode }) as ((
   client: ClientWithEns,
-  { name, key }: GetTextRecordParameters,
+  { name, key, strict }: GetTextRecordParameters,
 ) => Promise<GetTextRecordReturnType>) &
   BatchableFunctionObject
 

package/src/functions/public/universalWrapper.ts

@@ -1,9 +1,7 @@
 import {
   BaseError,
-  decodeErrorResult,
   decodeFunctionResult,
   encodeFunctionData,
-  getContractError,
   labelhash,
   toBytes,
   toHex,
@@ -17,25 +15,26 @@ import type {
   GenericPassthrough,
   TransactionRequestWithPassthrough,
 } from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { checkSafeUniversalResolverData } from '../../utils/checkSafeUniversalResolverData.js'
 import { generateFunction } from '../../utils/generateFunction.js'
-import { getRevertErrorData } from '../../utils/getRevertErrorData.js'
 import { packetToBytes } from '../../utils/hexEncodedName.js'
 import { encodeLabelhash } from '../../utils/labels.js'
 
 export type UniversalWrapperParameters = {
   name: string
   data: Hex
+  strict?: boolean
+  gatewayUrls?: string[]
 }
 
 export type UniversalWrapperReturnType = {
   data: Hex
   resolver: Address
-}
+} | null
 
 const encode = (
   client: ClientWithEns,
-  { name, data }: UniversalWrapperParameters,
+  { name, data, gatewayUrls }: Omit<UniversalWrapperParameters, 'strict'>,
 ): TransactionRequestWithPassthrough => {
   const nameWithSizedLabels = name
     .split('.')
@@ -52,17 +51,32 @@ const encode = (
     contract: 'ensUniversalResolver',
   })
   const args = [toHex(packetToBytes(nameWithSizedLabels)), data] as const
+
   return {
-    to: getChainContractAddress({ client, contract: 'ensUniversalResolver' }),
-    data: encodeFunctionData({
-      abi: universalResolverResolveSnippet,
-      functionName: 'resolve',
-      args,
-    }),
-    passthrough: {
-      args,
-      address: to,
-    },
+    to,
+    ...(gatewayUrls?.length
+      ? {
+          data: encodeFunctionData({
+            abi: universalResolverResolveSnippet,
+            functionName: 'resolve',
+            args: [...args, gatewayUrls] as const,
+          }),
+          passthrough: {
+            args: [...args, gatewayUrls],
+            address: to,
+          },
+        }
+      : {
+          data: encodeFunctionData({
+            abi: universalResolverResolveSnippet,
+            functionName: 'resolve',
+            args,
+          }),
+          passthrough: {
+            args,
+            address: to,
+          },
+        }),
   }
 }
 
@@ -70,37 +84,29 @@ const decode = async (
   _client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: GenericPassthrough,
+  { strict }: Pick<UniversalWrapperParameters, 'strict'>,
 ): Promise<UniversalWrapperReturnType> => {
-  if (typeof data === 'object') {
-    const errorData = getRevertErrorData(data)
-    if (errorData) {
-      const decodedError = decodeErrorResult({
-        abi: universalResolverResolveSnippet,
-        data: errorData,
-      })
-      if (
-        decodedError.errorName === 'ResolverNotFound' ||
-        decodedError.errorName === 'ResolverWildcardNotSupported'
-      )
-        return {
-          data: '0x',
-          resolver: EMPTY_ADDRESS,
-        }
-    }
-    throw getContractError(data, {
-      abi: universalResolverResolveSnippet,
-      functionName: 'resolve',
-      args: passthrough.args,
-      address: passthrough.address,
-    }) as BaseError
-  }
-
-  const result = decodeFunctionResult({
+  const isSafe = checkSafeUniversalResolverData(data, {
+    strict,
     abi: universalResolverResolveSnippet,
+    args: passthrough.args,
     functionName: 'resolve',
-    data,
+    address: passthrough.address,
   })
-  return { data: result[0], resolver: result[1] }
+
+  if (!isSafe) return null
+
+  try {
+    const result = decodeFunctionResult({
+      abi: universalResolverResolveSnippet,
+      functionName: 'resolve',
+      data,
+    })
+    return { data: result[0], resolver: result[1] }
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
 }
 
 const universalWrapper = generateFunction({ encode, decode })

package/src/types.ts

@@ -18,9 +18,10 @@ export type SimpleTransactionRequest = {
   >
 }
 
-export type TransactionRequestWithPassthrough = SimpleTransactionRequest & {
-  passthrough?: any
-}
+export type TransactionRequestWithPassthrough<TPassthrough = any> =
+  SimpleTransactionRequest & {
+    passthrough?: TPassthrough
+  }
 
 export type GenericPassthrough = { args: any; address: Address }
 

package/src/utils/checkSafeUniversalResolverData.ts

@@ -0,0 +1,62 @@
+import {
+  CallExecutionError,
+  decodeErrorResult,
+  getContractError,
+  type BaseError,
+  type Hex,
+} from 'viem'
+import type { Prettify } from '../types.js'
+import { getRevertErrorData } from './getRevertErrorData.js'
+
+type CheckSafeUniversalResolverDataParameters = Prettify<
+  {
+    strict: boolean | undefined
+    args: any[] | (() => any[])
+  } & Omit<Parameters<typeof getContractError>[1], 'args'>
+>
+
+/**
+ * Checks if the data returned from a universal resolver is safe to use, or if it is a known revert error
+ * @param parameters - {@link CheckSafeUniversalResolverDataParameters}
+ * @returns `true` if the data is safe to use, `false` if it is a known revert error, or throws if it is an unknown error
+ */
+export const checkSafeUniversalResolverData = (
+  data: Hex | BaseError,
+  {
+    strict,
+    abi,
+    args,
+    functionName,
+    address,
+    docsPath,
+    sender,
+  }: CheckSafeUniversalResolverDataParameters,
+): data is Hex => {
+  if (typeof data === 'object') {
+    // if not strict, attempt to check if the error is a known revert error before throwing
+    // if it is a known revert error, return false instead of throwing
+    // even if strict is false, we want to throw unknown contract errors
+    if (!strict) {
+      const errorData = getRevertErrorData(data)
+      if (errorData) {
+        try {
+          decodeErrorResult({
+            abi,
+            data: errorData,
+          })
+          return false
+        } catch (error) {}
+      }
+    }
+    if (data instanceof CallExecutionError) throw data
+    throw getContractError(data, {
+      abi,
+      args: typeof args === 'function' ? args() : args,
+      functionName,
+      address,
+      docsPath,
+      sender,
+    }) as BaseError
+  }
+  return true
+}