@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/functions/subgraph/getSubnames.ts

@@ -1,236 +0,0 @@
-/* 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 } from '../../utils/consts.js'
-import { namehash } from '../../utils/normalise.js'
-import { createSubgraphClient } from './client.js'
-import {
-  type DomainFilter,
-  getCreatedAtOrderFilter,
-  getExpiryDateOrderFilter,
-} from './filters.js'
-import {
-  type SubgraphDomain,
-  domainDetailsWithoutParentFragment,
-  registrationDetailsFragment,
-  wrappedDomainDetailsFragment,
-} from './fragments.js'
-import { type Name, makeNameObject } 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 = ({
-  orderBy,
-  orderDirection,
-  previousPage,
-}: Required<
-  Pick<GetSubnamesParameters, 'orderBy' | 'orderDirection' | 'previousPage'>
->): DomainFilter => {
-  const lastDomain = previousPage[previousPage.length - 1]
-  const operator = orderDirection === 'asc' ? 'gt' : 'lt'
-
-  switch (orderBy) {
-    case 'expiryDate': {
-      return getExpiryDateOrderFilter({
-        lastDomain,
-        orderDirection,
-      })
-    }
-    case 'name': {
-      return {
-        [`name_${operator}`]: lastDomain.name ?? '',
-      }
-    }
-    case 'labelName': {
-      return {
-        [`labelName_${operator}`]: lastDomain.labelName ?? '',
-      }
-    }
-    case 'createdAt': {
-      return getCreatedAtOrderFilter({ lastDomain, orderDirection })
-    }
-    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 } from '@ensdomains/ensjs'
- * import { getSubnames } from '@ensdomains/ensjs/subgraph'
- *
- * 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({
-        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/utils.ts

@@ -1,92 +0,0 @@
-import { type Address, type Hex, getAddress } from 'viem'
-import type { DateWithValue } from '../../types.js'
-import { truncateFormat } from '../../utils/format.js'
-import { type DecodedFuses, decodeFuses } 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 = Number.parseInt(domain.createdAt) * 1000
-  const registrationDate = domain.registration?.registrationDate
-    ? Number.parseInt(domain.registration?.registrationDate) * 1000
-    : null
-  const fuses = domain.wrappedDomain?.fuses
-    ? decodeFuses(Number.parseInt(domain.wrappedDomain.fuses))
-    : null
-  const expiryDateRef =
-    domain.registration?.expiryDate ||
-    (fuses?.parent.PARENT_CANNOT_CONTROL && domain.wrappedDomain?.expiryDate)
-  const expiryDate = expiryDateRef
-    ? Number.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(Number.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/clearRecords.ts

@@ -1,98 +0,0 @@
-import type {
-  Account,
-  Address,
-  Hash,
-  SendTransactionParameters,
-  Transport,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
-import type {
-  Prettify,
-  SimpleTransactionRequest,
-  WriteTransactionParameters,
-} from '../../types.js'
-import { encodeClearRecords } from '../../utils/encoders/encodeClearRecords.js'
-import { namehash } from '../../utils/normalise.js'
-
-export type ClearRecordsDataParameters = {
-  /** The name to clear records for */
-  name: string
-  /** The resolver address to use */
-  resolverAddress: Address
-}
-
-export type ClearRecordsDataReturnType = SimpleTransactionRequest
-
-export type ClearRecordsParameters<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined,
-> = Prettify<
-  ClearRecordsDataParameters &
-    WriteTransactionParameters<TChain, TAccount, TChainOverride>
->
-
-export type ClearRecordsReturnType = Hash
-
-export const makeFunctionData = <
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
->(
-  _wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  { name, resolverAddress }: ClearRecordsDataParameters,
-): ClearRecordsDataReturnType => {
-  return {
-    to: resolverAddress,
-    data: encodeClearRecords(namehash(name)),
-  }
-}
-
-/**
- * Clears the records for a name on a resolver.
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link ClearRecordsParameters}
- * @returns Transaction hash. {@link ClearRecordsReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { clearRecords } from '@ensdomains/ensjs/wallet'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const hash = await clearRecords(wallet, {
- *   name: 'ens.eth',
- *   resolverAddress: '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
- * })
- * // 0x...
- */
-async function clearRecords<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    resolverAddress,
-    ...txArgs
-  }: ClearRecordsParameters<TChain, TAccount, TChainOverride>,
-): Promise<ClearRecordsReturnType> {
-  const data = makeFunctionData(wallet, {
-    name,
-    resolverAddress,
-  })
-  const writeArgs = {
-    ...data,
-    ...txArgs,
-  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
-  return sendTransaction(wallet, writeArgs)
-}
-
-clearRecords.makeFunctionData = makeFunctionData
-
-export default clearRecords

package/src/functions/wallet/commitName.ts

@@ -1,132 +0,0 @@
-import {
-  type Account,
-  type Hash,
-  type SendTransactionParameters,
-  type Transport,
-  encodeFunctionData,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import type { ChainWithEns, ClientWithAccount } 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 {
-  type RegistrationParameters,
-  makeCommitment,
-} 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: ClientWithAccount<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 ClientWithAccount}
- * @param parameters - {@link CommitNameParameters}
- * @returns Transaction hash. {@link CommitNameReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { commitName } from '@ensdomains/ensjs/wallet'
- * import { randomSecret } from '@ensdomains/ensjs/utils'
- *
- * 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: ClientWithAccount<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 sendTransaction(wallet, writeArgs)
-}
-
-commitName.makeFunctionData = makeFunctionData
-
-export default commitName