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

package/dist/esm/utils/normalise.js

@@ -1,2 +1,20 @@
+import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils';
 import uts46 from 'idna-uts46-hx/uts46bundle.js';
+const zeros = new Uint8Array(32);
+zeros.fill(0);
 export const normalise = (name) => name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name;
+export const namehash = (inputName) => {
+    let result = zeros;
+    const name = normalise(inputName);
+    if (name) {
+        const labels = name.split('.');
+        for (var i = labels.length - 1; i >= 0; i--) {
+            const labelSha = keccak256(toUtf8Bytes(labels[i]));
+            result = keccak256(concat([result, labelSha]));
+        }
+    }
+    else {
+        result = hexlify(zeros);
+    }
+    return result;
+};

package/dist/esm/utils/registerHelpers.js

@@ -1,6 +1,7 @@
 import { utils } from 'ethers';
 import generateFuseInput from './generateFuseInput';
 import { labelhash } from './labels';
+import { namehash } from './normalise';
 import { generateRecordCallArray } from './recordHelpers';
 export const randomSecret = () => {
     const bytes = Buffer.allocUnsafe(32);
@@ -8,11 +9,9 @@ export const randomSecret = () => {
 };
 export const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
     const label = labelhash(name.split('.')[0]);
-    const namehash = utils.namehash(name);
+    const hash = namehash(name);
     const resolverAddress = resolver.address;
-    const data = records
-        ? generateRecordCallArray(namehash, records, resolver)
-        : [];
+    const data = records ? generateRecordCallArray(hash, records, resolver) : [];
     const secret = randomSecret();
     const fuseData = fuses ? generateFuseInput(fuses) : '0';
     const commitment = _makeCommitment({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.4",
   "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.0",
     "@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",
@@ -75,5 +80,6 @@
   },
   "peerDependencies": {
     "ethers": "*"
-  }
+  },
+  "stableVersion": "3.0.0-alpha.3"
 }

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,6 +1,7 @@
-import { BigNumber, ethers, utils } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -36,7 +37,7 @@ describe('burnFuses', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.getFuses(utils.namehash('parthtejpal.eth'))
+    const result = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
     const fuseBN = result.fuses as BigNumber
     expect(fuseBN.toHexString()).toBe('0x71')
   })

package/src/functions/burnFuses.ts

@@ -1,7 +1,7 @@
-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'>,
@@ -15,9 +15,9 @@ export default async function (
   }
 
   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.burnFuses(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 { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -32,7 +33,7 @@ describe('createSubname', () => {
     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.parthtejpal.eth'))
     expect(result).toBe(accounts[0])
   })
   it('should allow creating a subname on the namewrapper', async () => {
@@ -51,9 +52,7 @@ describe('createSubname', () => {
     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.parthtejpal.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/functions/createSubname.ts

@@ -2,6 +2,7 @@ import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { FuseOptions } from '../@types/FuseOptions'
 import generateFuseInput from '../utils/generateFuseInput'
+import { namehash } from '../utils/normalise'
 
 type BaseArgs = {
   name: string
@@ -44,7 +45,7 @@ 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': {

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 { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -38,7 +39,7 @@ describe('deleteSubname', () => {
     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.parthtejpal.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
   it('should allow deleting a subname on the nameWrapper', async () => {
@@ -64,9 +65,7 @@ describe('deleteSubname', () => {
     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.parthtejpal.eth'))
     expect(result).toBe('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']

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']
@@ -42,6 +42,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