@ensdomains/ensjs 3.0.0-beta.1 → 3.0.0-beta.11

package/src/functions/public/getRecords.ts

@@ -5,6 +5,7 @@ import {
   decodeFunctionResult,
   encodeFunctionData,
   getContractError,
+  hexToBigInt,
   toHex,
   type Address,
   type Hex,
@@ -106,39 +107,55 @@ const encode = (
   client: ClientWithEns,
   { name, resolver, records }: GetRecordsParameters,
 ): TransactionRequestWithPassthrough => {
-  const calls: (CallObj | null)[] = []
-  if (records.texts) {
-    for (const key of records.texts) {
-      calls.push({
-        key,
-        call: _getText.encode(client, { name, key }),
-        type: 'text',
-      })
+  const calls = Object.keys(records).reduce((prev, key) => {
+    if (key === 'texts') {
+      return [
+        ...prev,
+        ...records.texts!.map(
+          (text) =>
+            ({
+              key: text,
+              call: _getText.encode(client, { name, key: text }),
+              type: 'text',
+            } as const),
+        ),
+      ]
     }
-  }
-  if (records.coins) {
-    for (const coin of records.coins) {
-      calls.push({
-        key: coin,
-        call: _getAddr.encode(client, { name, coin }),
-        type: 'coin',
-      })
+    if (key === 'coins') {
+      return [
+        ...prev,
+        ...records.coins!.map(
+          (coin) =>
+            ({
+              key: coin,
+              call: _getAddr.encode(client, { name, coin }),
+              type: 'coin',
+            } as const),
+        ),
+      ]
     }
-  }
-  if (records.contentHash) {
-    calls.push({
-      key: 'contentHash',
-      call: _getContentHash.encode(client, { name }),
-      type: 'contentHash',
-    })
-  }
-  if (records.abi) {
-    calls.push({
-      key: 'abi',
-      call: _getAbi.encode(client, { name }),
-      type: 'abi',
-    })
-  }
+    if (key === 'contentHash') {
+      return [
+        ...prev,
+        {
+          key: 'contentHash',
+          call: _getContentHash.encode(client, { name }),
+          type: 'contentHash',
+        } as const,
+      ]
+    }
+    if (key === 'abi') {
+      return [
+        ...prev,
+        {
+          key: 'abi',
+          call: _getAbi.encode(client, { name }),
+          type: 'abi',
+        } as const,
+      ]
+    }
+    return prev
+  }, [] as (CallObj | null)[])
 
   const passthrough = calls
 
@@ -174,7 +191,7 @@ const decode = async <TParams extends GetRecordsParameters>(
   client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: (CallObj | null)[],
-  { name, resolver }: TParams,
+  { name, resolver, records: recordsParams }: TParams,
 ): Promise<GetRecordsReturnType<TParams>> => {
   const calls = passthrough
   let recordData: (Hex | null)[] = []
@@ -231,7 +248,7 @@ const decode = async <TParams extends GetRecordsParameters>(
           client,
           contract: 'ensUniversalResolver',
         }),
-      })
+      }) as BaseError
     }
     const result = decodeFunctionResult({
       abi: universalResolverResolveArraySnippet,
@@ -239,98 +256,96 @@ const decode = async <TParams extends GetRecordsParameters>(
       data,
     })
     ;[, resolverAddress] = result
-    recordData = [...result[0]]
-    for (let i = 0; i < recordData.length; i += 1) {
-      // error code for reverted call in batch
-      // this is expected when using offchain resolvers, so should be ignored
-      // Error((uint16, string)[])
-      // or if data is 0x, clear the call so there is no decoding errors
-      if (recordData[i]!.startsWith('0x0d1947a9') || recordData[i] === '0x') {
+    recordData = result[0].map((item, i) => {
+      if (!item.success) {
         calls[i] = null
-        recordData[i] = null
+        return null
       }
-    }
+      return item.returnData
+    })
   }
 
   const filteredCalls = calls.filter((x) => x) as CallObj[]
   const filteredRecordData = recordData.filter((x) => x) as Hex[]
 
-  const returnedRecords: GetRecordsReturnType<GetRecordsParameters> =
-    await Promise.all(
-      filteredRecordData.map(async (item, i) => {
-        const { key, type } = filteredCalls[i]
-        const baseItem = { key, type }
-        if (type === 'contentHash') {
-          const decodedFromAbi = decodeAbiParameters(
-            [{ type: 'bytes' }] as const,
-            item,
-          )[0]
-          if (BigInt(decodedFromAbi) === 0n) {
-            return { ...baseItem, value: null }
-          }
+  const decodedRecords = await Promise.all(
+    filteredRecordData.map(async (item, i) => {
+      const { key, type } = filteredCalls[i]
+      const baseItem = { key, type }
+      if (type === 'contentHash') {
+        const decodedFromAbi = decodeAbiParameters(
+          [{ type: 'bytes' }] as const,
+          item,
+        )[0]
+        if (decodedFromAbi === '0x' || hexToBigInt(decodedFromAbi) === 0n) {
+          return { ...baseItem, value: null }
+        }
+      }
+      if (type === 'text') {
+        const decodedFromAbi = await _getText.decode(client, item)
+        return { ...baseItem, value: decodedFromAbi }
+      }
+      if (type === 'coin') {
+        const decodedFromAbi = await _getAddr.decode(client, item, {
+          name,
+          coin: key,
+        })
+        return { ...baseItem, value: decodedFromAbi }
+      }
+      if (type === 'contentHash') {
+        const decodedFromAbi = await _getContentHash.decode(client, item)
+        return { ...baseItem, value: decodedFromAbi }
+      }
+      // abi
+      const decodedFromAbi = await _getAbi.decode(client, item)
+      return { ...baseItem, value: decodedFromAbi }
+    }),
+  )
+
+  const records = decodedRecords.reduce(
+    (prev, curr) => {
+      if (curr.type === 'text' || curr.type === 'coin') {
+        if (!curr.value) {
+          return prev
         }
-        if (type === 'text') {
-          const decodedFromAbi = await _getText.decode(client, item)
-          return { ...baseItem, value: decodedFromAbi }
+      }
+      if (curr.type === 'text') {
+        return {
+          ...prev,
+          texts: [
+            ...(prev.texts || []),
+            { key: curr.key, value: curr.value } as DecodedText,
+          ],
         }
-        if (type === 'coin') {
-          const decodedFromAbi = await _getAddr.decode(client, item, {
-            name,
-            coin: key,
-          })
-          return { ...baseItem, value: decodedFromAbi }
+      }
+      if (curr.type === 'coin') {
+        return {
+          ...prev,
+          coins: [...(prev.coins || []), curr.value as DecodedAddr],
         }
-        if (type === 'contentHash') {
-          const decodedFromAbi = await _getContentHash.decode(client, item)
-          return { ...baseItem, value: decodedFromAbi }
+      }
+      if (curr.type === 'contentHash') {
+        return {
+          ...prev,
+          contentHash: curr.value as InternalGetContentHashReturnType,
         }
-        // abi
-        const decodedFromAbi = await _getAbi.decode(client, item)
-        return { ...baseItem, value: decodedFromAbi }
-      }),
-    ).then((results) =>
-      results.reduce(
-        (prev, curr) => {
-          if (curr.type === 'text' || curr.type === 'coin') {
-            if (!curr.value) {
-              return prev
-            }
-          }
-          if (curr.type === 'text') {
-            return {
-              ...prev,
-              texts: [
-                ...(prev.texts || []),
-                { key: curr.key, value: curr.value } as DecodedText,
-              ],
-            }
-          }
-          if (curr.type === 'coin') {
-            return {
-              ...prev,
-              coins: [...(prev.coins || []), curr.value as DecodedAddr],
-            }
-          }
-          if (curr.type === 'contentHash') {
-            return {
-              ...prev,
-              contentHash: curr.value as InternalGetContentHashReturnType,
-            }
-          }
-          // abi
-          return { ...prev, abi: curr.value as InternalGetAbiReturnType }
-        },
-        {
-          resolverAddress,
-        } as GetRecordsReturnType<
-          GetRecordsParameters & {
-            records: Required<GetRecordsParameters['records']>
-          }
-        >,
-      ),
-    )
+      }
+      // abi
+      return { ...prev, abi: curr.value as InternalGetAbiReturnType }
+    },
+    {
+      resolverAddress,
+      ...('texts' in recordsParams ? { texts: [] } : {}),
+      ...('coins' in recordsParams ? { coins: [] } : {}),
+      ...('contentHash' in recordsParams ? { contentHash: null } : {}),
+    } as GetRecordsReturnType<
+      GetRecordsParameters & {
+        records: Required<GetRecordsParameters['records']>
+      }
+    >,
+  )
 
-  return returnedRecords as GetRecordsReturnType<TParams>
+  return records as GetRecordsReturnType<TParams>
 }
 
 type EncoderFunction = typeof encode
@@ -357,7 +372,8 @@ type BatchableFunctionObject = {
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getRecords } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getRecords } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getResolver.ts

@@ -59,7 +59,7 @@ const decode = async (
       functionName: 'findResolver',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   const response = decodeFunctionResult({
     abi: universalResolverFindResolverSnippet,
     functionName: 'findResolver',
@@ -82,7 +82,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getResolver } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getResolver } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getSupportedInterfaces.ts

@@ -1,4 +1,10 @@
-import { BaseError, encodeFunctionData, type Address, type Hex } from 'viem'
+import {
+  BaseError,
+  encodeFunctionData,
+  padHex,
+  type Address,
+  type Hex,
+} from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import { erc165SupportsInterfaceSnippet } from '../../contracts/erc165.js'
 import type {
@@ -8,12 +14,18 @@ import type {
 import { generateFunction } from '../../utils/generateFunction.js'
 import multicallWrapper from './multicallWrapper.js'
 
-export type GetSupportedInterfacesParameters = {
+export type GetSupportedInterfacesParameters<
+  TInterfaces extends readonly Hex[],
+> = {
   address: Address
-  interfaces: Hex[]
+  interfaces: TInterfaces
 }
 
-export type GetSupportedInterfacesReturnType = boolean[]
+export type GetSupportedInterfacesReturnType<
+  TInterfaces extends readonly Hex[],
+> = {
+  -readonly [K in keyof TInterfaces]: boolean
+}
 
 const encodeInterface = (interfaceId: Hex): Hex =>
   encodeFunctionData({
@@ -22,9 +34,9 @@ const encodeInterface = (interfaceId: Hex): Hex =>
     args: [interfaceId],
   })
 
-const encode = (
+const encode = <TInterfaces extends Hex[]>(
   client: ClientWithEns,
-  { address, interfaces }: GetSupportedInterfacesParameters,
+  { address, interfaces }: GetSupportedInterfacesParameters<TInterfaces>,
 ): TransactionRequestWithPassthrough => {
   const calls = interfaces.map((interfaceId) => ({
     to: address,
@@ -39,16 +51,64 @@ const encode = (
   }
 }
 
-const decode = async (
+const decode = async <const TInterfaces extends readonly Hex[]>(
   client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: SimpleTransactionRequest[],
-): Promise<GetSupportedInterfacesReturnType> => {
+): Promise<GetSupportedInterfacesReturnType<TInterfaces>> => {
   if (typeof data === 'object') throw data
   const result = await multicallWrapper.decode(client, data, passthrough)
-  return result.map((r) => r.success && r.returnData === '0x01')
+  return result.map(
+    (r) => r.success && r.returnData === padHex('0x01'),
+  ) as GetSupportedInterfacesReturnType<TInterfaces>
+}
+
+type EncoderFunction = typeof encode
+type DecoderFunction = typeof decode
+
+type BatchableFunctionObject = {
+  encode: EncoderFunction
+  decode: DecoderFunction
+  batch: <
+    const TInterfaces extends readonly Hex[],
+    TParams extends GetSupportedInterfacesParameters<TInterfaces>,
+  >(
+    args: TParams,
+  ) => {
+    args: [TParams]
+    encode: EncoderFunction
+    decode: typeof decode<TInterfaces>
+  }
 }
 
-const getSupportedInterfaces = generateFunction({ encode, decode })
+/**
+ * Gets the supported interfaces for any contract address.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetSupportedInterfacesParameters}
+ * @returns Array of booleans matching the input array {@link GetSupportedInterfacesReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getSupportedInterfaces } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getSupportedInterfaces(client, {
+ *   address: '0x58774Bb8acD458A640aF0B88238369A167546ef2',
+ *   interfaces: ['0x2f435428', '0x23b872dd'],
+ * })
+ * // [true, false]
+ */
+const getSupportedInterfaces = generateFunction({ encode, decode }) as (<
+  const TInterfaces extends readonly Hex[],
+>(
+  client: ClientWithEns,
+  { address, interfaces }: GetSupportedInterfacesParameters<TInterfaces>,
+) => Promise<GetSupportedInterfacesReturnType<TInterfaces>>) &
+  BatchableFunctionObject
 
 export default getSupportedInterfaces

package/src/functions/public/getTextRecord.ts

@@ -47,7 +47,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getTextRecord } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getTextRecord } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getWrapperData.ts

@@ -16,7 +16,7 @@ import type {
   TransactionRequestWithPassthrough,
 } from '../../types.js'
 import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { decodeFuses } from '../../utils/fuses.js'
+import { decodeFuses, type DecodedFuses } from '../../utils/fuses.js'
 import {
   generateFunction,
   type GeneratedFunction,
@@ -31,7 +31,7 @@ export type GetWrapperDataParameters = {
 
 export type GetWrapperDataReturnType = Prettify<{
   /** Fuse object */
-  fuses: ReturnType<typeof decodeFuses> & {
+  fuses: DecodedFuses & {
     value: number
   }
   /** Expiry of the name */
@@ -71,7 +71,7 @@ const decode = async (
       functionName: 'getData',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   const [owner, fuses, expiry] = decodeFunctionResult({
     abi: nameWrapperGetDataSnippet,
     functionName: 'getData',
@@ -111,7 +111,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getWrapperData } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getWrapperData } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getWrapperName.ts

@@ -58,7 +58,7 @@ const decode = async (
       functionName: 'names',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   const result = decodeFunctionResult({
     abi: nameWrapperNamesSnippet,
     functionName: 'names',
@@ -79,7 +79,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getWrapperName } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getWrapperName } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/multicallWrapper.ts

@@ -52,7 +52,7 @@ const decode = async (
       abi: multicallTryAggregateSnippet,
       functionName: 'tryAggregate',
       args: [],
-    })
+    }) as BaseError
   }
   const result = decodeFunctionResult({
     abi: multicallTryAggregateSnippet,

package/src/functions/public/universalWrapper.ts

@@ -92,7 +92,7 @@ const decode = async (
       functionName: 'resolve',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   }
 
   const result = decodeFunctionResult({

package/src/functions/subgraph/client.ts

@@ -1,6 +1,6 @@
 import type { Kind, SelectionNode, SelectionSetNode } from 'graphql'
+import type { RequestMiddleware, ResponseMiddleware } from 'graphql-request'
 import { GraphQLClient } from 'graphql-request'
-import type { RequestMiddleware, Response } from 'graphql-request/dist/types.js'
 import { parse, print, visit } from 'graphql/language/index.js'
 import traverse from 'traverse'
 import type { ClientWithEns } from '../../contracts/consts.js'
@@ -56,7 +56,7 @@ export const requestMiddleware: RequestMiddleware = (request) => {
   }
 }
 
-export const responseMiddleware = (response: Response<unknown> | Error) => {
+export const responseMiddleware: ResponseMiddleware = (response) => {
   traverse(response).forEach(function (responseItem: unknown) {
     if (
       responseItem instanceof Object &&