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

package/src/functions/public/getContentHashRecord.ts

@@ -0,0 +1,68 @@
+import type { BaseError, Hex } from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import type {
+  GenericPassthrough,
+  Prettify,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import _getContentHash, {
+  type InternalGetContentHashParameters,
+  type InternalGetContentHashReturnType,
+} from './_getContentHash.js'
+import universalWrapper from './universalWrapper.js'
+
+export type GetContentHashRecordParameters =
+  Prettify<InternalGetContentHashParameters>
+
+export type GetContentHashRecordReturnType =
+  Prettify<InternalGetContentHashReturnType>
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetContentHashRecordParameters,
+): TransactionRequestWithPassthrough => {
+  const prData = _getContentHash.encode(client, { name })
+  return universalWrapper.encode(client, { name, data: prData.data })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetContentHashRecordReturnType> => {
+  const urData = await universalWrapper.decode(client, data, passthrough)
+  return _getContentHash.decode(client, urData.data)
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the content hash record for a name
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetContentHashRecordParameters}
+ * @returns Content hash object, or `null` if not found. {@link GetContentHashRecordReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getContentHashRecord } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getContentHashRecord(client, { name: 'ens.eth' })
+ * // { protocolType: 'ipfs', decoded: 'k51qzi5uqu5djdczd6zw0grmo23j2vkj9uzvujencg15s5rlkq0ss4ivll8wqw' }
+ */
+const getContentHashRecord = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetContentHashRecordParameters,
+) => Promise<GetContentHashRecordReturnType>) &
+  BatchableFunctionObject
+
+export default getContentHashRecord

package/src/functions/public/getExpiry.ts

@@ -0,0 +1,200 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  labelhash,
+  type Hex,
+} 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 {
+  generateFunction,
+  type GeneratedFunction,
+} 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: bigint = 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

@@ -0,0 +1,129 @@
+import {
+  BaseError,
+  decodeErrorResult,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { universalResolverReverseSnippet } from '../../contracts/universalResolver.js'
+import type {
+  GenericPassthrough,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { getRevertErrorData } from '../../utils/getRevertErrorData.js'
+import { packetToBytes } from '../../utils/hexEncodedName.js'
+
+export type GetNameParameters = {
+  /** Address to get name for */
+  address: Address
+}
+
+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 }: GetNameParameters,
+): TransactionRequestWithPassthrough => {
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
+  const to = getChainContractAddress({
+    client,
+    contract: 'ensUniversalResolver',
+  })
+  const args = [toHex(packetToBytes(reverseNode))] as const
+  return {
+    to,
+    data: encodeFunctionData({
+      abi: universalResolverReverseSnippet,
+      functionName: 'reverse',
+      args,
+    }),
+    passthrough: { address, args },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+  { address }: GetNameParameters,
+): Promise<GetNameReturnType | null> => {
+  if (typeof data === 'object') {
+    const errorData = getRevertErrorData(data)
+    if (errorData) {
+      const decodedError = decodeErrorResult({
+        abi: universalResolverReverseSnippet,
+        data: errorData,
+      })
+      if (
+        decodedError.errorName === 'ResolverNotFound' ||
+        decodedError.errorName === 'ResolverWildcardNotSupported'
+      )
+        return null
+    }
+    throw getContractError(data, {
+      abi: universalResolverReverseSnippet,
+      functionName: 'reverse',
+      args: passthrough.args,
+      address: passthrough.address,
+    }) as BaseError
+  }
+  const result = decodeFunctionResult({
+    abi: universalResolverReverseSnippet,
+    functionName: 'reverse',
+    data,
+  })
+  if (!result[0]) return null
+  return {
+    name: result[0],
+    match: result[1].toLowerCase() === address.toLowerCase(),
+    reverseResolverAddress: result[2],
+    resolverAddress: result[3],
+  }
+}
+
+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 }: GetNameParameters,
+) => Promise<GetNameReturnType>) &
+  BatchableFunctionObject
+
+export default getName

package/src/functions/public/getOwner.ts

@@ -0,0 +1,271 @@
+import { BaseError, decodeAbiParameters, type Address, type Hex } 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 {
+  ownerFromContract,
+  type OwnerContract,
+} 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