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

package/src/errors/subgraph.ts

@@ -0,0 +1,71 @@
+import { BaseError } from './base.js'
+
+export class InvalidFilterKeyError extends BaseError {
+  filterKey: string
+
+  supportedFilterKeys: readonly string[]
+
+  override name = 'InvalidFilterKeyError'
+
+  constructor({
+    filterKey,
+    supportedFilterKeys,
+  }: {
+    filterKey: string
+    supportedFilterKeys: readonly string[]
+  }) {
+    super(`Invalid filter key: ${filterKey}`, {
+      metaMessages: [
+        `- Supported filter keys: ${supportedFilterKeys.join(', ')}`,
+      ],
+    })
+    this.filterKey = filterKey
+    this.supportedFilterKeys = supportedFilterKeys
+  }
+}
+
+export class FilterKeyRequiredError extends BaseError {
+  supportedFilterKeys: readonly string[]
+
+  override name = 'FilterKeyRequiredError'
+
+  constructor({
+    supportedFilterKeys,
+    details,
+  }: {
+    supportedFilterKeys: readonly string[]
+    details?: string
+  }) {
+    super('At least one filter key is required', {
+      metaMessages: [
+        `- Supported filter keys: ${supportedFilterKeys.join(', ')}`,
+      ],
+      details,
+    })
+    this.supportedFilterKeys = supportedFilterKeys
+  }
+}
+
+export class InvalidOrderByError extends BaseError {
+  orderBy: string
+
+  supportedOrderBys: string[]
+
+  override name = 'InvalidOrderByError'
+
+  constructor({
+    orderBy,
+    supportedOrderBys,
+  }: {
+    orderBy: string
+    supportedOrderBys: string[]
+  }) {
+    super(`Invalid orderBy: ${orderBy}`, {
+      metaMessages: [
+        `- Supported orderBy keys: ${supportedOrderBys.join(', ')}`,
+      ],
+    })
+    this.orderBy = orderBy
+    this.supportedOrderBys = supportedOrderBys
+  }
+}

package/src/errors/utils.ts

