@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.10

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 (_: any, dnsName: string) {
+  const result = await dnsQuery('TXT', `_ens.${dnsName}`)
+  const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1]
+  return address
+}

package/src/{tests → functions}/getExpiry.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']

package/src/{tests → functions}/getFuses.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -12,7 +12,9 @@ let withWrappedSnapshot: any
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
+    wrappedOwner: accounts[0],
+  })
   await tx.wait()
 
   withWrappedSnapshot = await createSnapshot()
@@ -33,11 +35,10 @@ describe('getFuses', () => {
     expect(result).toBeUndefined()
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
-    const tx = await ENSInstance.createSubname({
+    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
       contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
       owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      addressOrIndex: 0,
     })
     await tx.wait()
 
@@ -56,9 +57,11 @@ describe('getFuses', () => {
   })
   it('should return with other correct fuses', async () => {
     const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
-      cannotUnwrap: true,
-      cannotSetTtl: true,
-      cannotCreateSubdomain: true,
+      fusesToBurn: {
+        cannotUnwrap: true,
+        cannotSetTtl: true,
+        cannotCreateSubdomain: true,
+      },
     })
     await tx.wait()
     const result = await ENSInstance.getFuses('parthtejpal.eth')
@@ -86,8 +89,7 @@ describe('getFuses', () => {
     }
   })
   it('should return correct vulnerability data for a vulnerable node', async () => {
-    const tx = await ENSInstance.createSubname({
-      name: 'test.parthtejpal.eth',
+    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
       owner: accounts[0],
       contract: 'nameWrapper',
     })

package/src/functions/getFuses.ts

@@ -1,6 +1,7 @@
-import { BigNumber, ethers, utils } from 'ethers'
+import { BigNumber, utils } from 'ethers'
 import { ENSArgs } from '..'
 import { testable as fuseEnums } from '../utils/fuses'
+import { namehash } from '../utils/normalise'
 
 const NameSafety = [
   'Safe',
@@ -15,7 +16,7 @@ const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
   return {
     to: nameWrapper.address,
     data: nameWrapper.interface.encodeFunctionData('getFuses', [
-      ethers.utils.namehash(name),
+      namehash(name),
     ]),
   }
 }
@@ -51,7 +52,7 @@ const decode = async (
     if (utils.hexStripZeros(vulnerableNode) !== '0x') {
       name.split('.').forEach((label, index, arr) => {
         const node = arr.slice(index).join('.')
-        const nodehash = utils.namehash(node)
+        const nodehash = namehash(node)
         if (nodehash === vulnerableNode) {
           returnVulnerableNode = node
         }

package/src/{tests → functions}/getHistory.test.ts

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

package/src/{tests → functions}/getName.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']

package/src/{tests → functions}/getNames.test.ts

@@ -1,6 +1,6 @@
 import { ENS } from '..'
 import { OwnedName, Registration } from '../functions/getNames'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

package/src/{tests → functions}/getOwner.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -10,7 +10,9 @@ let accounts: string[]
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
+    wrappedOwner: accounts[0],
+  })
   await tx.wait()
 })
 
@@ -42,6 +44,16 @@ describe('getOwner', () => {
     expect(result?.ownershipLevel).toBe('registrar')
     expect(result?.registrant).toBe(nameWrapperAddress)
   })
+  it('should return the owner of a TLD on the registry', async () => {
+    const result = await ENSInstance.getOwner('eth')
+    const baseRegistrarAddress = (
+      await ENSInstance.contracts!.getBaseRegistrar()
+    ).address
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner?.toLowerCase()).toBe(
+      baseRegistrarAddress.toLowerCase(),
+    )
+  })
   // it('should return registry as the ownership level for an unwrapped subname', async () => {
   //   const result0 = await ENSInstance.getOwner('fleek.eth')
   //   console.log(result0?.owner, accounts[2])

package/src/functions/getOwner.ts

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
+import { namehash as makeNamehash } from '../utils/normalise'
 
 type Owner = {
   registrant?: string
@@ -49,13 +50,13 @@ const raw = async (
   name: string,
   contract?: 'nameWrapper' | 'registry' | 'registrar',
 ) => {
-  const namehash = ethers.utils.namehash(name)
+  const namehash = makeNamehash(name)
   const labels = name.split('.')
 
-  if (contract) {
+  if (contract || labels.length === 1) {
     return await singleContractOwnerRaw(
       { contracts },
-      contract,
+      contract || 'registry',
       namehash,
       labels,
     )
@@ -99,10 +100,11 @@ const decode = async (
   contract?: 'nameWrapper' | 'registry' | 'registrar',
 ): Promise<Owner | undefined> => {
   if (data === null) return
-  if (contract) {
+  const labels = name.split('.')
+  if (contract || labels.length === 1) {
     const singleOwner = singleContractOwnerDecode(data)
     let obj = {
-      ownershipLevel: contract,
+      ownershipLevel: contract || 'registry',
     }
     if (contract === 'registrar') {
       return {
@@ -133,8 +135,6 @@ const decode = async (
     decodedData[2] as ethers.utils.Result | undefined
   )?.[0]
 
-  const labels = name.split('.')
-
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
     // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner

package/src/{tests → functions}/getProfile.test.ts

@@ -1,18 +1,23 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
 })
 
 const checkRecords = (
-  result: Record<string, any> | null,
+  result: Record<string, any> | undefined,
   textLength = 3,
   coinTypeLength = 5,
 ) => {
-  expect(result).toBeTruthy()
+  expect(result).toBeDefined()
   if (result) {
     expect(result.records?.texts).toHaveLength(textLength)
     expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
@@ -22,24 +27,32 @@ const checkRecords = (
   }
 }
 
+jest.setTimeout(20000)
+
 describe('getProfile', () => {
   describe('with an address', () => {
     it('should return a profile object with no other args', async () => {
       const result = await ENSInstance.getProfile(
         '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
       )
-      expect((result as any).name).toBe('jefflau.eth')
-      expect((result as any).address).toBeUndefined()
-      checkRecords(result)
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).address).toBeUndefined()
+        checkRecords(result)
+      }
     })
     it('should return a profile object with specified records', async () => {
       const result = await ENSInstance.getProfile(
         '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
         { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
       )
-      expect((result as any).name).toBe('jefflau.eth')
-      expect((result as any).address).toBeUndefined()
-      checkRecords(result, 2, 3)
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).address).toBeUndefined()
+        checkRecords(result, 2, 3)
+      }
     })
     it('should return a profile object with all of each specified record type', async () => {
       const result = await ENSInstance.getProfile(
@@ -80,11 +93,32 @@ describe('getProfile', () => {
       })
       checkRecords(result)
     })
-    it('should return null for an unregistered name', async () => {
+    it('should return a profile object for a specified resolver', async () => {
+      const result = await ENSInstance.getProfile('saganaki.xyz', {
+        resolverAddress: '0x12299799a50340fb860d276805e78550cbad3de3',
+      })
+      expect(result).toBeDefined()
+      expect(result?.address).toBe('0x157545BfD441453921049998128Ff090c1c11230')
+      expect(result?.resolverAddress).toBe(
+        '0x12299799a50340fb860d276805e78550cbad3de3',
+      )
+    })
+    it('should return undefined for an unregistered name', async () => {
       const result = await ENSInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()
     })
   })
+  describe('with an old resolver', () => {
+    it('should use fallback methods for a name with an older resolver (no multicall)', async () => {
+      const result = await ENSInstance.getProfile('pepeq6.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBe(
+          '0x6308F1c6f283583C8bf8E31Da793B87718b051eD',
+        )
+      }
+    })
+  })
   describe('with an unmigrated name', () => {
     beforeAll(async () => {
       ;({ ENSInstance } = await setup(true))
@@ -95,7 +129,6 @@ describe('getProfile', () => {
       expect(result).toBeTruthy()
       if (result) {
         expect(result.isMigrated).toBe(false)
-        expect(result.message).toBe("Records fetch didn't complete")
       }
     })
   })