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

package/src/functions/dns/importDnsName.ts

@@ -0,0 +1,175 @@
+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 { PrepareDnsImportReturnType } from './prepareDnsImport.js'
+
+type BaseImportDnsNameDataParameters = {
+  /** Name to import */
+  name: string
+  /** Data returned from `prepareDnsImport()` */
+  preparedData: PrepareDnsImportReturnType
+  /** 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, preparedData, address, resolverAddress }: ImportDnsNameDataParameters,
+): ImportDnsNameDataReturnType => {
+  const data = preparedData.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', 'preparedData'],
+        details:
+          'resolverAddress cannot be specified when claiming without an address',
+      })
+    return {
+      to: dnsRegistrarAddress,
+      data: encodeFunctionData({
+        abi: dnsRegistrarProveAndClaimSnippet,
+        functionName: 'proveAndClaim',
+        args: [hexEncodedName, data, bytesToHex(preparedData.proof)],
+      }),
+    }
+  }
+
+  const resolverAddress_ =
+    resolverAddress ||
+    getChainContractAddress({ client: wallet, contract: 'ensPublicResolver' })
+
+  return {
+    to: dnsRegistrarAddress,
+    data: encodeFunctionData({
+      abi: dnsRegistrarProveAndClaimWithResolverSnippet,
+      functionName: 'proveAndClaimWithResolver',
+      args: [
+        hexEncodedName,
+        data,
+        bytesToHex(preparedData.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 { addContracts, prepareDnsImport, importDnsName } from '@ensdomains/ensjs'
+ *
+ * const [mainnetWithEns] = addContracts([mainnet])
+ * const client = createPublicClient({
+ *   chain: mainnetWithEns,
+ *   transport: http(),
+ * })
+ * const wallet = createWalletClient({
+ *   chain: mainnetWithEns,
+ *   transport: custom(window.ethereum),
+ * })
+ * const preparedData = await prepareDnsImport(client, {
+ *   name: 'example.com',
+ * })
+ * const hash = await importDnsName(client, {
+ *   name: 'example.com',
+ *   preparedData,
+ * })
+ */
+async function importDnsName<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    address,
+    preparedData,
+    resolverAddress,
+    ...txArgs
+  }: ImportDnsNameParameters<TChain, TAccount, TChainOverride>,
+): Promise<ImportDnsNameReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    address,
+    preparedData,
+    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/prepareDnsImport.test.ts

