@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/src/functions/createSubname.ts

@@ -0,0 +1,88 @@
+import { BigNumber, ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+import { namehash } from '../utils/normalise'
+import { Expiry, makeExpiry } from '../utils/wrapperExpiry'
+
+type BaseArgs = {
+  owner: string
+  resolverAddress?: string
+  contract: 'registry' | 'nameWrapper'
+}
+
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  fuses?: FuseOptions
+  expiry?: Expiry
+} & BaseArgs
+
+type Args = BaseArgs | NameWrapperArgs
+
+export default async function (
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  name: string,
+  { owner, resolverAddress, contract, ...wrapperArgs }: Args,
+) {
+  const labels = name.split('.')
+
+  if (labels.length === 1) {
+    throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs')
+  }
+
+  if ('fuses' in wrapperArgs && contract === 'registry') {
+    throw new Error('Fuses can only be set on a wrapped name')
+  }
+
+  if (!resolverAddress) {
+    resolverAddress = (await contracts?.getPublicResolver())!.address
+  }
+
+  const label = labels.shift() as string
+  const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
+  const parentNodehash = namehash(labels.join('.'))
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry()!).connect(signer)
+
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        owner,
+        resolverAddress,
+        0,
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      const expiry: BigNumber = await makeExpiry(
+        { getExpiry },
+        name,
+        'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined,
+      )
+
+      const generatedFuses =
+        'fuses' in wrapperArgs && wrapperArgs.fuses
+          ? generateFuseInput(wrapperArgs.fuses)
+          : '0'
+
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        owner,
+        resolverAddress,
+        0,
+        generatedFuses,
+        expiry,
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/deleteSubname.test.ts

