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

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

@@ -1,7 +1,8 @@
-import { formatsByCoinType } from '@ensdomains/address-encoder'
+import { getCoderByCoinType } from '@ensdomains/address-encoder'
 import { gql } from 'graphql-request'
+import { hexToBytes } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
-import { decodeContenthash } from '../../utils/contentHash.js'
+import { decodeContentHash } from '../../utils/contentHash.js'
 import { namehash } from '../../utils/normalise.js'
 import { createSubgraphClient } from './client.js'
 import type {
@@ -71,7 +72,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),
@@ -275,7 +277,7 @@ const getNameHistory = async (
         }
         case 'MulticoinAddrChanged': {
           const { multiaddr, ...event_ } = event
-          const format = formatsByCoinType[parseInt(event.coinType)]
+          const format = getCoderByCoinType(parseInt(event.coinType))
           if (!format) {
             return {
               ...event_,
@@ -296,11 +298,11 @@ const getNameHistory = async (
             ...event_,
             coinName: format.name,
             decoded: true,
-            addr: format.encoder(Buffer.from(multiaddr.slice(2), 'hex')),
+            addr: format.encode(hexToBytes(multiaddr)),
           }
         }
         case 'ContenthashChanged': {
-          const { decoded: contentHash, protocolType } = decodeContenthash(
+          const { decoded: contentHash, protocolType } = decodeContentHash(
             event.hash,
           ) || { protocolType: null, decoded: null }
           return {

package/src/functions/subgraph/getNamesForAddress.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { gql } from 'graphql-request'
 import type { Address } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
@@ -6,8 +7,9 @@ import {
   InvalidFilterKeyError,
   InvalidOrderByError,
 } from '../../errors/subgraph.js'
-import { GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
+import { EMPTY_ADDRESS, GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
 import { createSubgraphClient } from './client.js'
+import type { DomainFilter } from './filters.js'
 import {
   domainDetailsFragment,
   registrationDetailsFragment,
@@ -16,6 +18,13 @@ import {
 } from './fragments.js'
 import { makeNameObject, type Name } from './utils.js'
 
+const supportedOwnerFilters = [
+  'owner',
+  'registrant',
+  'wrappedOwner',
+  'resolvedAddress',
+] as const
+
 type GetNamesForAddressOrderBy =
   | 'expiryDate'
   | 'name'
@@ -34,10 +43,14 @@ 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) */
   allowReverseRecord?: boolean
+  /** Allows deleted names to be included (default: false) */
+  allowDeleted?: boolean
 }
 
 export type GetNamesForAddressParameters = {
@@ -65,6 +78,70 @@ type SubgraphResult = {
   domains: SubgraphDomain[]
 }
 
+const getOrderByFilter = ({
+  orderBy,
+  orderDirection,
+  previousPage,
+}: Required<
+  Pick<
+    GetNamesForAddressParameters,
+    'orderBy' | 'orderDirection' | 'previousPage'
+  >
+>): DomainFilter => {
+  const lastDomain = previousPage[previousPage.length - 1]
+  const operator = orderDirection === 'asc' ? 'gt' : 'lt'
+
+  switch (orderBy) {
+    case 'expiryDate': {
+      let lastExpiryDate = lastDomain.expiryDate?.value
+        ? lastDomain.expiryDate.value / 1000
+        : 0
+      if (lastDomain.parentName === 'eth') {
+        lastExpiryDate += GRACE_PERIOD_SECONDS
+      }
+
+      if (orderDirection === 'asc' && lastExpiryDate === 0) {
+        return {
+          and: [{ expiryDate: null }, { [`id_${operator}`]: lastDomain.id }],
+        }
+      }
+      if (orderDirection === 'desc' && lastExpiryDate !== 0) {
+        return {
+          [`expiryDate_${operator}`]: `${lastExpiryDate}`,
+        }
+      }
+      return {
+        or: [
+          {
+            [`expiryDate_${operator}`]: `${lastExpiryDate}`,
+          },
+          { expiryDate: null },
+        ],
+      }
+    }
+    case 'name': {
+      return {
+        [`name_${operator}`]: lastDomain.name ?? '',
+      }
+    }
+    case 'labelName': {
+      return {
+        [`labelName_${operator}`]: lastDomain.labelName ?? '',
+      }
+    }
+    case 'createdAt': {
+      return {
+        [`createdAt_${operator}`]: `${lastDomain.createdAt.value / 1000}`,
+      }
+    }
+    default:
+      throw new InvalidOrderByError({
+        orderBy: orderBy || '<no orderBy provided>',
+        supportedOrderBys: ['expiryDate', 'name', 'labelName', 'createdAt'],
+      })
+  }
+}
+
 /**
  * Gets the names for an address from the subgraph.
  * @param client - {@link ClientWithEns}
@@ -74,7 +151,8 @@ type SubgraphResult = {
  * @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),
@@ -86,247 +164,173 @@ const getNamesForAddress = async (
   client: ClientWithEns,
   {
     address,
-    filter = {
-      owner: true,
-      registrant: true,
-      resolvedAddress: true,
-      wrappedOwner: true,
-      allowExpired: 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 })
 
-  let ownerWhereFilter = `
-    or: [
-  `
-  let hasFilterApplied = false
-  const { allowExpired, allowReverseRecord, ...filters } = filter
-  for (const [key, value] of Object.entries(filters)) {
-    if (value) {
-      hasFilterApplied = true
-      switch (key) {
-        case 'owner': {
-          ownerWhereFilter += `
-            { owner: $address }
-          `
-          break
-        }
-        case 'registrant': {
-          ownerWhereFilter += `
-            { registrant: $address }
-          `
-          break
-        }
-        case 'wrappedOwner': {
-          ownerWhereFilter += `
-            { wrappedOwner: $address }
-          `
-          break
-        }
-        case 'resolvedAddress': {
-          ownerWhereFilter += `
-            { resolvedAddress: $address }
-          `
-          break
-        }
-        default:
+  const {
+    allowExpired,
+    allowDeleted,
+    allowReverseRecord,
+    searchString,
+    ...filters
+  } = filter
+  const ownerWhereFilters: DomainFilter[] = Object.entries(filters).reduce(
+    (prev, [key, value]) => {
+      if (value) {
+        if (!supportedOwnerFilters.includes(key as any))
           throw new InvalidFilterKeyError({
             filterKey: key,
-            supportedFilterKeys: [
-              'owner',
-              'registrant',
-              'wrappedOwner',
-              'resolvedAddress',
-            ],
+            supportedFilterKeys: supportedOwnerFilters,
           })
+        return [
+          ...prev,
+          {
+            [key]: address.toLowerCase(),
+          },
+        ]
       }
-    }
-  }
+      return prev
+    },
+    [] as DomainFilter[],
+  )
+
+  const hasFilterApplied = ownerWhereFilters.length > 0
 
   if (!hasFilterApplied)
     throw new FilterKeyRequiredError({
-      supportedFilterKeys: [
-        'owner',
-        'registrant',
-        'wrappedOwner',
-        'resolvedAddress',
-      ],
+      supportedFilterKeys: supportedOwnerFilters,
       details: 'At least one ownership filter must be enabled',
     })
 
-  ownerWhereFilter += `
-    ]
-  `
-
-  const whereFilters = [ownerWhereFilter]
-
-  let orderByFilter = ''
-  let orderByStringVar = ''
+  const ownerWhereFilter: DomainFilter =
+    ownerWhereFilters.length > 1
+      ? { or: ownerWhereFilters }
+      : ownerWhereFilters[0]
+  const whereFilters: DomainFilter[] = [ownerWhereFilter]
 
-  if (previousPage && previousPage.length > 0) {
-    const lastDomain = previousPage[previousPage.length - 1]
-    const operator = orderDirection === 'asc' ? 'gt' : 'lt'
-    switch (orderBy) {
-      case 'expiryDate': {
-        let lastExpiryDate = lastDomain.expiryDate?.value
-          ? lastDomain.expiryDate.value / 1000
-          : 0
-        if (lastDomain.parentName === 'eth') {
-          lastExpiryDate += GRACE_PERIOD_SECONDS
-        }
-        if (orderDirection === 'asc' && lastExpiryDate === 0) {
-          orderByFilter = `
-              {
-                and: [
-                  { expiryDate: null }
-                  { id_${operator}: "${lastDomain.id}" }
-                ]
-              }
-            `
-        } else if (orderDirection === 'desc' && lastExpiryDate !== 0) {
-          orderByFilter = `
-            {
-              expiryDate_${operator}: ${lastExpiryDate}
-            }
-          `
-        } else {
-          orderByFilter = `
-            {
-              or: [
-                {
-                  expiryDate_${operator}: ${lastExpiryDate}
-                }
-                { expiryDate: null }
-              ]
-            }
-          `
-        }
-        break
-      }
-      case 'name': {
-        orderByFilter = `
-          {
-            name_${operator}: $orderByStringVar
-          }
-        `
-        orderByStringVar = lastDomain.name ?? ''
-        break
-      }
-      case 'labelName': {
-        orderByFilter = `
-          {
-            labelName_${operator}: $orderByStringVar
-          }
-        `
-        orderByStringVar = lastDomain.labelName ?? ''
-        break
-      }
-      case 'createdAt': {
-        orderByFilter = `
-          {
-            createdAt_${operator}: ${lastDomain.createdAt.value / 1000}
-          }
-        `
-        break
-      }
-      default:
-        throw new InvalidOrderByError({
-          orderBy,
-          supportedOrderBys: ['expiryDate', 'name', 'labelName', 'createdAt'],
-        })
-    }
-    whereFilters.push(orderByFilter)
+  if (previousPage?.length) {
+    whereFilters.push(
+      getOrderByFilter({
+        orderBy,
+        orderDirection,
+        previousPage,
+      }),
+    )
   }
 
   if (!allowReverseRecord) {
     // Exclude domains with parent addr.reverse
     // namehash of addr.reverse = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2
-    whereFilters.push(`
-      {
-        parent_not: "0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2"
-      }
-    `)
+    whereFilters.push({
+      parent_not:
+        '0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2',
+    })
   }
 
   if (!allowExpired) {
     // Exclude domains that are expired
     // if expiryDate is null, there is no expiry on the domain (registration or wrapped)
-    whereFilters.push(`
-      {
-        or: [
-          { expiryDate_gt: $expiryDate }
-          { expiryDate: null }
-        ]
-      }
-    `)
+    whereFilters.push({
+      or: [
+        { expiryDate_gt: `${Math.floor(Date.now() / 1000)}` },
+        { expiryDate: null },
+      ],
+    })
   }
 
-  const whereFilter =
-    whereFilters.length > 1
-      ? `
-    and: [
-      {
-        ${whereFilters.shift()}
-      }
-      ${whereFilters.join('\n')}
-    ]
-  `
-      : whereFilters[0]
+  if (!allowDeleted) {
+    // exclude "deleted" domains
+    // when owner/resolver/registrant = null
+    whereFilters.push({
+      or: [
+        {
+          owner_not: EMPTY_ADDRESS,
+        },
+        {
+          resolver_not: null,
+        },
+        {
+          and: [
+            {
+              registrant_not: EMPTY_ADDRESS,
+            },
+            {
+              registrant_not: null,
+            },
+          ],
+        },
+      ],
+    })
+  }
+
+  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]
 
   const query = gql`
-      query getNamesForAddress(
-        $address: String!
-        $orderBy: Domain_orderBy
-        $orderDirection: OrderDirection
-        $first: Int
-        $expiryDate: Int
-        $orderByStringVar: String
+    query getNamesForAddress(
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+      $first: Int
+      $whereFilter: Domain_filter
+    ) {
+      domains(
+        orderBy: $orderBy
+        orderDirection: $orderDirection
+        first: $first
+        where: $whereFilter
       ) {
-        domains(
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-          first: $first
-          where: {
-            ${whereFilter}
-          }
-        ) {
-          ...DomainDetails
-          registration {
-            ...RegistrationDetails
-          }
-          wrappedDomain {
-            ...WrappedDomainDetails
-          }
+        ...DomainDetails
+        registration {
+          ...RegistrationDetails
+        }
+        wrappedDomain {
+          ...WrappedDomainDetails
         }
       }
-      ${domainDetailsFragment}
-      ${registrationDetailsFragment}
-      ${wrappedDomainDetailsFragment}
-    `
+    }
+    ${domainDetailsFragment}
+    ${registrationDetailsFragment}
+    ${wrappedDomainDetailsFragment}
+  `
 
   const result = await subgraphClient.request<
     SubgraphResult,
     {
-      address: string
       orderBy: string
       orderDirection: string
       first: number
-      expiryDate: number
-      orderByStringVar: string
+      whereFilter: DomainFilter
     }
   >(query, {
-    address: address.toLowerCase(),
     orderBy,
     orderDirection,
     first: pageSize,
-    expiryDate: Math.floor(Date.now() / 1000),
-    orderByStringVar,
+    whereFilter,
   })
 
   if (!result) return []

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),