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

package/src/functions/subgraph/getSubnames.ts

@@ -1,9 +1,11 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { gql } from 'graphql-request'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import { InvalidOrderByError } from '../../errors/subgraph.js'
-import { GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
+import { EMPTY_ADDRESS, GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
 import { namehash } from '../../utils/normalise.js'
 import { createSubgraphClient } from './client.js'
+import type { DomainFilter } from './filters.js'
 import {
   domainDetailsWithoutParentFragment,
   registrationDetailsFragment,
@@ -21,6 +23,8 @@ export type GetSubnamesParameters = {
   searchString?: string
   /** Allows expired names to be included (default: false) */
   allowExpired?: boolean
+  /** Allows deleted names to be included (default: false) */
+  allowDeleted?: boolean
   /** Parameter to order names by (default: name) */
   orderBy?: GetSubnamesOrderBy
   /** Direction to order names in (default: asc) */
@@ -39,6 +43,71 @@ type SubgraphResult = {
   }
 }
 
+const getOrderByFilter = ({
+  name,
+  orderBy,
+  orderDirection,
+  previousPage,
+}: Required<
+  Pick<
+    GetSubnamesParameters,
+    'name' | '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 (name === 'eth' && lastExpiryDate) {
+        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 subnames for a name from the subgraph.
  * @param client - {@link ClientWithEns}
@@ -62,6 +131,7 @@ const getSubnames = async (
     name,
     searchString,
     allowExpired = false,
+    allowDeleted = false,
     orderBy = 'name',
     orderDirection = 'asc',
     pageSize = 100,
@@ -70,119 +140,68 @@ const getSubnames = async (
 ): Promise<GetSubnamesReturnType> => {
   const subgraphClient = createSubgraphClient({ client })
 
-  const whereFilters: string[] = []
-
-  let orderByFilter = ''
-  let orderByStringVar = ''
-
-  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 (name === 'eth' && lastExpiryDate) {
-          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)
+  const whereFilters: DomainFilter[] = []
+
+  if (previousPage?.length) {
+    whereFilters.push(
+      getOrderByFilter({
+        name,
+        orderBy,
+        orderDirection,
+        previousPage,
+      }),
+    )
   }
 
   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 },
+      ],
+    })
+  }
+
+  if (!allowDeleted) {
+    // exclude "deleted" domains
+    // when owner/resolver/registrant = null
+    whereFilters.push({
+      or: [
+        {
+          owner_not: EMPTY_ADDRESS,
+        },
+        {
+          resolver_not: null,
+        },
+        ...(name.toLowerCase() === 'eth'
+          ? [
+              {
+                registrant_not: EMPTY_ADDRESS,
+              },
+            ]
+          : []),
+      ],
+    })
   }
 
   if (searchString) {
     // using labelName_contains instead of name_contains because name_contains
     // includes the parent name
-    whereFilters.push(`
-      {
-        labelName_contains: $searchString
-      }
-    `)
+    whereFilters.push({
+      labelName_contains: searchString,
+    })
   }
 
-  let whereFilter = ''
+  let whereFilter: DomainFilter = {}
 
   if (whereFilters.length > 1) {
-    whereFilter = `
-      and: [
-        ${whereFilters.join('\n')}
-      ]
-    `
+    whereFilter = {
+      and: whereFilters,
+    }
   } else if (whereFilters.length === 1) {
-    whereFilter = whereFilters[0].replace(/{(.*)}/gs, '$1')
+    ;[whereFilter] = whereFilters
   }
 
   const query = gql`
@@ -190,24 +209,15 @@ const getSubnames = async (
       $id: String!
       $orderBy: Domain_orderBy
       $orderDirection: OrderDirection
+      $whereFilter: Domain_filter
       $first: Int
-      $expiryDate: Int
-      $searchString: String
-      $orderByStringVar: String
     ) {
       domain(id: $id) {
         subdomains(
           orderBy: $orderBy
           orderDirection: $orderDirection
           first: $first
-          ${
-            whereFilter &&
-            `
-          where: {
-            ${whereFilter}
-          }
-          `
-          }
+          where: $whereFilter
         ) {
           ...DomainDetailsWithoutParent
           registration {
@@ -229,9 +239,7 @@ const getSubnames = async (
     orderBy,
     orderDirection,
     first: pageSize,
-    expiryDate: Math.floor(Date.now() / 1000),
-    searchString,
-    orderByStringVar,
+    whereFilter,
   }
 
   const result = await subgraphClient.request<SubgraphResult, typeof queryVars>(

package/src/functions/subgraph/types.ts

@@ -0,0 +1,13 @@
+import type { Hex } from 'viem'
+
+export type InputMaybe<T> = T | null
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  Bytes: Hex
+  BigInt: string
+}

package/src/functions/subgraph/utils.ts

@@ -1,7 +1,7 @@
 import { getAddress, type Address, type Hex } from 'viem'
 import type { DateWithValue } from '../../types.js'
 import { truncateFormat } from '../../utils/format.js'
-import { decodeFuses, type AllCurrentFuses } from '../../utils/fuses.js'
+import { decodeFuses, type DecodedFuses } from '../../utils/fuses.js'
 import { decryptName } from '../../utils/labels.js'
 import type { SubgraphDomain } from './fragments.js'
 
@@ -27,7 +27,7 @@ export type Name = {
   /** Expiry date of name */
   expiryDate: DateWithValue<number> | null
   /** Fuse values for name */
-  fuses: AllCurrentFuses | null
+  fuses: DecodedFuses | null
   /** Owner address */
   owner: Address
   /** Registrant address */

package/src/functions/wallet/createSubname.ts

@@ -20,7 +20,7 @@ import type {
   SimpleTransactionRequest,
   WriteTransactionParameters,
 } from '../../types.js'
-import { encodeFuses, type CombinedFuseInput } from '../../utils/fuses.js'
+import { encodeFuses, type EncodeFusesInputObject } from '../../utils/fuses.js'
 import { getNameType } from '../../utils/getNameType.js'
 import { makeLabelNodeAndParent } from '../../utils/makeLabelNodeAndParent.js'
 import {
@@ -41,7 +41,7 @@ type BaseCreateSubnameDataParameters = {
   /** Expiry to set (only on NameWrapper) */
   expiry?: AnyDate
   /** Fuses to set (only on NameWrapper) */
-  fuses?: CombinedFuseInput
+  fuses?: EncodeFusesInputObject
 }
 
 type RegistryCreateSubnameDataParameters = {
@@ -53,7 +53,7 @@ type RegistryCreateSubnameDataParameters = {
 type NameWrapperCreateSubnameDataParameters = {
   contract: 'nameWrapper'
   expiry?: AnyDate
-  fuses?: CombinedFuseInput
+  fuses?: EncodeFusesInputObject
 }
 
 export type CreateSubnameDataParameters = BaseCreateSubnameDataParameters &
@@ -119,7 +119,7 @@ export const makeFunctionData = <
     }
     case 'nameWrapper': {
       wrappedLabelLengthCheck(label)
-      const generatedFuses = fuses ? encodeFuses(fuses) : 0
+      const generatedFuses = fuses ? encodeFuses({ input: fuses }) : 0
       const generatedExpiry = expiry ? expiryToBigInt(expiry) : MAX_EXPIRY
       return {
         to: getChainContractAddress({

package/src/functions/wallet/setChildFuses.ts

@@ -14,14 +14,14 @@ import type {
   SimpleTransactionRequest,
   WriteTransactionParameters,
 } from '../../types.js'
-import { encodeFuses, type CombinedFuseInput } from '../../utils/fuses.js'
+import { encodeFuses, type EncodeFusesInputObject } from '../../utils/fuses.js'
 import { namehash } from '../../utils/normalise.js'
 
 export type SetChildFusesDataParameters = {
   /** Name to set child fuses for */
   name: string
   /** Fuse object or number value to set to */
-  fuses: Partial<CombinedFuseInput> | number
+  fuses: EncodeFusesInputObject
   /** Expiry to set for fuses */
   expiry?: number | bigint
 }
@@ -46,7 +46,7 @@ export const makeFunctionData = <
   wallet: WalletWithEns<Transport, TChain, TAccount>,
   { name, fuses, expiry }: SetChildFusesDataParameters,
 ): SetChildFusesDataReturnType => {
-  const encodedFuses = encodeFuses(fuses)
+  const encodedFuses = encodeFuses({ input: fuses })
   const labels = name.split('.')
   const labelHash = labelhash(labels.shift()!)
   const parentNode = namehash(labels.join('.'))

package/src/functions/wallet/setFuses.ts

@@ -13,14 +13,17 @@ import type {
   SimpleTransactionRequest,
   WriteTransactionParameters,
 } from '../../types.js'
-import { encodeFuses, type CombinedFuseInput } from '../../utils/fuses.js'
+import {
+  encodeFuses,
+  type EncodeChildFusesInputObject,
+} from '../../utils/fuses.js'
 import { namehash } from '../../utils/normalise.js'
 
 export type SetFusesDataParameters = {
   /** Name to set fuses for */
   name: string
   /** Fuse object to set to */
-  fuses: Prettify<CombinedFuseInput['child']>
+  fuses: EncodeChildFusesInputObject
 }
 
 export type SetFusesDataReturnType = SimpleTransactionRequest
@@ -43,7 +46,7 @@ export const makeFunctionData = <
   wallet: WalletWithEns<Transport, TChain, TAccount>,
   { name, fuses }: SetFusesDataParameters,
 ): SetFusesDataReturnType => {
-  const encodedFuses = encodeFuses(fuses, 'child')
+  const encodedFuses = encodeFuses({ restriction: 'child', input: fuses })
   return {
     to: getChainContractAddress({ client: wallet, contract: 'ensNameWrapper' }),
     data: encodeFunctionData({

package/src/functions/wallet/wrapName.ts

@@ -22,7 +22,10 @@ import type {
   SimpleTransactionRequest,
   WriteTransactionParameters,
 } from '../../types.js'
-import { encodeFuses, type CombinedFuseInput } from '../../utils/fuses.js'
+import {
+  encodeFuses,
+  type EncodeChildFusesInputObject,
+} from '../../utils/fuses.js'
 import { packetToBytes } from '../../utils/hexEncodedName.js'
 import { checkIsDotEth } from '../../utils/validation.js'
 import { wrappedLabelLengthCheck } from '../../utils/wrapper.js'
@@ -37,7 +40,7 @@ export type WrapNameDataParameters<
   newOwnerAddress: Address
   /** Fuses to set on wrap (eth-2ld only) */
   fuses?: TNameOption extends Eth2ldNameSpecifier
-    ? CombinedFuseInput['child']
+    ? EncodeChildFusesInputObject
     : never
   /** The resolver address to set on wrap */
   resolverAddress?: Address
@@ -83,7 +86,9 @@ export const makeFunctionData = <
 
   if (isEth2ld) {
     wrappedLabelLengthCheck(labels[0])
-    const encodedFuses = fuses ? encodeFuses(fuses, 'child') : 0
+    const encodedFuses = fuses
+      ? encodeFuses({ restriction: 'child', input: fuses })
+      : 0
     const tokenId = BigInt(labelhash(labels[0]))
 
     const data = encodeAbiParameters(

package/src/index.ts

@@ -59,7 +59,6 @@ export {
   FusesInvalidFuseObjectError,
   FusesInvalidNamedFuseError,
   FusesInvalidUnnamedFuseError,
-  FusesNonIntegerError,
   FusesOutOfRangeError,
   FusesRestrictionNotAllowedError,
   FusesValueRequiredError,

package/src/utils/contentHash.ts

@@ -1,5 +1,11 @@
-import contentHash from '@ensdomains/content-hash'
+import {
+  decode,
+  encode,
+  getCodec,
+  type Codec as InternalCodec,
+} from '@ensdomains/content-hash'
 import { isHex, type Hex } from 'viem'
+import { InvalidContentHashError } from '../errors/utils.js'
 
 export type ProtocolType =
   | 'ipfs'
@@ -16,16 +22,6 @@ export type DecodedContentHash = {
   decoded: string
 }
 
-const supportedCodecs = [
-  'ipns-ns',
-  'ipfs-ns',
-  'swarm-ns',
-  'onion',
-  'onion3',
-  'skynet-ns',
-  'arweave-ns',
-]
-
 function matchProtocol(text: string) {
   return (
     text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave|ar):\/\/(.*)/) ||
@@ -34,117 +30,67 @@ function matchProtocol(text: string) {
   )
 }
 
-export function decodeContenthash(encoded: Hex): DecodedContentHash | null {
+const getDisplayCodec = (encoded: string): ProtocolType => {
+  const codec = getCodec(encoded)
+  switch (codec) {
+    case 'ipfs':
+    case 'ipns':
+    case 'onion':
+    case 'onion3':
+      return codec
+    case 'swarm':
+      return 'bzz'
+    case 'skynet':
+      return 'sia'
+    case 'arweave':
+      return 'ar'
+    default:
+      return null
+  }
+}
+
+const getInternalCodec = (
+  displayCodec: NonNullable<ProtocolType>,
+): InternalCodec => {
+  switch (displayCodec) {
+    case 'bzz':
+      return 'swarm'
+    case 'sia':
+      return 'skynet'
+    case 'ar':
+      return 'arweave'
+    default:
+      return displayCodec
+  }
+}
+
+export function decodeContentHash(encoded: Hex): DecodedContentHash | null {
   if (!encoded || encoded === '0x') {
     return null
   }
-  let decoded = contentHash.decode(encoded)
-  let protocolType: ProtocolType = null
-  const codec = contentHash.getCodec(encoded)
-  if (codec === 'ipfs-ns') {
-    protocolType = 'ipfs'
-  } else if (codec === 'ipns-ns') {
-    protocolType = 'ipns'
-  } else if (codec === 'swarm-ns') {
-    protocolType = 'bzz'
-  } else if (codec === 'onion') {
-    protocolType = 'onion'
-  } else if (codec === 'onion3') {
-    protocolType = 'onion3'
-  } else if (codec === 'skynet-ns') {
-    protocolType = 'sia'
-  } else if (codec === 'arweave-ns') {
-    protocolType = 'ar'
-  } else {
-    decoded = encoded
-  }
+  const decoded = decode(encoded)
+  const protocolType = getDisplayCodec(encoded)
   return { protocolType, decoded }
 }
 
-export function validateContent(encoded: any) {
-  return (
-    contentHash.isHashOfType(encoded, contentHash.Types.ipfs) ||
-    contentHash.isHashOfType(encoded, contentHash.Types.swarm)
-  )
+export function isValidContentHash(encoded: unknown) {
+  if (typeof encoded !== 'string') return false
+  const codec = getCodec(encoded)
+  return Boolean(codec && isHex(encoded))
 }
 
-export function isValidContenthash(encoded: any) {
-  try {
-    const codec = contentHash.getCodec(encoded)
-    return isHex(encoded) && supportedCodecs.includes(codec)
-  } catch (e) {
-    console.log(e)
-  }
-  return false
+export function getProtocolType(encoded: string) {
+  const matched = matchProtocol(encoded)
+  if (!matched) return null
+  const [, protocolType, decoded] = matched
+  return { protocolType: protocolType as NonNullable<ProtocolType>, decoded }
 }
 
-export function getProtocolType(encoded: any) {
-  let protocolType
-  let decoded
-  try {
-    const matched = matchProtocol(encoded)
-    if (matched) {
-      ;[, protocolType, decoded] = matched
-    }
-    return {
-      protocolType,
-      decoded,
-    }
-  } catch (e) {
-    console.log(e)
-  }
-  return
-}
+export function encodeContentHash(text: string): Hex {
+  const typeData = getProtocolType(text)
+  if (!typeData) throw new InvalidContentHashError()
 
-export function encodeContenthash(text: string) {
-  let content = text
-  let contentType
-  let encoded: string | boolean = false
-  let error
-  if (text) {
-    const matched = matchProtocol(text)
-    if (matched) {
-      ;[, contentType, content] = matched
-    }
-    try {
-      if (contentType === 'ipfs') {
-        if (content.length >= 4) {
-          encoded = `0x${contentHash.encode('ipfs-ns', content)}`
-        }
-      } else if (contentType === 'ipns') {
-        encoded = `0x${contentHash.encode('ipns-ns', content)}`
-      } else if (contentType === 'bzz') {
-        if (content.length >= 4) {
-          encoded = `0x${contentHash.fromSwarm(content)}`
-        }
-      } else if (contentType === 'onion') {
-        if (content.length === 16) {
-          encoded = `0x${contentHash.encode('onion', content)}`
-        }
-      } else if (contentType === 'onion3') {
-        if (content.length === 56) {
-          encoded = `0x${contentHash.encode('onion3', content)}`
-        }
-      } else if (contentType === 'sia') {
-        if (content.length === 46) {
-          encoded = `0x${contentHash.encode('skynet-ns', content)}`
-        }
-      } else if (contentType === 'arweave' || contentType === 'ar') {
-        if (content.length === 43) {
-          encoded = `0x${contentHash.encode('arweave-ns', content)}`
-        }
-      } else {
-        console.warn('Unsupported protocol or invalid value', {
-          contentType,
-          text,
-        })
-      }
-    } catch (err) {
-      const errorMessage = 'Error encoding content hash'
-      console.warn(errorMessage, { text, encoded })
-      error = errorMessage
-      // throw 'Error encoding content hash'
-    }
-  }
-  return { encoded, error }
+  const internalCodec = getInternalCodec(typeData.protocolType)
+
+  return `0x${encode(internalCodec, typeData.decoded)}`
 }

package/src/utils/encoders/encodeSetContentHash.ts

@@ -1,6 +1,6 @@
 import { encodeFunctionData, type Hex } from 'viem'
 import { publicResolverSetContenthashSnippet } from '../../contracts/publicResolver.js'
-import { encodeContenthash } from '../contentHash.js'
+import { encodeContentHash } from '../contentHash.js'
 
 export type EncodeSetContentHashParameters = {
   namehash: Hex
@@ -15,9 +15,7 @@ export const encodeSetContentHash = ({
 }: EncodeSetContentHashParameters): EncodeSetContentHashReturnType => {
   let encodedHash: Hex = '0x'
   if (contentHash) {
-    const encodedObject = encodeContenthash(contentHash)
-    if (encodedObject.error) throw new Error(encodedObject.error)
-    encodedHash = encodedObject.encoded as Hex
+    encodedHash = encodeContentHash(contentHash)
   }
   return encodeFunctionData({
     abi: publicResolverSetContenthashSnippet,