@@ -0,0 +1,172 @@
+import { BaseError } from './base.js'
+
+export class FusesOutOfRangeError extends BaseError {
+  override name = 'FusesOutOfRangeError'
+
+  constructor({
+    fuses,
+    minimum = 0n,
+    maximum = 2n ** 32n,
+    details,
+  }: {
+    fuses: bigint
+    minimum?: bigint
+    maximum?: bigint
+    details?: string
+  }) {
+    super('Fuse value out of range', {
+      metaMessages: [
+        `- Fuse value: ${fuses}`,
+        `- Allowed range: ${minimum}-${maximum}`,
+      ],
+      details,
+    })
+  }
+}
+
+export class FusesRestrictionNotAllowedError extends BaseError {
+  override name = 'FusesRestrictionNotAllowed'
+
+  constructor({
+    fuses,
+    details,
+  }: {
+    fuses: object | bigint
+    details?: string
+  }) {
+    super('Restriction not allowed', {
+      metaMessages: [`- Fuse value: ${fuses}`],
+      details,
+    })
+  }
+}
+
+export class FusesInvalidFuseObjectError extends BaseError {
+  override name = 'FusesInvalidFuseObjectError'
+
+  constructor({ fuses, details }: { fuses: object; details?: string }) {
+    super('Invalid fuse value', {
+      metaMessages: [`- Fuse value: ${fuses}`],
+      details,
+    })
+  }
+}
+
+export class FusesValueRequiredError extends BaseError {
+  override name = 'FusesValueRequiredError'
+
+  constructor() {
+    super('Must specify at least one fuse')
+  }
+}
+
+export class FusesInvalidNamedFuseError extends BaseError {
+  override name = 'FusesInvalidNamedFuseError'
+
+  constructor({ fuse }: { fuse: string }) {
+    super(`${fuse} is not a valid named fuse`)
+  }
+}
+
+export class FusesFuseNotAllowedError extends BaseError {
+  override name = 'FusesFuseNotAllowedError'
+
+  constructor({ fuse }: { fuse: string | bigint }) {
+    super(`${fuse} is not allowed for this operation`)
+  }
+}
+
+export class FusesInvalidUnnamedFuseError extends BaseError {
+  override name = 'FusesInvalidUnnamedFuseError'
+
+  constructor({ fuse }: { fuse: any }) {
+    super(`${fuse} is not a valid unnamed fuse`, {
+      metaMessages: [
+        `- If you are trying to set a named fuse, use the named property`,
+      ],
+    })
+  }
+}
+
+export class InvalidEncodedLabelError extends BaseError {
+  override name = 'InvalidEncodedLabelError'
+
+  constructor({ label, details }: { label: string; details?: string }) {
+    super('Invalid encoded label', {
+      metaMessages: [`- Supplied label: ${label}`],
+      details,
+    })
+  }
+}
+
+export class InvalidLabelhashError extends BaseError {
+  override name = 'InvalidLabelhashError'
+
+  constructor({ labelhash, details }: { labelhash: string; details?: string }) {
+    super('Invalid labelhash', {
+      metaMessages: [`- Supplied labelhash: ${labelhash}`],
+      details,
+    })
+  }
+}
+
+export class NameWithEmptyLabelsError extends BaseError {
+  override name = 'NameWithEmptyLabelsError'
+
+  constructor({ name, details }: { name: string; details?: string }) {
+    super('Name cannot have empty labels', {
+      metaMessages: [`- Supplied name: ${name}`],
+      details,
+    })
+  }
+}
+
+export class RootNameIncludesOtherLabelsError extends BaseError {
+  override name = 'RootNameIncludesOtherLabelsError'
+
+  constructor({ name }: { name: string }) {
+    super('Root name cannot have other labels', {
+      metaMessages: [`- Supplied name: ${name}`],
+    })
+  }
+}
+
+export class WrappedLabelTooLargeError extends BaseError {
+  override name = 'WrappedLabelTooLargeError'
+
+  constructor({ label, byteLength }: { label: string; byteLength: number }) {
+    super('Supplied label was too long', {
+      metaMessages: [
+        `- Supplied label: ${label}`,
+        `- Max byte length: 255`,
+        `- Actual byte length: ${byteLength}`,
+      ],
+    })
+  }
+}
+
+export class CampaignReferenceTooLargeError extends BaseError {
+  override name = 'CampaignReferenceTooLargeError'
+
+  constructor({ campaign }: { campaign: number }) {
+    super(`Campaign reference ${campaign} is too large`, {
+      metaMessages: [`- Max campaign reference: ${0xffffffff}`],
+    })
+  }
+}
+
+export class InvalidContentHashError extends BaseError {
+  override name = 'InvalidContentHashError'
+
+  constructor() {
+    super('Invalid content hash')
+  }
+}
+
+export class UnknownContentTypeError extends BaseError {
+  override name = 'UnknownContentTypeError'
+
+  constructor({ contentType }: { contentType: string }) {
+    super(`Unknown content type: ${contentType}`)
+  }
+}

package/src/errors/version.ts

@@ -0,0 +1 @@
+export const version = 'v3.0.0-beta.10'

package/src/functions/dns/getDnsImportData.ts

