@ensdomains/ensjs 4.1.2 → 5.0.0-alpha.1

package/src/functions/dns/getDnsImportData.ts

@@ -1,102 +0,0 @@
-import type { ProvableAnswer, SignedSet } from '@ensdomains/dnsprovejs'
-import type * as packet from 'dns-packet'
-import { type Client, type Hex, type Transport, toHex } from 'viem'
-import { readContract } from 'viem/actions'
-import type { ChainWithEns } from '../../contracts/consts.js'
-import { dnssecImplVerifyRrSetSnippet } from '../../contracts/dnssecImpl.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { DnsNewerRecordTypeAvailableError } from '../../index.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: Hex
-  sig: Hex
-}
-
-export type GetDnsImportDataReturnType = RrSetWithSig[]
-
-// 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: toHex(proof.toWire(true)),
-    sig: toHex(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: Client<Transport, ChainWithEns>,
-  {
-    name,
-    endpoint = 'https://cloudflare-dns.com/dns-query',
-  }: GetDnsImportDataParameters,
-): Promise<GetDnsImportDataReturnType> => {
-  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 rrsets = encodeProofs(allProofs)
-
-  const [onchainRrData, inception] = await readContract(client, {
-    abi: dnssecImplVerifyRrSetSnippet,
-    address: getChainContractAddress({
-      client,
-      contract: 'ensDnssecImpl',
-    }),
-    functionName: 'verifyRRSet',
-    args: [rrsets],
-  })
-
-  const lastProof = allProofs[allProofs.length - 1]
-  if (serialNumberGt(inception, lastProof.signature.data.inception))
-    throw new DnsNewerRecordTypeAvailableError({
-      typeCovered: lastProof.signature.data.typeCovered,
-      signatureName: lastProof.signature.name,
-      onchainInception: inception,
-      dnsInception: lastProof.signature.data.inception,
-    })
-
-  if (toHex(lastProof.toWire(false)) !== onchainRrData)
-    throw new Error('Mismatched proof data')
-
-  return rrsets
-}
-
-export default getDnsImportData

package/src/functions/dns/getDnsOffchainData.ts

