@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.3

package/src/functions/getDNSOwner.test.ts

@@ -0,0 +1,122 @@
+import * as packet from 'dns-packet'
+import fetch from 'node-fetch'
+import nock from 'nock'
+
+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) => {
+        console.log('queryObject: ', 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) => {
+        console.log('queryObject: ', 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 (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,37 @@
+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 name', async () => {
+    const result = await ENSInstance.getExpiry('jefflau.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(7776000000)
+    }
+  })
+  it('should throw an error for a non .eth name', async () => {
+    try {
+      await ENSInstance.getExpiry('sub.jefflau.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+})

package/src/functions/getExpiry.ts

@@ -0,0 +1,63 @@
+import { BigNumber } from 'ethers'
+import { solidityKeccak256 } from 'ethers/lib/utils'
+import { ENSArgs } from '..'
+
+const raw = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
+  const labels = name.split('.')
+
+  if (labels.length > 2 || labels[1] !== 'eth') {
+    throw new Error('Only .eth names have expiry dates')
+  }
+
+  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 decode = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+) => {
+  if (data === null) return
+  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
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getFuses.test.ts

@@ -0,0 +1,103 @@
+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()
+  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+  await tx.wait()
+
+  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('jefflau.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
+    const tx = await ENSInstance.createSubname({
+      contract: 'nameWrapper',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getFuses('test.parthtejpal.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('parthtejpal.eth', {
+      cannotUnwrap: true,
+      cannotSetTtl: true,
+      cannotCreateSubdomain: true,
+    })
+    await tx.wait()
+    const result = await ENSInstance.getFuses('parthtejpal.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 vulnerability data for an invulnerable node', async () => {
+    const result = await ENSInstance.getFuses('parthtejpal.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.vulnerability).toBe('Safe')
+      expect(result.vulnerableNode).toBeNull()
+    }
+  })
+  it('should return correct vulnerability data for a vulnerable node', async () => {
+    const tx = await ENSInstance.createSubname({
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      contract: 'nameWrapper',
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.vulnerability).toBe('SubdomainReplacementAllowed')
+      expect(result.vulnerableNode).toBe('parthtejpal.eth')
+    }
+  })
+})

package/src/functions/getFuses.ts

@@ -0,0 +1,76 @@
+import { BigNumber, utils } 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, vulnerability, vulnerableNode] =
+      nameWrapper.interface.decodeFunctionResult('getFuses', data)
+
+    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
+    }
+
+    let returnVulnerableNode: string | null = null
+    if (utils.hexStripZeros(vulnerableNode) !== '0x') {
+      name.split('.').forEach((label, index, arr) => {
+        const node = arr.slice(index).join('.')
+        const nodehash = namehash(node)
+        if (nodehash === vulnerableNode) {
+          returnVulnerableNode = node
+        }
+      })
+    }
+
+    return {
+      fuseObj,
+      vulnerability: NameSafety[vulnerability] || vulnerability,
+      vulnerableNode: returnVulnerableNode,
+      rawFuses: fuses as BigNumber,
+    }
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getHistory.test.ts

@@ -0,0 +1,101 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+  jest.setTimeout(20000)
+})
+
+describe('getHistory', () => {
+  let textEventsWithValue: any[]
+
+  it('should return null for a non-existent name', async () => {
+    const result = await ENSInstance.getHistory('test123123cool.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return the history of a name', async () => {
+    const result = await ENSInstance.getHistory('jefflau.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).toHaveProperty('registration')
+    }
+  })
+  describe('getHistoryWithDetail', () => {
+    it('should return null for a non-existent name', async () => {
+      const result = await ENSInstance.getHistoryWithDetail(
+        'test123123cool.eth',
+      )
+      expect(result).toBeUndefined()
+    })
+    it('should return the history of a name with TextChanged event detail', async () => {
+      const result = await ENSInstance.getHistoryWithDetail('jefflau.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        const textEvents = result.resolver.filter(
+          (x) => x.type === 'TextChanged',
+        )
+        textEvents.forEach((event) =>
+          expect(event.data).toHaveProperty('value'),
+        )
+        textEventsWithValue = textEvents
+      }
+    })
+  })
+  describe('getHistoryDetailForTransactionHash', () => {
+    it('should throw an error for an invalid transaction hash', async () => {
+      try {
+        await ENSInstance.getHistoryDetailForTransactionHash('0x234')
+        expect(false).toBeTruthy()
+      } catch (error) {
+        expect((error as any).message).toContain('invalid hash')
+      }
+    })
+    it('should return null for a transaction hash with no text events', async () => {
+      const result = await ENSInstance.getHistoryDetailForTransactionHash(
+        '0x0fd7b555e3076ef38dbbe2e40deefe44c9a0530d43f6b3f60dbed4ba49d229b7',
+      )
+      expect(result).toBeUndefined()
+    })
+    it('should return single item for a given transaction hash with one event', async () => {
+      const eventToUse = textEventsWithValue[0]
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        eventToUse.transactionHash,
+      )) as { key: any; value: any }[]
+      expect(result).toHaveLength(1)
+      if (result) {
+        expect(result[0]).toMatchObject(eventToUse.data)
+      }
+    })
+    it('should return multiple items for a given transaction hash with multiple events', async () => {
+      const hash =
+        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
+      const dataArr = [
+        { key: 'description', value: 'Not so super description' },
+        { key: 'url', value: 'facebook.com' },
+      ]
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        hash,
+      )) as { key: any; value: any }[]
+      expect(result).toHaveLength(dataArr.length)
+      if (result) {
+        result.forEach((item, index) =>
+          expect(item).toMatchObject(dataArr[index]),
+        )
+      }
+    })
+    it('should return a single item when an index is specified for a hash', async () => {
+      const hash =
+        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
+      const data = { key: 'url', value: 'facebook.com' }
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        hash,
+        1,
+      )) as { key: any; value: any }
+      expect(result).toMatchObject(data)
+    })
+  })
+})