@@ -0,0 +1,53 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('deleteSubname', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should allow deleting a subname on the registry', async () => {
+    const tx = await ENSInstance.deleteSubname('test.with-subnames.eth', {
+      contract: 'registry',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+  it('should allow deleting a subname on the nameWrapper', async () => {
+    const tx = await ENSInstance.deleteSubname(
+      'test.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        addressOrIndex: 1,
+      },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+})

package/src/functions/deleteSubname.ts

@@ -0,0 +1,17 @@
+import { ENSArgs } from '..'
+
+export default async function (
+  { transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>,
+  name: string,
+  {
+    contract,
+  }: {
+    contract: 'registry' | 'nameWrapper'
+  },
+) {
+  return transferSubname.populateTransaction(name, {
+    contract,
+    owner: '0x0000000000000000000000000000000000000000',
+    signer,
+  })
+}

package/src/functions/getDNSOwner.test.ts

@@ -0,0 +1,118 @@
+import nock from 'nock'
+import fetch from 'node-fetch'
+import getDNSOwner, { encodeURLParams } from './getDNSOwner'
+
+function hex_decode(string: string) {
+  let bytes: any[] = []
+  string.replace(/../g, function (pair) {
+    bytes.push(parseInt(pair, 16))
+  })
+  return new Uint8Array(bytes).buffer
+}
+
+describe('encodeURLParams', () => {
+  it('should encodeURLParams', () => {
+    const p: { [key: string]: string } = {
+      a: 'b',
+      c: 'd',
+    }
+    const expected = 'a=b&c=d'
+    const actual = encodeURLParams(p)
+    expect(actual).toEqual(expected)
+  })
+})
+
+describe('getDNSOwner', () => {
+  beforeAll(() => {
+    global.fetch = fetch
+  })
+  afterAll(() => {
+    global.fetch = undefined
+  })
+  it('should return the address from the result of a dnsQuery', async () => {
+    const dnsName = 'brantly.xyz'
+
+    const scope = nock('https://cloudflare-dns.com:443', {
+      encodedQueryParams: true,
+    })
+      .get('/dns-query')
+      .query((queryObject) => {
+        return (
+          queryObject.ct === 'application/dns-udpwireformat' &&
+          queryObject.dns ===
+            'AAEBAAABAAAAAAABBF9lbnMHYnJhbnRseQN4eXoAABAAAQAAKRAAAACAAAAA'
+        )
+      })
+      .reply(
+        200,
+        Buffer.from(
+          hex_decode(
+            '000181a00001000200000001045f656e73076272616e746c790378797a0000100001c00c0010000100000e10002d2c613d307839383331313033303936323044393131373331416330393332323139616630363039316236373434c00c002e000100000e10009f0010080300000e1062df366962c23569d89d076272616e746c790378797a0039c894ca1d7a60c1356e478066d39961a78ec1edbe62e1eb0f13d7947bb72097654648dc79be075ca32625f02e60267f45e88d7c05e9c3ec0cf21ab2dca67a8fbeb8e995644726357628446b888a144cafef5cbfca120c6511fe36de9d3c62dee27680825190c5404ca503904b98dbf62d9122f6fda393dc04b14a89ceb68c7a00002904d0000080000000',
+          ),
+        ),
+        [
+          'Server',
+          'cloudflare',
+          'Date',
+          'Wed, 06 Jul 2022 23:37:28 GMT',
+          'Content-Type',
+          'application/dns-message',
+          'Connection',
+          'close',
+          'Access-Control-Allow-Origin',
+          '*',
+          'Content-Length',
+          '273',
+          'CF-RAY',
+          '726c2b1d3bab6b74-TPE',
+        ],
+      )
+    expect(await getDNSOwner({}, dnsName)).toEqual(
+      '0x983110309620D911731Ac0932219af06091b6744',
+    )
+  })
+  it('should throw if there is an error in the DNS query', async () => {
+    const dnsName = 'nick.xyz'
+
+    const scope = nock('https://cloudflare-dns.com:443', {
+      encodedQueryParams: true,
+    })
+      .get('/dns-query')
+      .query((queryObject) => {
+        return (
+          queryObject.ct === 'application/dns-udpwireformat' &&
+          queryObject.dns ===
+            'AAEBAAABAAAAAAABBF9lbnMEbmljawN4eXoAABAAAQAAKRAAAACAAAAA'
+        )
+      })
+      .reply(
+        200,
+        Buffer.from(
+          hex_decode(
+            '000181830001000000010001045f656e73046e69636b0378797a0000100001c0110006000100000258003b046e7337310d646f6d61696e636f6e74726f6c03636f6d0003646e73056a6f6d6178036e6574007876d1800000708000001c2000093a800000025800002904d0000080000000',
+          ),
+        ),
+        [
+          'Server',
+          'cloudflare',
+          'Date',
+          'Wed, 06 Jul 2022 23:37:28 GMT',
+          'Content-Type',
+          'application/dns-message',
+          'Connection',
+          'close',
+          'Access-Control-Allow-Origin',
+          '*',
+          'Content-Length',
+          '273',
+          'CF-RAY',
+          '726c2b1d3bab6b74-TPE',
+        ],
+      )
+    try {
+      await getDNSOwner({}, dnsName)
+    } catch (error) {
+      expect(error.message).toEqual('DNS query failed: NXDOMAIN')
+    }
+  })
+})

package/src/functions/getDNSOwner.ts

@@ -0,0 +1,61 @@
+import * as packet from 'dns-packet'
+
+export function encodeURLParams(p: { [key: string]: string }): string {
+  return Object.entries(p)
+    .map((kv) => kv.map(encodeURIComponent).join('='))
+    .join('&')
+}
+
+export const getDNS = async (q: packet.Packet): Promise<packet.Packet> => {
+  const response = await global.fetch(
+    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+      ct: 'application/dns-udpwireformat',
+      dns: packet.encode(q)?.toString('base64'),
+      ts: Date.now().toString(),
+    })}`,
+  )
+  const arrayBuffer = await response.arrayBuffer()
+  // @ts-ignore:next-line
+  const fromArrayBuffer = Buffer.from(arrayBuffer);
+  return packet.decode(fromArrayBuffer)
+}
+
+export const dnsQuery = async (
+  qtype: string,
+  qname: string,
+): Promise<packet.Packet> => {
+  const query: packet.Packet = {
+    type: 'query',
+    id: 1,
+    flags: packet.RECURSION_DESIRED,
+    questions: [
+      {
+        type: qtype,
+        class: 'IN',
+        name: qname,
+      },
+    ],
+    additionals: [
+      {
+        type: 'OPT',
+        class: 'IN',
+        name: '.',
+        udpPayloadSize: 4096,
+        flags: packet.DNSSEC_OK,
+      },
+    ],
+    answers: [],
+  }
+
+  const response = await getDNS(query)
+  if (response.rcode !== 'NOERROR') {
+    throw new Error(`DNS query failed: ${response.rcode}`)
+  }
+  return response
+}
+
+export default async function (_: any, dnsName: string) {
+  const result = await dnsQuery('TXT', `_ens.${dnsName}`)
+  const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1]
+  return address
+}

package/src/functions/getExpiry.test.ts

@@ -0,0 +1,59 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getExpiry', () => {
+  it('should get the expiry for a .eth name with no other args', async () => {
+    const result = await ENSInstance.getExpiry('with-profile.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(7776000000)
+    }
+  })
+  it('should get the expiry for a wrapped name', async () => {
+    const result = await ENSInstance.getExpiry('wrapped.eth', {
+      contract: 'nameWrapper',
+    })
+
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(null)
+    }
+  })
+  it('should throw an error for a non .eth name if not wrapped', async () => {
+    try {
+      await ENSInstance.getExpiry('sub.with-profile.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+  it('should throw an error for a non .eth name if registrar is specified', async () => {
+    try {
+      await ENSInstance.getExpiry('sub.with-profile.eth', {
+        contract: 'registrar',
+      })
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+})

package/src/functions/getExpiry.ts

@@ -0,0 +1,141 @@
+import { BigNumber } from 'ethers'
+import { solidityKeccak256 } from 'ethers/lib/utils'
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+type ContractOption = 'registrar' | 'nameWrapper'
+
+type Args = {
+  contract?: ContractOption
+}
+
+const getRegistrarExpiry = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  labels: string[],
+) => {
+  if (labels.length > 2 || labels[1] !== 'eth') {
+    throw new Error('Only .eth names have expiry dates on the registrar')
+  }
+
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
+  const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
+    solidityKeccak256(['string'], [labels[0]]),
+  ])
+  const gracePeriodCall =
+    baseRegistrar.interface.encodeFunctionData('GRACE_PERIOD')
+
+  return multicallWrapper.raw([
+    {
+      to: baseRegistrar.address,
+      data: expiryCall,
+    },
+    {
+      to: baseRegistrar.address,
+      data: gracePeriodCall,
+    },
+  ])
+}
+
+const getWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  labels: string[],
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+    namehash(labels.join('.')),
+  ])
+  return {
+    to: nameWrapper.address,
+    data: expiryCall,
+  }
+}
+
+const getContractToUse = (
+  contract: ContractOption | undefined,
+  labels: string[],
+) => {
+  if (contract) return contract
+  if (labels.length === 2 && labels[1] === 'eth') {
+    return 'registrar'
+  }
+  return 'nameWrapper'
+}
+
+const raw = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+  { contract }: Args = {},
+) => {
+  const labels = name.split('.')
+
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? getWrapperExpiry(ensArgs, labels)
+    : getRegistrarExpiry(ensArgs, labels)
+}
+
+const decodeRegistrarExpiry = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+) => {
+  const result = await multicallWrapper.decode(data)
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+  try {
+    const [nameExpires] = baseRegistrar.interface.decodeFunctionResult(
+      'nameExpires',
+      result[0].returnData,
+    )
+    const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult(
+      'GRACE_PERIOD',
+      result[1].returnData,
+    )
+    return {
+      expiry: nameExpires > 0 ? new Date(nameExpires * 1000) : null,
+      gracePeriod: (gracePeriod as BigNumber).toNumber() * 1000,
+    }
+  } catch {
+    return
+  }
+}
+
+const decodeWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [_owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getData',
+      data,
+    )
+    return {
+      expiry: new Date(expiry * 1000),
+      gracePeriod: null,
+    }
+  } catch {
+    return
+  }
+}
+
+const decode = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+  name: string,
+  { contract }: Args = {},
+) => {
+  if (data === null) return
+
+  const labels = name.split('.')
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? decodeWrapperExpiry(ensArgs, data)
+    : decodeRegistrarExpiry(ensArgs, data)
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getFuses.test.ts

@@ -0,0 +1,82 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+let withWrappedSnapshot: any
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
+  accounts = await provider.listAccounts()
+
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterEach(async () => {
+  await revert(withWrappedSnapshot)
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getFuses', () => {
+  it('should return null for an unwrapped name', async () => {
+    const result = await ENSInstance.getFuses('with-profile.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await ENSInstance.getFuses('test.wrapped-with-subnames.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj.canDoEverything).toBe(true)
+      expect(
+        Object.values(result.fuseObj).reduce(
+          (prev, curr) => (curr ? prev + 1 : prev),
+          0,
+        ),
+      ).toBe(1)
+      expect(result.rawFuses.toHexString()).toBe('0x00')
+    }
+  })
+  it('should return with other correct fuses', async () => {
+    const tx = await ENSInstance.burnFuses('wrapped.eth', {
+      fusesToBurn: {
+        cannotUnwrap: true,
+        cannotSetTtl: true,
+        cannotCreateSubdomain: true,
+      },
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getFuses('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj).toMatchObject({
+        cannotUnwrap: true,
+        cannotBurnFuses: false,
+        cannotTransfer: false,
+        cannotSetResolver: false,
+        cannotSetTtl: true,
+        cannotCreateSubdomain: true,
+        parentCannotControl: true,
+        canDoEverything: false,
+      })
+      expect(result.rawFuses.toHexString()).toBe('0x71')
+    }
+  })
+  it('should return correct expiry', async () => {
+    const result = await ENSInstance.getFuses('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+    }
+  })
+})

package/src/functions/getFuses.ts

@@ -0,0 +1,70 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+import { testable as fuseEnums } from '../utils/fuses'
+import { namehash } from '../utils/normalise'
+
+const NameSafety = [
+  'Safe',
+  'RegistrantNotWrapped',
+  'ControllerNotWrapped',
+  'SubdomainReplacementAllowed',
+  'Expired',
+]
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData('getFuses', [
+      namehash(name),
+    ]),
+  }
+}
+
+const decode = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+  name: string,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getFuses',
+      data,
+    )
+
+    const fuses = BigNumber.from(_fuses)
+
+    const fuseObj = Object.fromEntries(
+      Object.keys(fuseEnums).map((fuseEnum) => [
+        fuseEnum
+          .toLowerCase()
+          .replace(/([-_][a-z])/g, (group: string) =>
+            group.toUpperCase().replace('-', '').replace('_', ''),
+          ),
+        fuses.and(fuseEnums[fuseEnum as keyof typeof fuseEnums]).gt(0),
+      ]),
+    )
+
+    if (fuses.eq(0)) {
+      fuseObj.canDoEverything = true
+    } else {
+      fuseObj.canDoEverything = false
+    }
+
+    const expiryDate = new Date(expiry * 1000)
+
+    return {
+      fuseObj,
+      expiryDate,
+      rawFuses: fuses,
+    }
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}