@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/functions/public/getExpiry.ts

@@ -1,200 +0,0 @@
-import {
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  labelhash,
-} from 'viem'
-import {
-  baseRegistrarGracePeriodSnippet,
-  baseRegistrarNameExpiresSnippet,
-} from '../../contracts/baseRegistrar.js'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { multicallGetCurrentBlockTimestampSnippet } from '../../contracts/multicall.js'
-import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
-import type {
-  DateWithValue,
-  Prettify,
-  SimpleTransactionRequest,
-} from '../../types.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import { makeSafeSecondsDate } from '../../utils/makeSafeSecondsDate.js'
-import { namehash } from '../../utils/normalise.js'
-import { checkIsDotEth } from '../../utils/validation.js'
-import multicallWrapper from './multicallWrapper.js'
-
-type ContractOption = 'registrar' | 'nameWrapper'
-type ExpiryStatus = 'active' | 'expired' | 'gracePeriod'
-
-export type GetExpiryParameters = Prettify<{
-  /** Name to get expiry for */
-  name: string
-  /** Optional specific contract to use to get expiry */
-  contract?: ContractOption
-}>
-
-export type GetExpiryReturnType = Prettify<{
-  /** Expiry value */
-  expiry: DateWithValue<bigint>
-  /** Grace period value (in seconds) */
-  gracePeriod: number
-  /** Status of name */
-  status: ExpiryStatus
-} | null>
-
-const getContractToUse = (
-  contract: ContractOption | undefined,
-  labels: string[],
-) => {
-  if (contract) return contract
-  if (checkIsDotEth(labels)) {
-    return 'registrar'
-  }
-  return 'nameWrapper'
-}
-
-const encode = (
-  client: ClientWithEns,
-  { name, contract }: GetExpiryParameters,
-): SimpleTransactionRequest => {
-  const labels = name.split('.')
-
-  const contractToUse = getContractToUse(contract, labels)
-
-  const calls: SimpleTransactionRequest[] = [
-    {
-      to: getChainContractAddress({ client, contract: 'multicall3' }),
-      data: encodeFunctionData({
-        abi: multicallGetCurrentBlockTimestampSnippet,
-        functionName: 'getCurrentBlockTimestamp',
-      }),
-    },
-  ]
-
-  if (contractToUse === 'nameWrapper') {
-    calls.push({
-      to: getChainContractAddress({ client, contract: 'ensNameWrapper' }),
-      data: encodeFunctionData({
-        abi: nameWrapperGetDataSnippet,
-        functionName: 'getData',
-        args: [BigInt(namehash(labels.join('.')))],
-      }),
-    })
-  } else {
-    const baseRegistrarImplementationAddress = getChainContractAddress({
-      client,
-      contract: 'ensBaseRegistrarImplementation',
-    })
-    calls.push({
-      to: baseRegistrarImplementationAddress,
-      data: encodeFunctionData({
-        abi: baseRegistrarNameExpiresSnippet,
-        functionName: 'nameExpires',
-        args: [BigInt(labelhash(labels[0]))],
-      }),
-    })
-    calls.push({
-      to: baseRegistrarImplementationAddress,
-      data: encodeFunctionData({
-        abi: baseRegistrarGracePeriodSnippet,
-        functionName: 'GRACE_PERIOD',
-      }),
-    })
-  }
-
-  return multicallWrapper.encode(client, { transactions: calls })
-}
-
-const decode = async (
-  client: ClientWithEns,
-  data: Hex | BaseError,
-  { name, contract }: GetExpiryParameters,
-): Promise<GetExpiryReturnType> => {
-  if (typeof data === 'object') throw data
-  const labels = name.split('.')
-  const result = await multicallWrapper.decode(client, data, [])
-
-  const blockTimestamp = decodeFunctionResult({
-    abi: multicallGetCurrentBlockTimestampSnippet,
-    functionName: 'getCurrentBlockTimestamp',
-    data: result[0].returnData,
-  })
-
-  const contractToUse = getContractToUse(contract, labels)
-
-  let expiry: bigint
-  let gracePeriod = 0n
-
-  if (contractToUse === 'nameWrapper') {
-    ;[, , expiry] = decodeFunctionResult({
-      abi: nameWrapperGetDataSnippet,
-      functionName: 'getData',
-      data: result[1].returnData,
-    })
-  } else {
-    expiry = decodeFunctionResult({
-      abi: baseRegistrarNameExpiresSnippet,
-      functionName: 'nameExpires',
-      data: result[1].returnData,
-    })
-    gracePeriod = decodeFunctionResult({
-      abi: baseRegistrarGracePeriodSnippet,
-      functionName: 'GRACE_PERIOD',
-      data: result[2].returnData,
-    })
-  }
-
-  if (expiry === 0n) {
-    return null
-  }
-
-  let status: ExpiryStatus = 'active'
-
-  if (blockTimestamp > expiry + gracePeriod) {
-    status = 'expired'
-  } else if (blockTimestamp > expiry) {
-    status = 'gracePeriod'
-  }
-
-  return {
-    expiry: {
-      date: makeSafeSecondsDate(expiry),
-      value: expiry,
-    },
-    gracePeriod: Number(gracePeriod),
-    status,
-  }
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets the expiry for a name
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetExpiryParameters}
- * @returns Expiry object, or `null` if no expiry. {@link GetExpiryReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getExpiry } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getExpiry(client, { name: 'ens.eth' })
- * // { expiry: { date: Date, value: 1913933217n }, gracePeriod: 7776000, status: 'active' }
- */
-const getExpiry = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name, contract }: GetExpiryParameters,
-) => Promise<GetExpiryReturnType>) &
-  BatchableFunctionObject
-
-export default getExpiry

