@ensdomains/ensjs 3.0.1 → 3.2.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/functions/wallet/setAbiRecord.ts

@@ -22,7 +22,7 @@ export type SetAbiRecordDataParameters = {
   /** Name to set ABI for */
   name: string
   /** Encoded ABI data to set */
-  encodedAbi: EncodedAbi | null
+  encodedAbi: EncodedAbi
   /** Resolver address to set ABI on */
   resolverAddress: Address
 }
@@ -47,12 +47,11 @@ export const makeFunctionData = <
   _wallet: WalletWithEns<Transport, TChain, TAccount>,
   { name, encodedAbi, resolverAddress }: SetAbiRecordDataParameters,
 ): SetAbiRecordDataReturnType => {
-  const encodedAbi_ = encodedAbi || { contentType: 0, encodedData: null }
   return {
     to: resolverAddress,
     data: encodeSetAbi({
       namehash: namehash(name),
-      ...encodedAbi_,
+      ...encodedAbi,
     } as EncodeSetAbiParameters),
   }
 }

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
+}

package/src/utils/encoders/encodeAbi.ts

@@ -20,11 +20,11 @@ export type EncodeAbiParameters<TEncodeAs extends AbiEncodeAs = AbiEncodeAs> =
   TEncodeAs extends 'uri'
     ? {
         encodeAs: TEncodeAs
-        data: string
+        data: string | null
       }
     : {
         encodeAs: TEncodeAs
-        data: Record<any, any>
+        data: Record<any, any> | null
       }
 
 export type EncodedAbi<TContentType extends AbiContentType = AbiContentType> = {
@@ -72,27 +72,31 @@ export const encodeAbi = async <
   Prettify<EncodeAbiReturnType<TContentType>>
 > => {
   let contentType: AbiContentType
-  let encodedData: Hex
+  let encodedData: Hex = '0x'
   switch (encodeAs) {
     case 'json':
       contentType = 1
-      encodedData = stringToHex(JSON.stringify(data))
+      if (data) encodedData = stringToHex(JSON.stringify(data))
       break
     case 'zlib': {
       contentType = 2
-      const { deflate } = await import('pako/dist/pako_deflate.min.js')
-      encodedData = bytesToHex(deflate(JSON.stringify(data)))
+      if (data) {
+        const { deflate } = await import('pako/dist/pako_deflate.min.js')
+        encodedData = bytesToHex(deflate(JSON.stringify(data)))
+      }
       break
     }
     case 'cbor': {
       contentType = 4
-      const { cborEncode } = await import('@ensdomains/address-encoder/utils')
-      encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
+      if (data) {
+        const { cborEncode } = await import('@ensdomains/address-encoder/utils')
+        encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
+      }
       break
     }
     default: {
       contentType = 8
-      encodedData = stringToHex(data as string)
+      if (data) encodedData = stringToHex(data as string)
       break
     }
   }

package/src/utils/encoders/encodeSetAbi.ts

@@ -4,7 +4,7 @@ import type { EncodedAbi } from './encodeAbi.js'
 
 export type EncodeSetAbiParameters = {
   namehash: Hex
-} & (EncodedAbi | { contentType: 0; encodedData: null })
+} & EncodedAbi
 
 export type EncodeSetAbiReturnType = Hex
 
@@ -16,6 +16,6 @@ export const encodeSetAbi = ({
   return encodeFunctionData({
     abi: publicResolverSetAbiSnippet,
     functionName: 'setABI',
-    args: [namehash, BigInt(contentType), encodedData ?? '0x'],
+    args: [namehash, BigInt(contentType), encodedData],
   })
 }

package/src/utils/generateRecordCallArray.ts

@@ -26,7 +26,7 @@ export type RecordOptions = Prettify<{
   /** Array of coin records */
   coins?: Omit<EncodeSetAddrParameters, 'namehash'>[]
   /** ABI value */
-  abi?: EncodedAbi | null
+  abi?: EncodedAbi
 }>
 
 export const generateRecordCallArray = ({
@@ -49,8 +49,7 @@ export const generateRecordCallArray = ({
   }
 
   if (abi !== undefined) {
-    const abi_ = abi ?? { contentType: 0, encodedData: null }
-    const data = encodeSetAbi({ namehash, ...abi_ } as EncodeSetAbiParameters)
+    const data = encodeSetAbi({ namehash, ...abi } as EncodeSetAbiParameters)
     if (data) calls.push(data)
   }