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

package/src/functions/getDNSOwner.test.ts

@@ -1,122 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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', {
-    wrappedOwner: 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('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      owner: accounts[0],
-      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', {
-      fusesToBurn: {
-        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('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

@@ -1,76 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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)
-    })
-  })
-})