@ensdomains/ensjs 3.0.0-beta.5 → 3.0.0-beta.6

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)[] = []
@@ -255,82 +272,84 @@ const decode = async <TParams extends GetRecordsParameters>(
   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 +376,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

@@ -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

@@ -81,6 +81,28 @@ type BatchableFunctionObject = {
   }
 }
 
+/**
+ * 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[],
 >(

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

@@ -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

@@ -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/subgraph/getDecodedName.ts

@@ -32,7 +32,8 @@ type SubgraphResult = {
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getDecodedName } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getDecodedName } from '@ensdomains/ensjs/subgraph'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/subgraph/getNameHistory.ts

@@ -71,7 +71,8 @@ export type GetNameHistoryReturnType = {
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getNameHistory } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getNameHistory } from '@ensdomains/ensjs/subgraph'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/subgraph/getNamesForAddress.ts

@@ -43,6 +43,8 @@ type GetNamesForAddressRelation = {
 }
 
 type GetNamesForAddressFilter = GetNamesForAddressRelation & {
+  /** Search string filter for subname label */
+  searchString?: string
   /** Allows expired names to be included (default: false) */
   allowExpired?: boolean
   /** Allows reverse record nodes to be included (default: false) */
@@ -149,7 +151,8 @@ const getOrderByFilter = ({
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getNamesForAddress } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getNamesForAddress } from '@ensdomains/ensjs/subgraph'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),
@@ -161,24 +164,33 @@ const getNamesForAddress = async (
   client: ClientWithEns,
   {
     address,
-    filter = {
-      owner: true,
-      registrant: true,
-      resolvedAddress: true,
-      wrappedOwner: true,
-      allowExpired: false,
-      allowDeleted: false,
-      allowReverseRecord: false,
-    },
+    filter: _filter,
     orderBy = 'name',
     orderDirection = 'asc',
     pageSize = 100,
     previousPage,
   }: GetNamesForAddressParameters,
 ): Promise<GetNamesForAddressReturnType> => {
+  const filter = {
+    owner: true,
+    registrant: true,
+    resolvedAddress: true,
+    wrappedOwner: true,
+    allowExpired: false,
+    allowDeleted: false,
+    allowReverseRecord: false,
+    ..._filter,
+  }
+
   const subgraphClient = createSubgraphClient({ client })
 
-  const { allowExpired, allowDeleted, allowReverseRecord, ...filters } = filter
+  const {
+    allowExpired,
+    allowDeleted,
+    allowReverseRecord,
+    searchString,
+    ...filters
+  } = filter
   const ownerWhereFilters: DomainFilter[] = Object.entries(filters).reduce(
     (prev, [key, value]) => {
       if (value) {
@@ -268,6 +280,14 @@ const getNamesForAddress = async (
     })
   }
 
+  if (searchString) {
+    // using labelName_contains instead of name_contains because name_contains
+    // includes the parent name
+    whereFilters.push({
+      labelName_contains: searchString,
+    })
+  }
+
   const whereFilter: DomainFilter =
     whereFilters.length > 1 ? { and: whereFilters } : whereFilters[0]
 

package/src/functions/subgraph/getSubgraphRecords.ts

@@ -1,5 +1,6 @@
+import type { GraphQLClient } from 'graphql-request'
 import { gql } from 'graphql-request'
-import type { Address } from 'viem'
+import type { Address, Hex } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import type { DateWithValue } from '../../types.js'
 import { namehash } from '../../utils/normalise.js'
@@ -73,6 +74,59 @@ type CustomResolverSubgraphResult = {
   resolver?: ResolverResult
 }
 
+type GetResolverResultReturnType = {
+  domain: DomainResult
+  resolver: ResolverResult | undefined
+} | null
+
+const getCustomResolverResult = async (
+  subgraphClient: GraphQLClient,
+  {
+    id,
+    resolverAddress,
+  }: {
+    id: Hex
+    resolverAddress: Address
+  },
+): Promise<GetResolverResultReturnType> => {
+  const resolverId = `${resolverAddress.toLowerCase()}-${id}`
+  const response = await subgraphClient.request<CustomResolverSubgraphResult>(
+    customResolverQuery,
+    {
+      id,
+      resolverId,
+    },
+  )
+  if (!response || !response.domain) return null
+  return {
+    domain: response.domain,
+    resolver: response.resolver,
+  }
+}
+
+const getInheritedResolverResult = async (
+  subgraphClient: GraphQLClient,
+  {
+    id,
+  }: {
+    id: Hex
+  },
+): Promise<GetResolverResultReturnType> => {
+  const response =
+    await subgraphClient.request<InheritedResolverSubgraphResult>(
+      inheritedResolverQuery,
+      {
+        id,
+      },
+    )
+  if (!response || !response.domain) return null
+  const { resolver, ...domain } = response.domain
+  return {
+    domain,
+    resolver,
+  }
+}
+
 /**
  * Gets the records for a name from the subgraph
  * @param client - {@link ClientWithEns}
@@ -82,7 +136,8 @@ type CustomResolverSubgraphResult = {
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getSubgraphRecords } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getSubgraphRecords } from '@ensdomains/ensjs/subgraph'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),
@@ -103,39 +158,16 @@ const getSubgraphRecords = async (
   const subgraphClient = createSubgraphClient({ client })
   const id = namehash(name)
 
-  let domainResult: DomainResult
-  let resolverResult: ResolverResult | undefined
-
-  if (resolverAddress) {
-    const resolverId = `${resolverAddress.toLowerCase()}-${id}`
-    const response = await subgraphClient.request<CustomResolverSubgraphResult>(
-      customResolverQuery,
-      {
-        id,
-        resolverId,
-      },
-    )
-    if (!response || !response.domain) return null
-    domainResult = response.domain
-    resolverResult = response.resolver
-  } else {
-    const response =
-      await subgraphClient.request<InheritedResolverSubgraphResult>(
-        inheritedResolverQuery,
-        {
-          id,
-        },
-      )
-    if (!response || !response.domain) return null
-    const { resolver, ...domain_ } = response.domain
-    resolverResult = resolver
-    domainResult = domain_
-  }
+  const result = resolverAddress
+    ? await getCustomResolverResult(subgraphClient, { id, resolverAddress })
+    : await getInheritedResolverResult(subgraphClient, { id })
+  if (!result) return null
+  const { domain, resolver } = result
 
-  const { isMigrated, createdAt: stringCreatedAt } = domainResult
+  const { isMigrated, createdAt: stringCreatedAt } = domain
   const intCreatedAt = parseInt(stringCreatedAt) * 1000
-  const texts = resolverResult?.texts || []
-  const coins = resolverResult?.coinTypes || []
+  const texts = resolver?.texts || []
+  const coins = resolver?.coinTypes || []
 
   return {
     isMigrated,

package/src/functions/subgraph/getSubgraphRegistrant.ts

@@ -39,7 +39,8 @@ type SubgraphResult = {
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getSubgraphRegistrant } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getSubgraphRegistrant } from '@ensdomains/ensjs/subgraph'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/subgraph/getSubnames.ts

@@ -117,7 +117,8 @@ const getOrderByFilter = ({
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getSubnames } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getSubnames } from '@ensdomains/ensjs/subgraph'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),