package/src/functions/public/getName.ts

@@ -1,197 +0,0 @@
-import { evmChainIdToCoinType } from '@ensdomains/address-encoder/utils'
-import {
-  type Address,
-  type BaseError,
-  type Hex,
-  decodeErrorResult,
-  decodeFunctionResult,
-  encodeFunctionData,
-  zeroAddress,
-} from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import {
-  universalResolverReverseSnippet,
-  universalResolverReverseWithGatewaysSnippet,
-} from '../../contracts/universalResolver.js'
-import type {
-  GenericPassthrough,
-  TransactionRequestWithPassthrough,
-} from '../../types.js'
-import { checkSafeUniversalResolverData } from '../../utils/checkSafeUniversalResolverData.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import { getRevertErrorData } from '../../utils/getRevertErrorData.js'
-import { normalise } from '../../utils/normalise.js'
-
-type GetNameCoinTypeParameters = {
-  coinType: number
-  chainId?: never
-}
-
-type GetNameChainIdParameters = {
-  chainId: number
-  coinType?: never
-}
-
-export type GetNameParameters = {
-  /** Address to get name for */
-  address: Address
-  /** Coin type to use for reverse resolution */
-  coinType?: GetNameCoinTypeParameters['coinType']
-  /** Chain ID to use for reverse resolution */
-  chainId?: GetNameChainIdParameters['chainId']
-  /** Whether or not to allow mismatched forward resolution */
-  allowMismatch?: boolean
-  /** Whether or not to throw decoding errors */
-  strict?: boolean
-  /** Batch gateway URLs to use for resolving CCIP-read requests. */
-  gatewayUrls?: string[]
-} & (GetNameCoinTypeParameters | GetNameChainIdParameters | {})
-
-export type GetNameReturnType = {
-  /** Primary name for address */
-  name: string
-  /** Indicates if forward resolution for name matches address */
-  match: boolean
-  /** Resolver address for reverse node */
-  reverseResolverAddress: Address
-  /** Resolver address for resolved name */
-  resolverAddress: Address
-}
-
-const encode = (
-  client: ClientWithEns,
-  {
-    address,
-    coinType,
-    chainId,
-    gatewayUrls,
-  }: Omit<GetNameParameters, 'allowMismatch' | 'strict'>,
-): TransactionRequestWithPassthrough => {
-  const to = getChainContractAddress({
-    client,
-    contract: 'ensUniversalResolver',
-  })
-  const args = [
-    address,
-    chainId ? evmChainIdToCoinType(chainId) : coinType || 60n,
-  ] as const
-
-  return {
-    to,
-    ...(gatewayUrls?.length
-      ? {
-          data: encodeFunctionData({
-            abi: universalResolverReverseWithGatewaysSnippet,
-            functionName: 'reverseWithGateways',
-            args: [...args, gatewayUrls] as const,
-          }),
-          passthrough: {
-            args: [...args, gatewayUrls],
-            address: to,
-          },
-        }
-      : {
-          data: encodeFunctionData({
-            abi: universalResolverReverseSnippet,
-            functionName: 'reverse',
-            args,
-          }),
-          passthrough: {
-            args,
-            address: to,
-          },
-        }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-  { allowMismatch, strict, gatewayUrls }: GetNameParameters,
-): Promise<GetNameReturnType | null> => {
-  const isSafe = checkSafeUniversalResolverData(data, {
-    strict,
-    abi: gatewayUrls
-      ? universalResolverReverseWithGatewaysSnippet
-      : universalResolverReverseSnippet,
-    args: passthrough.args,
-    functionName: 'reverse',
-    address: passthrough.address,
-  })
-  if (!isSafe) {
-    if (!allowMismatch) return null
-    const errorData = getRevertErrorData(data)
-    if (!errorData) return null
-    try {
-      const decodedError = decodeErrorResult({
-        abi: universalResolverReverseSnippet,
-        data: errorData,
-      })
-      if (decodedError.errorName !== 'ReverseAddressMismatch') return null
-      return {
-        name: decodedError.args[0],
-        match: false,
-        reverseResolverAddress: zeroAddress,
-        resolverAddress: zeroAddress,
-      }
-    } catch {
-      return null
-    }
-  }
-
-  try {
-    const [unnormalisedName, resolverAddress, reverseResolverAddress] =
-      decodeFunctionResult({
-        abi: universalResolverReverseSnippet,
-        functionName: 'reverse',
-        data,
-      })
-
-    if (!unnormalisedName) return null
-
-    const normalisedName = normalise(unnormalisedName)
-    return {
-      name: normalisedName,
-      match: true,
-      reverseResolverAddress,
-      resolverAddress,
-    }
-  } catch (error) {
-    if (strict) throw error
-    return null
-  }
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets the primary name for an address
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetNameParameters}
- * @returns Name data object, or `null` if no primary name is set. {@link GetNameReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getName } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getName(client, { address: '0xb8c2C29ee19D8307cb7255e1Cd9CbDE883A267d5' })
- * // { name: 'nick.eth', match: true, reverseResolverAddress: '0xa2c122be93b0074270ebee7f6b7292c7deb45047', resolverAddress: '0x4976fb03c32e5b8cfe2b6ccb31c09ba78ebaba41' }
- */
-const getName = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { address, allowMismatch, strict }: GetNameParameters,
-) => Promise<GetNameReturnType>) &
-  BatchableFunctionObject
-
-export default getName