@@ -0,0 +1,115 @@
+import { SignedSet } from '@ensdomains/dnsprovejs'
+import type { Address, Hex } from 'viem'
+import {
+  publicClient,
+  testClient,
+  waitForTransaction,
+  walletClient,
+} from '../../tests/addTestContracts.js'
+import importDnsName from './importDnsName.js'
+import prepareDnsImport, { type RrSetWithSig } from './prepareDnsImport.js'
+
+let snapshot: Hex
+let accounts: Address[]
+
+beforeAll(async () => {
+  accounts = await walletClient.getAddresses()
+})
+
+beforeEach(async () => {
+  snapshot = await testClient.snapshot()
+})
+
+afterEach(async () => {
+  await testClient.revert({ id: snapshot })
+})
+
+const decodeProofs = (proofs: RrSetWithSig[]) =>
+  proofs.map((proof) =>
+    SignedSet.fromWire(proof.rrset as Buffer, proof.sig as Buffer),
+  )
+
+jest.setTimeout(10000)
+
+const wait = async (ms: number) =>
+  // eslint-disable-next-line no-promise-executor-return
+  new Promise((resolve) => setTimeout(resolve, ms))
+
+it('returns all rrsets when no proofs are known', async () => {
+  const result = await prepareDnsImport(publicClient, {
+    name: 'taytems.xyz',
+  })
+  expect(result.rrsets.length).toBeGreaterThan(0)
+  expect(result.proof).toBeInstanceOf(Uint8Array)
+  const decodedProofs = decodeProofs(result.rrsets)
+  const rootProofs = decodedProofs.filter((x) => x.signature.name === '.')
+  const tldProofs = decodedProofs.filter((x) => x.signature.name === 'xyz')
+  const twoLDProofs = decodedProofs.filter(
+    (x) => x.signature.name === 'taytems.xyz',
+  )
+  const threeLDProofs = decodedProofs.filter(
+    (x) => x.signature.name === '_ens.taytems.xyz',
+  )
+  expect(rootProofs.length).toBeGreaterThan(0)
+  expect(tldProofs.length).toBeGreaterThan(0)
+  expect(twoLDProofs.length).toBeGreaterThan(0)
+  expect(threeLDProofs.length).toBeGreaterThan(0)
+})
+it('returns rrsets up to the first unknown proof', async () => {
+  const tx = await importDnsName(walletClient, {
+    name: 'taytems.xyz',
+    account: accounts[0],
+    preparedData: await prepareDnsImport(publicClient, { name: 'taytems.xyz' }),
+  })
+  expect(tx).toBeTruthy()
+  const receipt = await waitForTransaction(tx)
+  expect(receipt.status).toBe('success')
+
+  await wait(5000)
+
+  const result = await prepareDnsImport(publicClient, {
+    name: 'lenster.xyz',
+  })
+  const decodedProofs = decodeProofs(result.rrsets)
+  const rootProofs = decodedProofs.filter((x) => x.signature.name === '.')
+  const tldProofs = decodedProofs.filter((x) => x.signature.name === 'xyz')
+  const twoLDProofs = decodedProofs.filter(
+    (x) => x.signature.name === 'lenster.xyz',
+  )
+  const threeLDProofs = decodedProofs.filter(
+    (x) => x.signature.name === '_ens.lenster.xyz',
+  )
+  expect(rootProofs).toHaveLength(0)
+  expect(tldProofs).toHaveLength(0)
+  expect(twoLDProofs.length).toBeGreaterThan(0)
+  expect(threeLDProofs.length).toBeGreaterThan(0)
+})
+it('returns empty rrsets for all known proofs when the last proof is known', async () => {
+  const tx = await importDnsName(walletClient, {
+    name: 'taytems.xyz',
+    account: accounts[0],
+    preparedData: await prepareDnsImport(publicClient, { name: 'taytems.xyz' }),
+  })
+  expect(tx).toBeTruthy()
+  const receipt = await waitForTransaction(tx)
+  expect(receipt.status).toBe('success')
+
+  await wait(5000)
+
+  const result = await prepareDnsImport(publicClient, {
+    name: 'taytems.xyz',
+  })
+  const decodedProofs = decodeProofs(result.rrsets)
+  const rootProofs = decodedProofs.filter((x) => x.signature.name === '.')
+  const tldProofs = decodedProofs.filter((x) => x.signature.name === 'xyz')
+  const twoLDProofs = decodedProofs.filter(
+    (x) => x.signature.name === 'taytems.xyz',
+  )
+  const threeLDProofs = decodedProofs.filter(
+    (x) => x.signature.name === '_ens.taytems.xyz',
+  )
+  expect(rootProofs).toHaveLength(0)
+  expect(tldProofs).toHaveLength(0)
+  expect(twoLDProofs).toHaveLength(0)
+  expect(threeLDProofs).toHaveLength(0)
+})

