@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.5",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -27,13 +27,16 @@
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",
-    "test": "jest --run-in-band src/tests",
+    "test": "jest --run-in-band",
+    "test:watch": "jest --watch --run-in-band",
     "test:specific": "ts-node --files ",
     "clean": "rm -rf ./dist ./README.md ./LICENSE",
     "build:esm": "tsc --project tsconfig.esm.json",
     "build:cjs": "tsc --project tsconfig.cjs.json",
     "build": "yarn clean && yarn build:esm && yarn build:cjs",
-    "prepublish": "yarn build && cp ../../{README.md,LICENSE} ./"
+    "prepublish": "yarn build && cp ../../{README.md,LICENSE} ./",
+    "remove-stableVersion": "ex -c '%s/,\\n\\s\\+\"stableVersion\".*\"//g' -cwq ./package.json",
+    "version:create": "yarn remove-stableVersion && yarn version"
   },
   "packageManager": "yarn@3.2.0",
   "dependencies": {
@@ -48,7 +51,7 @@
   },
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-test-env": "0.2.0",
+    "@ensdomains/ens-test-env": "0.1.2",
     "@ethersproject/abi": "^5.6.0",
     "@ethersproject/providers": "^5.6.2",
     "@nomiclabs/hardhat-ethers": "^2.0.5",
@@ -66,6 +69,8 @@
     "jest": "^27.5.1",
     "jest-environment-node": "^27.5.1",
     "jest-localstorage-mock": "^2.4.21",
+    "nock": "^13.2.8",
+    "node-fetch": "^3.2.6",
     "solc": "^0.8.13",
     "ts-jest": "^27.1.4",
     "ts-node": "^10.7.0",
@@ -76,5 +81,5 @@
   "peerDependencies": {
     "ethers": "*"
   },
-  "stableVersion": "3.0.0-alpha.1"
+  "stableVersion": "3.0.0-alpha.4"
 }

package/src/@types/dns-packet/index.d.ts

@@ -0,0 +1,114 @@
+declare module 'dns-packet' {
+    const AUTHORITATIVE_ANSWER: number
+    const TRUNCATED_RESPONSE: number
+    const RECURSION_DESIRED: number
+    const RECURSION_AVAILABLE: number
+    const AUTHENTIC_DATA: number
+    const CHECKING_DISABLED: number
+    const DNSSEC_OK: number
+     
+   interface decoder<T> {
+     (buf: Buffer, offset?: number): T
+     bytes: number;
+   }
+ 
+   const decode: decoder<Packet>;
+ 
+   interface encoder<T> {
+     (packet: T, buf?: Buffer, offset?: number): Buffer
+     bytes: number;
+   }
+ 
+   const encode: encoder<Packet>;
+ 
+   interface Packet {
+     id?: number
+     type: 'query' | 'response'
+     flags?: number
+     rcode?: string
+     questions: Question[]
+     answers?: Answer[]
+     authorities?: Answer[]
+     additionals?: Answer[]
+   }
+     
+   interface Question {
+     type: string
+     class: string
+     name: string
+   }
+ 
+   interface AnswerBase {
+     type: string
+     class: string
+     name: string
+     ttl?: number
+   }
+ 
+   interface A extends AnswerBase {
+     type: 'A'
+     data: string
+   }
+ 
+   interface Dnskey extends AnswerBase {
+     type: 'DNSKEY'
+     data: {
+       flags: number
+       algorithm: number
+       key: Buffer
+     }
+   }
+ 
+   interface Ds extends AnswerBase {
+     type: 'DS'
+     data: {
+       keyTag: number
+       algorithm: number
+       digestType: number
+       digest: Buffer
+     }
+   }
+ 
+   interface Opt extends AnswerBase {
+     type: 'OPT'
+     udpPayloadSize?: number
+     extendedRcode?: number
+     ednsVersion?: number
+     flags?: number
+     data?: any
+   }
+ 
+   interface Rrsig extends AnswerBase {
+     type: 'RRSIG'
+     data: {
+       typeCovered: string
+       algorithm: number
+       labels: number
+       originalTTL: number
+       expiration: number
+       inception: number
+       keyTag: number
+       signersName: string
+       signature: Buffer
+     }
+   }
+ 
+   interface Rtxt extends AnswerBase {
+     type: 'TXT'
+     data: Buffer[]
+   }
+ 
+   type Answer = A|Dnskey|Ds|Opt|Rrsig|Rtxt
+ 
+   interface Encodable<T> {
+     decode: decoder<T>
+     encode: encoder<T>
+   }
+ 
+   const record: (type: string) => Encodable<Answer>
+   const answer: Encodable<Answer>
+   const dnskey: Encodable<Dnskey['data']>
+   const name: Encodable<string>
+   const rrsig: Encodable<Rrsig['data']>
+ }
+ 

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
 

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
 

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

@@ -1,7 +1,7 @@
 import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,16 +22,17 @@ describe('burnFuses', () => {
     await revert()
   })
   it('should return a burnFuses transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+    })
     await wrapNameTx.wait()
 
     const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
-      cannotUnwrap: true,
-      cannotCreateSubdomain: true,
-      cannotSetTtl: true,
+      fusesToBurn: {
+        cannotUnwrap: true,
+        cannotCreateSubdomain: true,
+        cannotSetTtl: true,
+      },
     })
     expect(tx).toBeTruthy()
     await tx.wait()

package/src/functions/burnFuses.ts

@@ -4,16 +4,14 @@ 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 hash = namehash(name)
 

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -23,11 +23,10 @@ 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.parthtejpal.eth', {
       contract: 'registry',
-      name: 'test.parthtejpal.eth',
       owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      addressOrIndex: 0,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -37,16 +36,14 @@ describe('createSubname', () => {
     expect(result).toBe(accounts[0])
   })
   it('should allow creating a subname on the namewrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+    })
     await wrapNameTx.wait()
-    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,
     })
     expect(tx).toBeTruthy()
     await tx.wait()

package/src/functions/createSubname.ts

@@ -5,11 +5,9 @@ import generateFuseInput from '../utils/generateFuseInput'
 import { namehash } from '../utils/normalise'
 
 type BaseArgs = {
-  name: string
   owner: string
   resolverAddress?: string
   contract: 'registry' | 'nameWrapper'
-  options?: { addressOrIndex?: string | number }
 }
 
 type NameWrapperArgs = {
@@ -20,15 +18,10 @@ type NameWrapperArgs = {
 type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
-  { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  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) {

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,19 +22,20 @@ describe('deleteSubname', () => {
     await revert()
   })
   it('should allow deleting a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
-      contract: 'registry',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
-    })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname(
+    const createSubnameTx = await ENSInstance.createSubname(
       'test.parthtejpal.eth',
-      'registry',
-      { addressOrIndex: 0 },
+      {
+        contract: 'registry',
+        owner: accounts[0],
+        addressOrIndex: 0,
+      },
     )
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
+      contract: 'registry',
+      addressOrIndex: 0,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -43,24 +44,24 @@ describe('deleteSubname', () => {
     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 },
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname(
+    await wrapNameTx.wait()
+    const createSubnameTx = await ENSInstance.createSubname(
       'test.parthtejpal.eth',
-      'nameWrapper',
-      { addressOrIndex: 0 },
+      {
+        contract: 'nameWrapper',
+        owner: accounts[0],
+        addressOrIndex: 0,
+      },
     )
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
+      contract: 'nameWrapper',
+      addressOrIndex: 0,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 

package/src/functions/deleteSubname.ts

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

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/{tests → functions}/getHistory.test.ts

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