@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/functions/subgraph/getSubnames.ts

@@ -0,0 +1,259 @@
+/* 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 { 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,
+  wrappedDomainDetailsFragment,
+  type SubgraphDomain,
+} from './fragments.js'
+import { makeNameObject, type Name } from './utils.js'
+
+type GetSubnamesOrderBy = 'expiryDate' | 'name' | 'labelName' | 'createdAt'
+
+export type GetSubnamesParameters = {
+  /** Name to get subnames for */
+  name: string
+  /** Search string filter for subname label */
+  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) */
+  orderDirection?: 'asc' | 'desc'
+  /** Previous page of subnames, used for pagination */
+  previousPage?: Name[]
+  /** Page size (default: 100) */
+  pageSize?: number
+}
+
+export type GetSubnamesReturnType = Name[]
+
+type SubgraphResult = {
+  domain?: {
+    subdomains: SubgraphDomain[]
+  }
+}
+
+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}
+ * @param parameters - {@link GetSubnamesParameters}
+ * @returns Subname array. {@link GetSubnamesReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getSubnames } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getSubnames(client, { name: 'ens.eth' })
+ */
+const getSubnames = async (
+  client: ClientWithEns,
+  {
+    name,
+    searchString,
+    allowExpired = false,
+    allowDeleted = false,
+    orderBy = 'name',
+    orderDirection = 'asc',
+    pageSize = 100,
+    previousPage,
+  }: GetSubnamesParameters,
+): Promise<GetSubnamesReturnType> => {
+  const subgraphClient = createSubgraphClient({ client })
+
+  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: `${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,
+    })
+  }
+
+  let whereFilter: DomainFilter = {}
+
+  if (whereFilters.length > 1) {
+    whereFilter = {
+      and: whereFilters,
+    }
+  } else if (whereFilters.length === 1) {
+    ;[whereFilter] = whereFilters
+  }
+
+  const query = gql`
+    query getSubnames(
+      $id: String!
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+      $whereFilter: Domain_filter
+      $first: Int
+    ) {
+      domain(id: $id) {
+        subdomains(
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+          first: $first
+          where: $whereFilter
+        ) {
+          ...DomainDetailsWithoutParent
+          registration {
+            ...RegistrationDetails
+          }
+          wrappedDomain {
+            ...WrappedDomainDetails
+          }
+        }
+      }
+    }
+    ${domainDetailsWithoutParentFragment}
+    ${registrationDetailsFragment}
+    ${wrappedDomainDetailsFragment}
+  `
+
+  const queryVars = {
+    id: namehash(name),
+    orderBy,
+    orderDirection,
+    first: pageSize,
+    whereFilter,
+  }
+
+  const result = await subgraphClient.request<SubgraphResult, typeof queryVars>(
+    query,
+    queryVars,
+  )
+
+  if (!result.domain) return []
+
+  const names = result.domain.subdomains.map((domain) =>
+    makeNameObject({ ...domain, parent: { name } }),
+  )
+
+  return names
+}
+
+export default getSubnames

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

@@ -0,0 +1,90 @@
+import { getAddress, type Address, type Hex } from 'viem'
+import type { DateWithValue } from '../../types.js'
+import { truncateFormat } from '../../utils/format.js'
+import { decodeFuses, type DecodedFuses } from '../../utils/fuses.js'
+import { decryptName } from '../../utils/labels.js'
+import type { SubgraphDomain } from './fragments.js'
+
+export type Name = {
+  /** Id of the name, equal to namehash */
+  id: Hex
+  /** Name string */
+  name: string | null
+  /** Truncated name, formatted for display use only */
+  truncatedName: string | null
+  /** Label name for name */
+  labelName: string | null
+  /** Label hash of label for name */
+  labelhash: Hex
+  /** Migration status from old ENS registry */
+  isMigrated: boolean
+  /** Parent name string, null if name is root */
+  parentName: string | null
+  /** Initial name creation time */
+  createdAt: DateWithValue<number>
+  /** Registration date of name */
+  registrationDate: DateWithValue<number> | null
+  /** Expiry date of name */
+  expiryDate: DateWithValue<number> | null
+  /** Fuse values for name */
+  fuses: DecodedFuses | null
+  /** Owner address */
+  owner: Address
+  /** Registrant address */
+  registrant: Address | null
+  /** Wrapped owner address */
+  wrappedOwner: Address | null
+  /** ETH record on name */
+  resolvedAddress: Address | null
+}
+
+export const getChecksumAddressOrNull = (
+  address: string | undefined,
+): Address | null => (address ? getAddress(address) : null)
+
+export const makeNameObject = (domain: SubgraphDomain): Name => {
+  const decrypted = domain.name ? decryptName(domain.name) : null
+  const createdAt = parseInt(domain.createdAt) * 1000
+  const registrationDate = domain.registration?.registrationDate
+    ? parseInt(domain.registration?.registrationDate) * 1000
+    : null
+  const fuses = domain.wrappedDomain?.fuses
+    ? decodeFuses(parseInt(domain.wrappedDomain.fuses))
+    : null
+  const expiryDateRef =
+    domain.registration?.expiryDate ||
+    (fuses?.parent.PARENT_CANNOT_CONTROL && domain.wrappedDomain?.expiryDate)
+  const expiryDate = expiryDateRef ? parseInt(expiryDateRef) * 1000 : null
+  return {
+    id: domain.id,
+    name: decrypted,
+    truncatedName: decrypted ? truncateFormat(decrypted) : null,
+    labelName: domain.labelName,
+    labelhash: domain.labelhash,
+    isMigrated: domain.isMigrated,
+    parentName: domain.parent?.name ?? null,
+    createdAt: {
+      date: new Date(createdAt),
+      value: createdAt,
+    },
+    registrationDate: registrationDate
+      ? {
+          date: new Date(registrationDate),
+          value: registrationDate,
+        }
+      : null,
+    expiryDate: expiryDate
+      ? {
+          date: new Date(expiryDate),
+          value: expiryDate,
+        }
+      : null,
+    fuses: domain.wrappedDomain?.fuses
+      ? decodeFuses(parseInt(domain.wrappedDomain.fuses))
+      : null,
+    owner: getAddress(domain.owner.id),
+    registrant: getChecksumAddressOrNull(domain.registrant?.id),
+    wrappedOwner: getChecksumAddressOrNull(domain.wrappedOwner?.id),
+    resolvedAddress: getChecksumAddressOrNull(domain.resolvedAddress?.id),
+  }
+}

package/src/functions/wallet/commitName.ts

@@ -0,0 +1,129 @@
+import {
+  encodeFunctionData,
+  type Account,
+  type Hash,
+  type SendTransactionParameters,
+  type Transport,
+} from 'viem'
+import type { ChainWithEns, WalletWithEns } from '../../contracts/consts.js'
+import { ethRegistrarControllerCommitSnippet } from '../../contracts/ethRegistrarController.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { UnsupportedNameTypeError } from '../../errors/general.js'
+import type {
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { getNameType } from '../../utils/getNameType.js'
+import {
+  makeCommitment,
+  type RegistrationParameters,
+} from '../../utils/registerHelpers.js'
+import { wrappedLabelLengthCheck } from '../../utils/wrapper.js'
+
+export type CommitNameDataParameters = RegistrationParameters
+
+export type CommitNameDataReturnType = SimpleTransactionRequest
+
+export type CommitNameParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  CommitNameDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type CommitNameReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  args: CommitNameDataParameters,
+): CommitNameDataReturnType => {
+  const labels = args.name.split('.')
+  const nameType = getNameType(args.name)
+  if (nameType !== 'eth-2ld')
+    throw new UnsupportedNameTypeError({
+      nameType,
+      supportedNameTypes: ['eth-2ld'],
+      details: 'Only 2ld-eth name registration is supported',
+    })
+  wrappedLabelLengthCheck(labels[0])
+  return {
+    to: getChainContractAddress({
+      client: wallet,
+      contract: 'ensEthRegistrarController',
+    }),
+    data: encodeFunctionData({
+      abi: ethRegistrarControllerCommitSnippet,
+      functionName: 'commit',
+      args: [makeCommitment(args)],
+    }),
+  }
+}
+
+/**
+ * Commits a name to be registered
+ * @param wallet - {@link WalletWithEns}
+ * @param parameters - {@link CommitNameParameters}
+ * @returns Transaction hash. {@link CommitNameReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, commitName, randomSecret } from '@ensdomains/ensjs'
+ *
+ * const wallet = createWalletClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: custom(window.ethereum),
+ * })
+ * const secret = randomSecret()
+ * const hash = await commitName(wallet, {
+ *   name: 'example.eth',
+ *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
+ *   duration: 31536000, // 1 year
+ *   secret,
+ * })
+ * // 0x...
+ */
+async function commitName<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    records,
+    reverseRecord,
+    fuses,
+    ...txArgs
+  }: CommitNameParameters<TChain, TAccount, TChainOverride>,
+): Promise<CommitNameReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    records,
+    reverseRecord,
+    fuses,
+  })
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return wallet.sendTransaction(writeArgs)
+}
+
+commitName.makeFunctionData = makeFunctionData
+
+export default commitName

package/src/functions/wallet/createSubname.ts

@@ -0,0 +1,207 @@
+import {
+  encodeFunctionData,
+  type Account,
+  type Address,
+  type Hash,
+  type SendTransactionParameters,
+  type Transport,
+} from 'viem'
+import type { ChainWithEns, WalletWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { nameWrapperSetSubnodeRecordSnippet } from '../../contracts/nameWrapper.js'
+import { registrySetSubnodeRecordSnippet } from '../../contracts/registry.js'
+import {
+  InvalidContractTypeError,
+  UnsupportedNameTypeError,
+} from '../../errors/general.js'
+import type {
+  AnyDate,
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { encodeFuses, type EncodeFusesInputObject } from '../../utils/fuses.js'
+import { getNameType } from '../../utils/getNameType.js'
+import { makeLabelNodeAndParent } from '../../utils/makeLabelNodeAndParent.js'
+import {
+  MAX_EXPIRY,
+  expiryToBigInt,
+  wrappedLabelLengthCheck,
+} from '../../utils/wrapper.js'
+
+type BaseCreateSubnameDataParameters = {
+  /** Subname to create */
+  name: string
+  /** New owner of subname */
+  owner: Address
+  /** Contract to create subname on */
+  contract: 'registry' | 'nameWrapper'
+  /** Resolver address to set */
+  resolverAddress?: Address
+  /** Expiry to set (only on NameWrapper) */
+  expiry?: AnyDate
+  /** Fuses to set (only on NameWrapper) */
+  fuses?: EncodeFusesInputObject
+}
+
+type RegistryCreateSubnameDataParameters = {
+  contract: 'registry'
+  expiry?: never
+  fuses?: never
+}
+
+type NameWrapperCreateSubnameDataParameters = {
+  contract: 'nameWrapper'
+  expiry?: AnyDate
+  fuses?: EncodeFusesInputObject
+}
+
+export type CreateSubnameDataParameters = BaseCreateSubnameDataParameters &
+  (RegistryCreateSubnameDataParameters | NameWrapperCreateSubnameDataParameters)
+
+export type CreateSubnameDataReturnType = SimpleTransactionRequest
+
+export type CreateSubnameParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  CreateSubnameDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type CreateSubnameReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    contract,
+    owner,
+    resolverAddress = getChainContractAddress({
+      client: wallet,
+      contract: 'ensPublicResolver',
+    }),
+    expiry,
+    fuses,
+  }: CreateSubnameDataParameters,
+): CreateSubnameDataReturnType => {
+  const nameType = getNameType(name)
+  if (nameType === 'tld' || nameType === 'root')
+    throw new UnsupportedNameTypeError({
+      nameType,
+      supportedNameTypes: [
+        'eth-2ld',
+        'eth-subname',
+        'other-2ld',
+        'other-subname',
+      ],
+    })
+
+  const { label, labelhash, parentNode } = makeLabelNodeAndParent(name)
+
+  switch (contract) {
+    case 'registry': {
+      return {
+        to: getChainContractAddress({
+          client: wallet,
+          contract: 'ensRegistry',
+        }),
+        data: encodeFunctionData({
+          abi: registrySetSubnodeRecordSnippet,
+          functionName: 'setSubnodeRecord',
+          args: [parentNode, labelhash, owner, resolverAddress, BigInt(0)],
+        }),
+      }
+    }
+    case 'nameWrapper': {
+      wrappedLabelLengthCheck(label)
+      const generatedFuses = fuses ? encodeFuses({ input: fuses }) : 0
+      const generatedExpiry = expiry ? expiryToBigInt(expiry) : MAX_EXPIRY
+      return {
+        to: getChainContractAddress({
+          client: wallet,
+          contract: 'ensNameWrapper',
+        }),
+        data: encodeFunctionData({
+          abi: nameWrapperSetSubnodeRecordSnippet,
+          functionName: 'setSubnodeRecord',
+          args: [
+            parentNode,
+            label,
+            owner,
+            resolverAddress,
+            BigInt(0),
+            generatedFuses,
+            generatedExpiry,
+          ],
+        }),
+      }
+    }
+    default:
+      throw new InvalidContractTypeError({
+        contractType: contract,
+        supportedContractTypes: ['registry', 'nameWrapper'],
+      })
+  }
+}
+
+/**
+ * Creates a subname
+ * @param wallet - {@link WalletWithEns}
+ * @param parameters - {@link CreateSubnameParameters}
+ * @returns Transaction hash. {@link CreateSubnameReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, createSubname } from '@ensdomains/ensjs'
+ *
+ * const wallet = createWalletClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await createSubname(wallet, {
+ *   name: 'sub.ens.eth',
+ *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
+ *   contract: 'registry',
+ * })
+ * // 0x...
+ */
+async function createSubname<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    contract,
+    owner,
+    resolverAddress,
+    expiry,
+    fuses,
+    ...txArgs
+  }: CreateSubnameParameters<TChain, TAccount, TChainOverride>,
+): Promise<CreateSubnameReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    contract,
+    owner,
+    resolverAddress,
+    expiry,
+    fuses,
+  } as CreateSubnameDataParameters)
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return wallet.sendTransaction(writeArgs)
+}
+
+createSubname.makeFunctionData = makeFunctionData
+
+export default createSubname