package/src/functions/public/getOwner.ts

@@ -1,277 +0,0 @@
-import {
-  type Address,
-  type BaseError,
-  type Hex,
-  decodeAbiParameters,
-} from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import type { SimpleTransactionRequest } from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { generateFunction } from '../../utils/generateFunction.js'
-import { namehash as makeNamehash } from '../../utils/normalise.js'
-import {
-  type OwnerContract,
-  ownerFromContract,
-} from '../../utils/ownerFromContract.js'
-import { checkIsDotEth } from '../../utils/validation.js'
-import multicallWrapper from './multicallWrapper.js'
-
-export type GetOwnerParameters<
-  TContract extends OwnerContract | undefined = undefined,
-> = {
-  /** Name to get owner for */
-  name: string
-  /** Optional specific contract to get ownership value from */
-  contract?: TContract
-}
-
-type BaseGetOwnerReturnType = {
-  /** Owner of the name */
-  owner?: Address | null
-  /** Registrant of the name (registrar owner) */
-  registrant?: Address | null
-  /** The contract level that the ownership is on */
-  ownershipLevel: 'registry' | 'registrar' | 'nameWrapper'
-}
-
-type RegistrarOnlyOwnership = {
-  owner?: never
-  registrant: Address
-  ownershipLevel: 'registrar'
-}
-
-type WrappedOwnership = {
-  owner: Address
-  registrant?: never
-  ownershipLevel: 'nameWrapper'
-}
-
-type UnwrappedEth2ldOwnership = {
-  registrant: Address | null
-  owner: Address
-  ownershipLevel: 'registrar'
-}
-
-type UnwrappedOwnership = {
-  owner: Address
-  registrant?: never
-  ownershipLevel: 'registry'
-}
-
-export type GetOwnerReturnType<
-  TContract extends OwnerContract | undefined = undefined,
-> =
-  | (BaseGetOwnerReturnType &
-      (TContract extends 'registrar'
-        ? RegistrarOnlyOwnership
-        : TContract extends 'nameWrapper'
-          ? WrappedOwnership
-          : TContract extends 'registry'
-            ? UnwrappedOwnership
-            : WrappedOwnership | UnwrappedEth2ldOwnership | UnwrappedOwnership))
-  | null
-
-const encode = <TContract extends OwnerContract | undefined = undefined>(
-  client: ClientWithEns,
-  { name, contract }: GetOwnerParameters<TContract>,
-): SimpleTransactionRequest => {
-  const namehash = makeNamehash(name)
-  const labels = name.split('.')
-
-  if (contract || labels.length === 1) {
-    return ownerFromContract({
-      client,
-      contract: contract || 'registry',
-      namehash,
-      labels,
-    })
-  }
-
-  const registryData = ownerFromContract({
-    client,
-    contract: 'registry',
-    namehash,
-  })
-  const nameWrapperData = ownerFromContract({
-    client,
-    contract: 'nameWrapper',
-    namehash,
-  })
-
-  const data: { to: Address; data: Hex }[] = [registryData, nameWrapperData]
-
-  if (checkIsDotEth(labels)) {
-    data.push(ownerFromContract({ client, contract: 'registrar', labels }))
-  }
-
-  return multicallWrapper.encode(client, { transactions: data })
-}
-
-const addressDecode = (data: Hex) =>
-  decodeAbiParameters([{ type: 'address' }], data)[0] as Address
-
-const decode = async <TContract extends OwnerContract | undefined = undefined>(
-  client: ClientWithEns,
-  data: Hex | BaseError,
-  { name, contract }: GetOwnerParameters<TContract>,
-): Promise<GetOwnerReturnType<TContract>> => {
-  if (typeof data === 'object') throw data
-  const labels = name.split('.')
-  if (contract || labels.length === 1) {
-    const singleOwner = addressDecode(data)
-    if (contract === 'registrar') {
-      return {
-        ownershipLevel: 'registrar',
-        registrant: singleOwner,
-      } as GetOwnerReturnType<TContract>
-    }
-    return {
-      ownershipLevel: contract || 'registry',
-      owner: singleOwner,
-    } as GetOwnerReturnType<TContract>
-  }
-
-  const result = await multicallWrapper.decode(client, data, [])
-
-  const [registryOwner, nameWrapperOwner, registrarOwner] = [
-    result[0].returnData,
-    result[1].returnData,
-    result[2]?.returnData,
-  ].map((ret) => (ret && ret !== '0x' ? addressDecode(ret) : undefined)) as [
-    Address,
-    Address,
-    Address | undefined,
-  ]
-
-  const nameWrapperAddress = getChainContractAddress({
-    client,
-    contract: 'ensNameWrapper',
-  })
-
-  // check for only .eth names
-  if (labels[labels.length - 1] === 'eth') {
-    // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
-    // there is no "registrant" for wrapped names
-    if (registrarOwner === nameWrapperAddress) {
-      return {
-        owner: nameWrapperOwner,
-        ownershipLevel: 'nameWrapper',
-      } as GetOwnerReturnType<TContract>
-    }
-    // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
-    // this means that it's an unwrapped second-level name
-    // the registrant is the owner of the NFT
-    // the owner is the controller of the records
-    if (registrarOwner) {
-      return {
-        registrant: registrarOwner!,
-        owner: registryOwner!,
-        ownershipLevel: 'registrar',
-      } as GetOwnerReturnType<TContract>
-    }
-    if (registryOwner !== EMPTY_ADDRESS) {
-      // if there is no registrar owner, but the label length is two, then the domain is an expired 2LD .eth
-      // so we still want to return the ownership values
-      if (labels.length === 2) {
-        return {
-          registrant: null,
-          owner: registryOwner,
-          ownershipLevel: 'registrar',
-        } as GetOwnerReturnType<TContract>
-      }
-      // this means that the subname is wrapped
-      if (
-        registryOwner === nameWrapperAddress &&
-        nameWrapperOwner &&
-        nameWrapperOwner !== EMPTY_ADDRESS
-      ) {
-        return {
-          owner: nameWrapperOwner,
-          ownershipLevel: 'nameWrapper',
-        } as GetOwnerReturnType<TContract>
-      }
-      // unwrapped subnames do not have NFTs associated, so do not have a registrant
-      return {
-        owner: registryOwner,
-        ownershipLevel: 'registry',
-      } as GetOwnerReturnType<TContract>
-    }
-    // .eth names with no registrar owner are either unregistered or expired
-    return null
-  }
-
-  // non .eth names inherit the owner from the registry
-  // there will only ever be an owner for non .eth names, not a registrant
-  // this is because for unwrapped names, there is no associated NFT
-  // and for wrapped names, owner and registrant are the same thing
-  if (
-    registryOwner === nameWrapperAddress &&
-    nameWrapperOwner &&
-    nameWrapperOwner !== EMPTY_ADDRESS
-  ) {
-    return {
-      owner: nameWrapperOwner,
-      ownershipLevel: 'nameWrapper',
-    } as GetOwnerReturnType<TContract>
-  }
-
-  // for unwrapped non .eth names, the owner is the registry owner
-  if (registryOwner && registryOwner !== EMPTY_ADDRESS) {
-    return {
-      owner: registryOwner,
-      ownershipLevel: 'registry',
-    } as GetOwnerReturnType<TContract>
-  }
-
-  // for anything else, return
-  return null
-}
-
-type EncoderFunction = typeof encode
-type DecoderFunction = typeof decode
-
-type BatchableFunctionObject = {
-  encode: EncoderFunction
-  decode: DecoderFunction
-  batch: <
-    TContract extends OwnerContract | undefined = undefined,
-    TParams extends
-      GetOwnerParameters<TContract> = GetOwnerParameters<TContract>,
-  >(
-    args: TParams,
-  ) => {
-    args: [TParams]
-    encode: EncoderFunction
-    decode: typeof decode<TContract>
-  }
-}
-
-/**
- * Gets the owner(s) of a name.
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetOwnerParameters}
- * @returns Owner data object, or `null` if no owners exist. {@link GetOwnerReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getOwner } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getOwner(client, { name: 'ens.eth' })
- * // { owner: '0xb6E040C9ECAaE172a89bD561c5F73e1C48d28cd9', registrant: '0xb6E040C9ECAaE172a89bD561c5F73e1C48d28cd9', ownershipLevel: 'registrar }
- */
-const getOwner = generateFunction({ encode, decode }) as (<
-  TContract extends OwnerContract | undefined = undefined,
->(
-  client: ClientWithEns,
-  { name, contract }: GetOwnerParameters<TContract>,
-) => Promise<GetOwnerReturnType<TContract>>) &
-  BatchableFunctionObject
-
-export default getOwner