@@ -1,152 +0,0 @@
-import { type Address, type Client, type Transport, isAddress } from 'viem'
-import type { ChainWithEns } from '../../contracts/consts.js'
-import {
-  DnsDnssecVerificationFailedError,
-  DnsDnssecWildcardExpansionError,
-  DnsInvalidTxtRecordError,
-  DnsNoTxtRecordError,
-  DnsResponseStatusError,
-} from '../../errors/dns.js'
-import { UnsupportedNameTypeError } from '../../errors/general.js'
-import { getDnsTxtRecords } from '../../utils/dns/getDnsTxtRecords.js'
-import {
-  DnsRecordType,
-  type DnsResponseItem,
-  DnsResponseStatus,
-} from '../../utils/dns/misc.js'
-import { getNameType } from '../../utils/getNameType.js'
-import getAddressRecord from '../public/getAddressRecord.js'
-import type { Endpoint } from './types.js'
-
-export type GetDnsOffchainDataParameters = {
-  /** Name to get the offchain data for */
-  name: string
-  /** An RFC-1035 compatible DNS endpoint to use (default: `https://cloudflare-dns.com/dns-query`) */
-  endpoint?: Endpoint
-  /** Whether or not to throw errors */
-  strict?: boolean
-}
-
-export type GetDnsOffchainDataReturnType = {
-  resolverAddress: Address
-  extraData: string | null
-} | null
-
-type ValidTextRecord = {
-  isValid: true
-  resolverAddress: Address
-  extraData: string | null
-}
-type InvalidTextRecord = { isValid: false; recordData: string }
-
-const checkValidEnsTxtRecord = async (
-  client: Client<Transport, ChainWithEns>,
-  record: DnsResponseItem,
-): Promise<InvalidTextRecord | ValidTextRecord | null> => {
-  if (record.type !== DnsRecordType.TXT) return null
-  if (!record.data.startsWith('"ENS1 ')) return null
-
-  const unwrappedRecordData = record.data.replace(/^"(.*)"$/g, '$1')
-
-  const resolverAndExtraData = unwrappedRecordData.slice(5)
-  const splitIndex = resolverAndExtraData.indexOf(' ')
-  const resolverNameOrAddress =
-    splitIndex === -1
-      ? resolverAndExtraData
-      : resolverAndExtraData.slice(0, splitIndex)
-  const extraData =
-    splitIndex === -1 ? null : resolverAndExtraData.slice(splitIndex + 1)
-
-  if (isAddress(resolverNameOrAddress))
-    return { isValid: true, resolverAddress: resolverNameOrAddress, extraData }
-
-  const resolverAddress = await getAddressRecord(client, {
-    name: resolverNameOrAddress,
-    // force no ccip-read, since dnsregistrar doesn't allow resolvers with ccip-read addresses
-    gatewayUrls: [],
-  }).catch(() => null) // if ccip-read is attempted, an error will be thrown. we can just ignore it
-
-  if (resolverAddress)
-    return {
-      isValid: true,
-      resolverAddress: resolverAddress.value as Address,
-      extraData,
-    }
-
-  return { isValid: false, recordData: unwrappedRecordData }
-}
-
-/**
- * Gets the DNS offchain data for a name, via DNS record lookup
- * @param parameters - {@link GetDnsOffchainDataParameters}
- * @returns Resolver address and extra data, or null. {@link GetDnsOffchainDataReturnType}
- *
- * @example
- * import { getDnsOffchainData } from '@ensdomains/ensjs/dns'
- *
- * const owner = await getDnsOffchainData({ name: 'ethleaderboard.xyz' })
- */
-const getDnsOffchainData = async (
-  client: Client<Transport, ChainWithEns>,
-  { name, endpoint, strict }: GetDnsOffchainDataParameters,
-): Promise<GetDnsOffchainDataReturnType> => {
-  const nameType = getNameType(name)
-
-  if (nameType !== 'other-2ld' && nameType !== 'other-subname')
-    throw new UnsupportedNameTypeError({
-      nameType,
-      supportedNameTypes: ['other-2ld', 'other-subname'],
-    })
-
-  try {
-    const response = await getDnsTxtRecords({ name, endpoint })
-
-    if (response.Status !== DnsResponseStatus.NOERROR)
-      throw new DnsResponseStatusError({
-        responseStatus: DnsResponseStatus[response.Status],
-      })
-
-    if (response.AD === false)
-      throw new DnsDnssecVerificationFailedError({ record: undefined })
-
-    if (!response.Answer?.length) throw new DnsNoTxtRecordError()
-
-    const labels = name.split('.')
-    const rrsigRecord = response.Answer.find((record) => {
-      if (record.type !== DnsRecordType.RRSIG) return false
-      if (record.name !== name) return false
-      if (!record.data.startsWith('TXT')) return false
-      const [, , labelCount] = record.data.split(' ')
-      // mismatching label count implies wildcard expansion, which is not supported
-      return Number(labelCount) === labels.length
-    })
-
-    if (!rrsigRecord) throw new DnsDnssecWildcardExpansionError()
-
-    const ensTxtRecords = await Promise.all(
-      response.Answer.map((record) => checkValidEnsTxtRecord(client, record)),
-    )
-
-    const validRecord = ensTxtRecords.find(
-      (record): record is ValidTextRecord => record?.isValid === true,
-    )
-    if (validRecord)
-      return {
-        resolverAddress: validRecord.resolverAddress,
-        extraData: validRecord.extraData,
-      }
-
-    const invalidRecord = ensTxtRecords.find(
-      (record): record is InvalidTextRecord => record?.isValid === false,
-    )
-    if (invalidRecord)
-      throw new DnsInvalidTxtRecordError({ record: invalidRecord.recordData })
-
-    throw new DnsNoTxtRecordError()
-  } catch (error) {
-    if (!strict) return null
-    throw error
-  }
-}
-
-export default getDnsOffchainData

package/src/functions/dns/getDnsOwner.ts