package/src/functions/dns/prepareDnsImport.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 PrepareDnsImportParameters = {
+  /** 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 PrepareDnsImportReturnType = {
+  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,
+  }))
+
+/**
+ * Creates prepared data for `importDnsName()`
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link PrepareDnsImportParameters}
+ * @returns Prepared data object
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addContracts, prepareDnsImport } from '@ensdomains/ensjs'
+ *
+ * const mainnetWithEns = addContracts([mainnet])
+ * const client = createPublicClient({
+ *   chain: mainnetWithEns,
+ *   transport: http(),
+ * })
+ * const preparedData = await prepareDnsImport(client, {
+ *   name: 'example.eth',
+ * })
+ */
+const prepareDnsImport = async (
+  client: ClientWithEns,
+  {
+    name,
+    endpoint = 'https://cloudflare-dns.com/dns-query',
+  }: PrepareDnsImportParameters,
+): Promise<PrepareDnsImportReturnType> => {
+  // 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 prepareDnsImport

package/src/functions/dns/types.ts

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

package/src/functions/public/_getAbi.ts

@@ -0,0 +1,115 @@
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  hexToBytes,
+  hexToString,
+  type Hex,
+} 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
+}
+
+export type InternalGetAbiReturnType = Prettify<DecodedAbi | null>
+
+// Supported content types as bitwise OR
+// ID 1: JSON
+// ID 2: zlib compressed JSON
+// ID 4: CBOR
+// ID 8: URI
+const supportedContentTypes = BigInt('0xf')
+
+const encode = (
+  _client: ClientWithEns,
+  { name }: InternalGetAbiParameters,
+): SimpleTransactionRequest => {
+  return {
+    to: EMPTY_ADDRESS,
+    data: encodeFunctionData({
+      abi: publicResolverAbiSnippet,
+      functionName: 'ABI',
+      args: [namehash(name), supportedContentTypes],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex,
+): Promise<InternalGetAbiReturnType> => {
+  if (data === '0x') return null
+
+  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 { decodeFirst } = await import('cbor')
+      abiData = await decodeFirst(hexToBytes(encodedAbiData))
+      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,
+  }
+}
+
+const _getAbi = generateFunction({ encode, decode })
+
+export default _getAbi

package/src/functions/public/_getAddr.ts

@@ -0,0 +1,121 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import { decodeFunctionResult, encodeFunctionData, trim, type Hex } from 'viem'
+import { namehash } from '../../utils/normalise.js'
+
+import type { ClientWithEns } from '../../contracts/consts.js'
+import {
+  publicResolverMultiAddrSnippet,
+  publicResolverSingleAddrSnippet,
+} from '../../contracts/publicResolver.js'
+import { CoinFormatterNotFoundError } from '../../errors/public.js'
+import type {
+  DecodedAddr,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { generateFunction } from '../../utils/generateFunction.js'
+
+export type InternalGetAddrParameters = {
+  /** Name to get the address record for */
+  name: string
+  /** Coin to get the address record for, can be either symbol (string) or coinId (number) (default: `60`) */
+  coin?: string | number
+  /** Optionally return raw bytes value of address record (default: false) */
+  bypassFormat?: boolean
+}
+
+export type InternalGetAddrReturnType = Prettify<DecodedAddr | null>
+
+const encode = (
+  _client: ClientWithEns,
+  { name, coin = 60, bypassFormat }: InternalGetAddrParameters,
+): SimpleTransactionRequest => {
+  if (coin === 60 || coin === '60') {
+    return {
+      to: EMPTY_ADDRESS,
+      data: encodeFunctionData({
+        abi: publicResolverSingleAddrSnippet,
+        functionName: 'addr',
+        args: [namehash(name)],
+      }),
+    }
+  }
+
+  if (bypassFormat) {
+    return {
+      to: EMPTY_ADDRESS,
+      data: encodeFunctionData({
+        abi: publicResolverMultiAddrSnippet,
+        functionName: 'addr',
+        args: [namehash(name), BigInt(coin)],
+      }),
+    }
+  }
+  const formatter =
+    typeof coin === 'string' && Number.isNaN(parseInt(coin))
+      ? formatsByName[coin]
+      : formatsByCoinType[typeof coin === 'number' ? coin : parseInt(coin)]
+
+  if (!formatter) throw new CoinFormatterNotFoundError({ coinType: coin })
+
+  return {
+    to: EMPTY_ADDRESS,
+    data: encodeFunctionData({
+      abi: publicResolverMultiAddrSnippet,
+      functionName: 'addr',
+      args: [namehash(name), BigInt(formatter.coinType)],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex,
+  { coin }: InternalGetAddrParameters,
+): Promise<InternalGetAddrReturnType> => {
+  if (data === '0x') return null
+  if (!coin) {
+    coin = 60
+  }
+
+  const formatter =
+    typeof coin === 'string' && Number.isNaN(parseInt(coin))
+      ? formatsByName[coin]
+      : formatsByCoinType[typeof coin === 'number' ? coin : parseInt(coin)]
+
+  let response: Hex
+
+  if (coin === 60 || coin === '60') {
+    response = decodeFunctionResult({
+      abi: publicResolverSingleAddrSnippet,
+      functionName: 'addr',
+      data,
+    })
+  } else {
+    response = decodeFunctionResult({
+      abi: publicResolverMultiAddrSnippet,
+      functionName: 'addr',
+      data,
+    })
+  }
+
+  if (!response) return null
+
+  const trimmed = trim(response)
+  if (trimmed === '0x' || trimmed === '0x0' || trimmed === '0x00') {
+    return null
+  }
+
+  const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), 'hex'))
+
+  if (!decodedAddr) {
+    return null
+  }
+
+  return { id: formatter.coinType, name: formatter.name, value: decodedAddr }
+}
+
+const _getAddr = generateFunction({ encode, decode })
+
+export default _getAddr