@@ -0,0 +1,133 @@
+import type { ProvableAnswer, SignedSet } from '@ensdomains/dnsprovejs'
+import type * as packet from 'dns-packet'
+import { toType } from 'dns-packet/types.js'
+import { keccak256, toBytes, toHex } from 'viem'
+import { readContract } from 'viem/actions'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import {
+  dnssecImplAnchorsSnippet,
+  dnssecImplRrDataSnippet,
+} from '../../contracts/dnssecImpl.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { DnsNewerRecordTypeAvailableError } from '../../errors/dns.js'
+import { packetToBytes } from '../../utils/hexEncodedName.js'
+import type { Endpoint } from './types.js'
+
+export type GetDnsImportDataParameters = {
+  /** Name to prepare for DNS import */
+  name: string
+  /** An RFC-1035 compatible DNS endpoint to use (default: `https://cloudflare-dns.com/dns-query`) */
+  endpoint?: Endpoint
+}
+
+export type RrSetWithSig = {
+  rrset: Uint8Array
+  sig: Uint8Array
+}
+
+export type GetDnsImportDataReturnType = {
+  rrsets: RrSetWithSig[]
+  proof: Uint8Array
+}
+
+// Compares two serial numbers using RFC1982 serial number math.
+const serialNumberGt = (i1: number, i2: number): boolean =>
+  (i1 < i2 && i2 - i1 > 0x7fffffff) || (i1 > i2 && i1 - i2 < 0x7fffffff)
+
+const encodeProofs = (
+  proofs: SignedSet<packet.Ds | packet.Dnskey | packet.Rtxt>[],
+): RrSetWithSig[] =>
+  proofs.map((proof) => ({
+    rrset: proof.toWire(true),
+    sig: proof.signature.data.signature,
+  }))
+
+/**
+ * Gets DNS import data, used for `importDnsName()`
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetDnsImportDataParameters}
+ * @returns DNS import data object, used for proving the value of the `_ens` TXT record
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getDnsImportData } from '@ensdomains/ensjs/dns'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const data = await getDnsImportData(client, {
+ *   name: 'example.eth',
+ * })
+ */
+const getDnsImportData = async (
+  client: ClientWithEns,
+  {
+    name,
+    endpoint = 'https://cloudflare-dns.com/dns-query',
+  }: GetDnsImportDataParameters,
+): Promise<GetDnsImportDataReturnType> => {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const { DNSProver } = await import('@ensdomains/dnsprovejs')
+  const prover = DNSProver.create(endpoint)
+  const result = (await prover.queryWithProof(
+    'TXT',
+    `_ens.${name}`,
+  )) as ProvableAnswer<packet.Rtxt>
+
+  const allProofs = (
+    result.proofs as SignedSet<packet.Ds | packet.Dnskey | packet.Rtxt>[]
+  ).concat([result.answer])
+
+  const ensDnssecImplAddress = getChainContractAddress({
+    client,
+    contract: 'ensDnssecImpl',
+  })
+
+  for (let i = allProofs.length - 1; i >= 0; i -= 1) {
+    const proof = allProofs[i]
+    const hexEncodedName = toHex(packetToBytes(proof.signature.name))
+    const type = toType(proof.signature.data.typeCovered)
+    // eslint-disable-next-line no-await-in-loop
+    const [inception, expiration, hash] = await readContract(client, {
+      abi: dnssecImplRrDataSnippet,
+      address: ensDnssecImplAddress,
+      functionName: 'rrdata',
+      args: [type, hexEncodedName],
+    })
+    if (serialNumberGt(inception, proof.signature.data.inception))
+      throw new DnsNewerRecordTypeAvailableError({
+        typeCovered: proof.signature.data.typeCovered,
+        signatureName: proof.signature.name,
+        onchainInception: inception,
+        dnsInception: proof.signature.data.inception,
+      })
+    const expired = serialNumberGt(Date.now() / 1000, expiration)
+    const proofHash = keccak256(proof.toWire(false)).slice(0, 42)
+    const isKnownProof = hash === proofHash && !expired
+    if (isKnownProof) {
+      if (i === allProofs.length - 1) {
+        return { rrsets: [], proof: proof.toWire(false) }
+      }
+      return {
+        rrsets: encodeProofs(allProofs.slice(i + 1, allProofs.length)),
+        proof: proof.toWire(false),
+      }
+    }
+  }
+
+  return {
+    rrsets: encodeProofs(allProofs),
+    proof: toBytes(
+      await readContract(client, {
+        abi: dnssecImplAnchorsSnippet,
+        address: ensDnssecImplAddress,
+        functionName: 'anchors',
+      }),
+    ),
+  }
+}
+
+export default getDnsImportData

package/src/functions/dns/getDnsOwner.ts