@@ -1,89 +0,0 @@
-import { type Address, getAddress } from 'viem'
-import {
-  DnsDnssecVerificationFailedError,
-  DnsInvalidAddressChecksumError,
-  DnsInvalidTxtRecordError,
-  DnsNoTxtRecordError,
-  DnsResponseStatusError,
-} from '../../errors/dns.js'
-import { UnsupportedNameTypeError } from '../../errors/general.js'
-import { getDnsTxtRecords } from '../../utils/dns/getDnsTxtRecords.js'
-import { DnsRecordType, DnsResponseStatus } from '../../utils/dns/misc.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
-  /** Whether or not to throw errors */
-  strict?: boolean
-}
-
-export type GetDnsOwnerReturnType = Address | null
-
-/**
- * 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,
-  strict,
-}: GetDnsOwnerParameters): Promise<GetDnsOwnerReturnType> => {
-  const nameType = getNameType(name)
-
-  if (nameType !== 'other-2ld')
-    throw new UnsupportedNameTypeError({
-      nameType,
-      supportedNameTypes: ['other-2ld'],
-    })
-
-  try {
-    const response = await getDnsTxtRecords({ name: `_ens.${name}`, endpoint })
-
-    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
-  } catch (error) {
-    if (!strict) return null
-    throw error
-  }
-}
-
-export default getDnsOwner

package/src/functions/dns/importDnsName.ts

@@ -1,171 +0,0 @@
-import {
-  type Account,
-  type Address,
-  type Hash,
-  type SendTransactionParameters,
-  type Transport,
-  encodeFunctionData,
-  toHex,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import type { ChainWithEns, ClientWithAccount } 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: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    dnsImportData,
-    address,
-    resolverAddress,
-  }: ImportDnsNameDataParameters,
-): ImportDnsNameDataReturnType => {
-  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, dnsImportData],
-      }),
-    }
-  }
-
-  const resolverAddress_ =
-    resolverAddress ||
-    getChainContractAddress({ client: wallet, contract: 'ensPublicResolver' })
-
-  return {
-    to: dnsRegistrarAddress,
-    data: encodeFunctionData({
-      abi: dnsRegistrarProveAndClaimWithResolverSnippet,
-      functionName: 'proveAndClaimWithResolver',
-      args: [hexEncodedName, dnsImportData, resolverAddress_, address],
-    }),
-  }
-}
-
-/**
- * Creates a transaction to import a DNS name to ENS.
- * @param wallet - {@link ClientWithAccount}
- * @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: ClientWithAccount<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 sendTransaction(wallet, writeArgs)
-}
-
-importDnsName.makeFunctionData = makeFunctionData
-
-export default importDnsName

package/src/functions/public/_getAbi.ts

@@ -1,126 +0,0 @@
-import {
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  hexToBytes,
-  hexToString,
-} from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { publicResolverAbiSnippet } from '../../contracts/publicResolver.js'
-import type {
-  DecodedAbi,
-  Prettify,
-  SimpleTransactionRequest,
-} from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { generateFunction } from '../../utils/generateFunction.js'
-import { namehash } from '../../utils/normalise.js'
-
-export type InternalGetAbiParameters = {
-  /** Name to get ABI record for */
-  name: string
-  /** Supported content types as bitwise
-   * ID 1: JSON
-   * ID 2: zlib compressed JSON
-   * ID 4: CBOR
-   * ID 8: URI
-   */
-  supportedContentTypes?: bigint
-  /** Whether or not to throw decoding errors */
-  strict?: boolean
-}
-
-export type InternalGetAbiReturnType = Prettify<DecodedAbi | null>
-
-const encode = (
-  _client: ClientWithEns,
-  {
-    name,
-    supportedContentTypes = 0xfn,
-  }: Omit<InternalGetAbiParameters, 'strict'>,
-): SimpleTransactionRequest => {
-  return {
-    to: EMPTY_ADDRESS,
-    data: encodeFunctionData({
-      abi: publicResolverAbiSnippet,
-      functionName: 'ABI',
-      args: [namehash(name), supportedContentTypes],
-    }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex,
-  { strict }: Pick<InternalGetAbiParameters, 'strict'>,
-): Promise<InternalGetAbiReturnType> => {
-  if (data === '0x') return null
-
-  try {
-    const [bigintContentType, encodedAbiData] = decodeFunctionResult({
-      abi: publicResolverAbiSnippet,
-      functionName: 'ABI',
-      data,
-    })
-
-    if (!bigintContentType || !encodedAbiData) {
-      return null
-    }
-
-    const contentType = Number(bigintContentType)
-    if (!contentType) {
-      return null
-    }
-
-    let abiData: string | object
-    let decoded = false
-    switch (contentType) {
-      // JSON
-      case 1:
-        abiData = JSON.parse(hexToString(encodedAbiData))
-        decoded = true
-        break
-      // zlib compressed JSON
-      case 2: {
-        const { inflate } = await import('pako/dist/pako_inflate.min.js')
-        abiData = JSON.parse(
-          inflate(hexToBytes(encodedAbiData), { to: 'string' }),
-        )
-        decoded = true
-        break
-      }
-      // CBOR
-      case 4: {
-        const { cborDecode } = await import('@ensdomains/address-encoder/utils')
-        abiData = await cborDecode(hexToBytes(encodedAbiData).buffer)
-        decoded = true
-        break
-      }
-      // URI
-      case 8:
-        abiData = hexToString(encodedAbiData)
-        decoded = true
-        break
-      default:
-        try {
-          abiData = hexToString(encodedAbiData)
-          decoded = true
-        } catch {
-          abiData = encodedAbiData
-        }
-    }
-
-    return {
-      contentType,
-      decoded,
-      abi: abiData,
-    }
-  } catch (error) {
-    if (strict) throw error
-    return null
-  }
-}
-
-const _getAbi = generateFunction({ encode, decode })
-
-export default _getAbi