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

package/src/GqlManager.ts

@@ -1,11 +1,76 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field',
+  name: {
+    kind: 'Name',
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: any) => {
+  if (node.kind === 'SelectionSet') {
+    const id = node.selections.find((x) => x.name && x.name.value === 'id')
+    const name = node.selections.find((x) => x.name && x.name.value === 'name')
+
+    if (!id && name) {
+      node.selections = [...node.selections, generateSelection('id')]
+      return node
+    }
+  }
+}
+
+export const requestMiddleware = (visit, parse) => (request: any) => {
+  const requestBody = JSON.parse(request.body)
+  const rawQuery = requestBody.query
+  const parsedQuery = parse(rawQuery)
+  const updatedQuery = visit(parsedQuery, { enter })
+  const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body }
+
+  return {
+    ...request,
+    body: JSON.stringify(updatedBody),
+  }
+}
+
+export const responseMiddleware = (traverse) => (response: any) => {
+  traverse(response).forEach(function (responseItem: any) {
+    if (responseItem instanceof Object && responseItem.name) {
+      //Name already in hashed form
+      if (responseItem.name && responseItem.name.includes('[')) {
+        return
+      }
+
+      const hashedName = namehash(responseItem.name)
+      if (responseItem.id !== hashedName) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true })
+      }
+    }
+  })
+  return response
+}
+
 export default class GqlManager {
   public gql: any = () => null
   public client?: any | null = null
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const imported = await import('graphql-request')
-      this.client = new imported.GraphQLClient(url)
+      const [imported, traverse, { visit, parse }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
       this.gql = imported.gql
     } else {
       this.client = null

package/src/contracts/index.ts

@@ -25,7 +25,7 @@ export default class ContractManager {
   private generateContractGetter = <C extends (...args: any) => any>(
     name: ContractName,
     func: C,
-  ) => {
+  ): ((passedProvider?: any, address?: string) => Promise<ReturnType<C>>) => {
     return async (
       passedProvider?: any,
       address?: string,

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 
@@ -10,23 +10,23 @@ beforeAll(async () => {
 describe('batch', () => {
   it('should batch calls together', async () => {
     const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
-      ENSInstance.getAddr.batch('jefflau.eth'),
-      ENSInstance.getName.batch('0x866B3c4994e1416B7C738B9818b31dC246b95eEE'),
+      ENSInstance.getText.batch('with-profile.eth', 'description'),
+      ENSInstance.getAddr.batch('with-profile.eth'),
+      ENSInstance.getName.batch('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'),
     )
     expect(result).toBeTruthy()
     if (result) {
       expect(result[0]).toBe('Hello2')
-      expect(result[1]).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      expect(result[1]).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
       expect(result[2]).toMatchObject({
-        name: 'jefflau.eth',
+        name: 'with-profile.eth',
         match: true,
       })
     }
   })
   it('should batch a single call', async () => {
     const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
+      ENSInstance.getText.batch('with-profile.eth', 'description'),
     )
     expect(result).toBeTruthy()
     if (result) {

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 
@@ -10,12 +10,12 @@ beforeAll(async () => {
 describe('batchWrappers', () => {
   it('should batch calls together', async () => {
     const batch = await ENSInstance.resolverMulticallWrapper.raw([
-      await ENSInstance._getText.raw('jefflau.eth', 'description'),
-      await ENSInstance._getText.raw('jefflau.eth', 'url'),
-      await ENSInstance._getAddr.raw('jefflau.eth'),
+      await ENSInstance._getText.raw('with-profile.eth', 'description'),
+      await ENSInstance._getText.raw('with-profile.eth', 'url'),
+      await ENSInstance._getAddr.raw('with-profile.eth'),
     ])
     const universalResponse = await ENSInstance.universalWrapper(
-      'jefflau.eth',
+      'with-profile.eth',
       batch.data,
     )
     const [batchDecoded] = await ENSInstance.resolverMulticallWrapper.decode(
@@ -26,6 +26,6 @@ describe('batchWrappers', () => {
     const decoded3 = await ENSInstance._getAddr.decode(batchDecoded[2])
     expect(decoded1).toBe('Hello2')
     expect(decoded2).toBe('twitter.com')
-    expect(decoded3).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+    expect(decoded3).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
   })
 })

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

@@ -1,6 +1,7 @@
-import { BigNumber, ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -21,23 +22,19 @@ describe('burnFuses', () => {
     await revert()
   })
   it('should return a burnFuses transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-
-    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
-      cannotUnwrap: true,
-      cannotCreateSubdomain: true,
-      cannotSetTtl: true,
+    const tx = await ENSInstance.burnFuses('wrapped.eth', {
+      fusesToBurn: {
+        cannotUnwrap: true,
+        cannotCreateSubdomain: true,
+        cannotSetTtl: true,
+      },
+      addressOrIndex: accounts[1],
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.getFuses(utils.namehash('parthtejpal.eth'))
-    const fuseBN = result.fuses as BigNumber
-    expect(fuseBN.toHexString()).toBe('0x71')
+    const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+    expect(fuses).toBe(113)
   })
 })

package/src/functions/burnFuses.ts

@@ -1,23 +1,21 @@
-import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { FuseOptions } from '../@types/FuseOptions'
 import generateFuseInput from '../utils/generateFuseInput'
+import { namehash } from '../utils/normalise'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  fusesToBurn: FuseOptions,
+  {
+    fusesToBurn,
+  }: {
+    fusesToBurn: FuseOptions
+  },
 ) {
-  const signer = provider?.getSigner()
-
-  if (!signer) {
-    throw new Error('No signer found')
-  }
-
   const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
-  const namehash = ethers.utils.namehash(name)
+  const hash = namehash(name)
 
   const encodedFuses = generateFuseInput(fusesToBurn)
 
-  return nameWrapper.burnFuses(namehash, encodedFuses)
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
 }

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

@@ -1,6 +1,7 @@
-import { ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,38 +23,29 @@ describe('createSubname', () => {
     await revert()
   })
   it('should allow creating a subname on the registry', async () => {
-    const tx = await ENSInstance.createSubname({
+    const tx = await ENSInstance.createSubname('test.test123.eth', {
       contract: 'registry',
-      name: 'test.parthtejpal.eth',
       owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.test123.eth'))
     expect(result).toBe(accounts[0])
   })
   it('should allow creating a subname on the namewrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.createSubname({
+    const tx = await ENSInstance.createSubname('test.wrapped.eth', {
       contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
       owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(
-      utils.namehash('test.parthtejpal.eth'),
-    )
+    const result = await nameWrapper.ownerOf(namehash('test.wrapped.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/functions/createSubname.ts

@@ -1,33 +1,33 @@
-import { ethers } from 'ethers'
+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 = {
-  name: string
   owner: string
   resolverAddress?: string
   contract: 'registry' | 'nameWrapper'
-  options?: { addressOrIndex?: string | number }
 }
 
 type NameWrapperArgs = {
   contract: 'nameWrapper'
   fuses?: FuseOptions
+  expiry?: Expiry
 } & BaseArgs
 
 type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
-  { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args,
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  name: string,
+  { owner, resolverAddress, contract, ...wrapperArgs }: Args,
 ) {
-  const signer = provider?.getSigner(options?.addressOrIndex)
-
-  if (!signer) {
-    throw new Error('No signer found')
-  }
-
   const labels = name.split('.')
 
   if (labels.length === 1) {
@@ -44,13 +44,13 @@ export default async function (
 
   const label = labels.shift() as string
   const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
-  const parentNodehash = ethers.utils.namehash(labels.join('.'))
+  const parentNodehash = namehash(labels.join('.'))
 
   switch (contract) {
     case 'registry': {
       const registry = (await contracts?.getRegistry()!).connect(signer)
 
-      return registry.setSubnodeRecord(
+      return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
         owner,
@@ -60,19 +60,25 @@ export default async function (
     }
     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.setSubnodeRecord(
+      return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,
         label,
         owner,
         resolverAddress,
         0,
         generatedFuses,
+        expiry,
       )
     }
     default: {

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

@@ -1,6 +1,7 @@
-import { ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -21,51 +22,31 @@ describe('deleteSubname', () => {
     await revert()
   })
   it('should allow deleting a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
+    const tx = await ENSInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      addressOrIndex: 1,
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname(
-      'test.parthtejpal.eth',
-      'registry',
-      { addressOrIndex: 0 },
-    )
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    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 wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname({
-      contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
-    })
-    await createSubnameTx.wait()
-
     const tx = await ENSInstance.deleteSubname(
-      'test.parthtejpal.eth',
-      'nameWrapper',
-      { addressOrIndex: 0 },
+      '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(
-      utils.namehash('test.parthtejpal.eth'),
+      namehash('test.wrapped-with-subnames.eth'),
     )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })

package/src/functions/deleteSubname.ts

@@ -1,19 +1,17 @@
 import { ENSArgs } from '..'
 
 export default async function (
-  {
-    contracts,
-    provider,
-    transferSubname,
-  }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>,
+  { transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>,
   name: string,
-  contract: 'registry' | 'nameWrapper',
-  options?: { addressOrIndex?: string | number },
+  {
+    contract,
+  }: {
+    contract: 'registry' | 'nameWrapper'
+  },
 ) {
-  return transferSubname(
-    name,
+  return transferSubname.populateTransaction(name, {
     contract,
-    '0x0000000000000000000000000000000000000000',
-    options,
-  )
+    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
+}