@@ -0,0 +1,141 @@
+import { getAddress, type Address } from 'viem'
+import {
+  DnsDnssecVerificationFailedError,
+  DnsInvalidAddressChecksumError,
+  DnsInvalidTxtRecordError,
+  DnsNoTxtRecordError,
+  DnsResponseStatusError,
+} from '../../errors/dns.js'
+import { UnsupportedNameTypeError } from '../../errors/general.js'
+import { getNameType } from '../../utils/getNameType.js'
+import type { Endpoint } from './types.js'
+
+export type GetDnsOwnerParameters = {
+  /** Name to get the owner for */
+  name: string
+  /** An RFC-1035 compatible DNS endpoint to use (default: `https://cloudflare-dns.com/dns-query`) */
+  endpoint?: Endpoint
+  /** Optional flag to allow the function to fail silently (default: `true`) */
+  allowFailure?: boolean
+}
+
+export type GetDnsOwnerReturnType = Address
+
+enum DnsResponseStatus {
+  NOERROR = 0,
+  FORMERR = 1,
+  SERVFAIL = 2,
+  NXDOMAIN = 3,
+  NOTIMP = 4,
+  REFUSED = 5,
+  YXDOMAIN = 6,
+  YXRRSET = 7,
+  NXRRSET = 8,
+  NOTAUTH = 9,
+  NOTZONE = 10,
+  DSOTYPENI = 11,
+  BADVERS = 16,
+  BADSIG = 16,
+  BADKEY = 17,
+  BADTIME = 18,
+  BADMODE = 19,
+  BADNAME = 20,
+  BADALG = 21,
+  BADTRUNC = 22,
+  BADCOOKIE = 23,
+}
+
+enum DnsRecordType {
+  TXT = 16,
+  DS = 43,
+  RRSIG = 46,
+  DNSKEY = 48,
+}
+
+type DnsQuestionItem = {
+  name: string
+  type: DnsRecordType
+}
+
+type DnsResponseItem = DnsQuestionItem & {
+  TTL: number
+  data: string
+}
+
+type DnsResponse = {
+  Status: DnsResponseStatus
+  TC: boolean
+  RD: boolean
+  RA: boolean
+  AD: boolean
+  CD: boolean
+  Question: DnsQuestionItem[]
+  Answer?: DnsResponseItem[]
+  Authority?: DnsResponseItem[]
+  Additional?: DnsResponseItem[]
+  Comment?: string
+}
+
+/**
+ * Gets the DNS owner of a name, via DNS record lookup
+ * @param parameters - {@link GetDnsOwnerParameters}
+ * @returns Address of DNS owner. {@link GetDnsOwnerReturnType}
+ *
+ * @example
+ * import { getDnsOwner } from '@ensdomains/ensjs/dns'
+ *
+ * const owner = await getDnsOwner({ name: 'ens.domains' })
+ * // '0xb8c2C29ee19D8307cb7255e1Cd9CbDE883A267d5'
+ */
+const getDnsOwner = async ({
+  name,
+  endpoint = 'https://cloudflare-dns.com/dns-query',
+}: GetDnsOwnerParameters): Promise<GetDnsOwnerReturnType> => {
+  const nameType = getNameType(name)
+
+  if (nameType !== 'other-2ld')
+    throw new UnsupportedNameTypeError({
+      nameType,
+      supportedNameTypes: ['other-2ld'],
+    })
+
+  const response: DnsResponse = await fetch(
+    `${endpoint}?name=_ens.${name}.&type=TXT`,
+    {
+      method: 'GET',
+      headers: {
+        accept: 'application/dns-json',
+      },
+    },
+  ).then((res) => res.json())
+
+  if (response.Status !== DnsResponseStatus.NOERROR)
+    throw new DnsResponseStatusError({
+      responseStatus: DnsResponseStatus[response.Status],
+    })
+
+  const addressRecord = response.Answer?.find(
+    (record) => record.type === DnsRecordType.TXT,
+  )
+  const unwrappedAddressRecord = addressRecord?.data?.replace(/^"(.*)"$/g, '$1')
+
+  if (response.AD === false)
+    throw new DnsDnssecVerificationFailedError({
+      record: unwrappedAddressRecord,
+    })
+
+  if (!addressRecord?.data) throw new DnsNoTxtRecordError()
+
+  if (!unwrappedAddressRecord!.match(/^a=0x[a-fA-F0-9]{40}$/g))
+    throw new DnsInvalidTxtRecordError({ record: unwrappedAddressRecord! })
+
+  const address = unwrappedAddressRecord!.slice(2)
+  const checksumAddress = getAddress(address)
+
+  if (address !== checksumAddress)
+    throw new DnsInvalidAddressChecksumError({ address })
+
+  return checksumAddress
+}
+
+export default getDnsOwner

package/src/functions/dns/importDnsName.ts

@@ -0,0 +1,181 @@
+import {
+  bytesToHex,
+  encodeFunctionData,
+  toHex,
+  type Account,
+  type Address,
+  type Hash,
+  type SendTransactionParameters,
+  type Transport,
+} from 'viem'
+import type { ChainWithEns, WalletWithEns } from '../../contracts/consts.js'
+import {
+  dnsRegistrarProveAndClaimSnippet,
+  dnsRegistrarProveAndClaimWithResolverSnippet,
+} from '../../contracts/dnsRegistrar.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { AdditionalParameterSpecifiedError } from '../../errors/general.js'
+import type {
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { packetToBytes } from '../../utils/hexEncodedName.js'
+import type { GetDnsImportDataReturnType } from './getDnsImportData.js'
+
+type BaseImportDnsNameDataParameters = {
+  /** Name to import */
+  name: string
+  /** Data returned from `getDnsImportData()` */
+  dnsImportData: GetDnsImportDataReturnType
+  /** Address to claim the name for */
+  address?: Address
+  /** Address of the resolver to use (default: `ensPublicResolver`) */
+  resolverAddress?: Address
+}
+
+type NoResolverImportDnsNameDataParameters = {
+  address?: never
+  resolverAddress?: never
+}
+
+type ResolverImportDnsNameDataParameters = {
+  address: Address
+  resolverAddress?: Address
+}
+
+export type ImportDnsNameDataParameters = BaseImportDnsNameDataParameters &
+  (NoResolverImportDnsNameDataParameters | ResolverImportDnsNameDataParameters)
+
+export type ImportDnsNameDataReturnType = SimpleTransactionRequest
+
+export type ImportDnsNameParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  ImportDnsNameDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type ImportDnsNameReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    dnsImportData,
+    address,
+    resolverAddress,
+  }: ImportDnsNameDataParameters,
+): ImportDnsNameDataReturnType => {
+  const data = dnsImportData.rrsets.map((rrset) => ({
+    rrset: bytesToHex(rrset.rrset),
+    sig: bytesToHex(rrset.sig),
+  }))
+  const hexEncodedName = toHex(packetToBytes(name))
+  const dnsRegistrarAddress = getChainContractAddress({
+    client: wallet,
+    contract: 'ensDnsRegistrar',
+  })
+
+  if (!address) {
+    if (resolverAddress)
+      throw new AdditionalParameterSpecifiedError({
+        parameter: 'resolverAddress',
+        allowedParameters: ['name', 'dnsImportData'],
+        details:
+          'resolverAddress cannot be specified when claiming without an address',
+      })
+    return {
+      to: dnsRegistrarAddress,
+      data: encodeFunctionData({
+        abi: dnsRegistrarProveAndClaimSnippet,
+        functionName: 'proveAndClaim',
+        args: [hexEncodedName, data, bytesToHex(dnsImportData.proof)],
+      }),
+    }
+  }
+
+  const resolverAddress_ =
+    resolverAddress ||
+    getChainContractAddress({ client: wallet, contract: 'ensPublicResolver' })
+
+  return {
+    to: dnsRegistrarAddress,
+    data: encodeFunctionData({
+      abi: dnsRegistrarProveAndClaimWithResolverSnippet,
+      functionName: 'proveAndClaimWithResolver',
+      args: [
+        hexEncodedName,
+        data,
+        bytesToHex(dnsImportData.proof),
+        resolverAddress_,
+        address,
+      ],
+    }),
+  }
+}
+
+/**
+ * Creates a transaction to import a DNS name to ENS.
+ * @param wallet - {@link WalletWithEns}
+ * @param parameters - {@link ImportDnsNameParameters}
+ * @returns A transaction hash. {@link ImportDnsNameReturnType}
+ *
+ * @example
+ * import { createPublicClient, createWalletClient, http, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getDnsImportData, importDnsName } from '@ensdomains/ensjs/dns'
+ *
+ * const mainnetWithEns = addEnsContracts(mainnet)
+ * const client = createPublicClient({
+ *   chain: mainnetWithEns,
+ *   transport: http(),
+ * })
+ * const wallet = createWalletClient({
+ *   chain: mainnetWithEns,
+ *   transport: custom(window.ethereum),
+ * })
+ * const dnsImportData = await getDnsImportData(client, {
+ *   name: 'example.com',
+ * })
+ * const hash = await importDnsName(wallet, {
+ *   name: 'example.com',
+ *   dnsImportData,
+ * })
+ */
+async function importDnsName<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    address,
+    dnsImportData,
+    resolverAddress,
+    ...txArgs
+  }: ImportDnsNameParameters<TChain, TAccount, TChainOverride>,
+): Promise<ImportDnsNameReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    address,
+    dnsImportData,
+    resolverAddress,
+  } as ImportDnsNameDataParameters)
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return wallet.sendTransaction(writeArgs)
+}
+
+importDnsName.makeFunctionData = makeFunctionData
+
+export default importDnsName

package/src/functions/dns/types.ts

@@ -0,0 +1 @@
+export type Endpoint = `https://${string}` | `http://${string}`