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

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/GqlManager.test.ts

@@ -0,0 +1,170 @@
+import traverse from 'traverse'
+import { visit, parse } from 'graphql'
+
+import { requestMiddleware, responseMiddleware, enter } from './GqlManager'
+import { namehash } from './utils/normalise'
+
+describe('GqlManager', () => {
+  const queryWithoutId = `
+query getNames($id: ID!, $expiryDate: Int) {
+    account(id: $id) {
+      registrations(first: 1000, where: { expiryDate_gt: $expiryDate }) {
+        registrationDate
+        expiryDate
+        domain {
+          labelName
+          labelhash
+          name
+          isMigrated
+          parent {
+            name
+          }
+        }
+      }
+      domains(first: 1000) {
+        labelName
+        labelhash
+        name
+        isMigrated
+        parent {
+          name
+        }
+        createdAt
+      }
+    }
+  }
+`
+
+  const mockRequest = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ query: queryWithoutId }),
+  }
+
+  const mockResponse = {
+    data: {
+      account: {
+        registrations: [
+          {
+            registrationDate: '1659245504',
+            expiryDate: '1690781504',
+            domain: {
+              id: '0xb1ccf7f6bb648f39ba48bf80f4a8a4522f474ee7d1edd6ea65f7fa51fe8b1612',
+              labelName: 'randydandy',
+              labelhash:
+                '0x63fd5bfdd0b1eb9f4c33c209b7c3e7dcb87a761d926a65e267f7cb99ee313ddd',
+              name: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+              isMigrated: true,
+              parent: {
+                name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+                invalidName: true,
+              },
+              invalidName: true,
+            },
+          },
+          {
+            registrationDate: '1635284756',
+            expiryDate: '1666841708',
+            domain: {
+              id: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+              labelName: 'randydandy',
+              labelhash:
+                '0x6a877a8d92ad83c8d044d0c5b69aa0da3050f4d653dcc149fca952d6439e4105',
+              name: 'randydandy.eth',
+              isMigrated: true,
+              parent: {
+                name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+                invalidName: true,
+              },
+            },
+          },
+          {
+            registrationDate: '1659250465',
+            expiryDate: '1690786465',
+            domain: {
+              id: '0xaf119e72f050e5acad6b2d97826a7afb45afe9407376a2ab8240b62173b2d7c2',
+              labelName: 'nullbyte',
+              labelhash:
+                '0xc8985f8323b3dc707003a6ef5b379d9e8a058b6d6bcc2cfb307c61ca36920e27',
+              name: '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+              isMigrated: true,
+              parent: {
+                name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+                invalidName: true,
+              },
+              invalidName: true,
+            },
+          },
+        ],
+        domains: [
+          {
+            id: '0xaf119e72f050e5acad6b2d97826a7afb45afe9407376a2ab8240b62173b2d7c2',
+            labelName: 'nullbyte',
+            labelhash:
+              '0xc8985f8323b3dc707003a6ef5b379d9e8a058b6d6bcc2cfb307c61ca36920e27',
+            name: '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            createdAt: '1659250465',
+            invalidName: true,
+          },
+          {
+            id: '0xb1ccf7f6bb648f39ba48bf80f4a8a4522f474ee7d1edd6ea65f7fa51fe8b1612',
+            labelName: 'randydandy',
+            labelhash:
+              '0x63fd5bfdd0b1eb9f4c33c209b7c3e7dcb87a761d926a65e267f7cb99ee313ddd',
+            name: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            createdAt: '1659245504',
+            invalidName: true,
+          },
+          {
+            id: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+            labelName: 'randydandy',
+            labelhash:
+              '0x6a877a8d92ad83c8d044d0c5b69aa0da3050f4d653dcc149fca952d6439e4105',
+            name: 'randydandy.eth',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            createdAt: '1635284756',
+          },
+        ],
+      },
+    },
+    headers: {
+      map: {
+        'content-type': 'application/json',
+      },
+    },
+    status: 200,
+  }
+
+  describe('requestMiddleware', () => {
+    it('should add id to a SelectionSet if name is present and id is not', () => {
+      const result = requestMiddleware(visit, parse)(mockRequest)
+      expect(result.body.includes('id')).toBe(true)
+    })
+  })
+  describe('responseMiddleware', () => {
+    it('should replace name with the namehash when there is an invalid name and id combo', () => {
+      const result = responseMiddleware(traverse)(mockResponse)
+      expect(result.data.account.domains[0].name).toBe(
+        namehash(
+          '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+        ),
+      )
+    })
+  })
+})

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/{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 setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -21,22 +22,23 @@ 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()
 
     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,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.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 setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,38 +23,33 @@ 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()
 
     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 () => {
-    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()
 
     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,13 +2,12 @@ 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
   owner: string
   resolverAddress?: string
   contract: 'registry' | 'nameWrapper'
-  options?: { addressOrIndex?: string | number }
 }
 
 type NameWrapperArgs = {
@@ -19,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) {
@@ -44,13 +38,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,
@@ -66,7 +60,7 @@ export default async function (
           ? generateFuseInput(wrapperArgs.fuses)
           : '0'
 
-      return nameWrapper.setSubnodeRecord(
+      return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,
         label,
         owner,

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,52 +22,51 @@ 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()
 
     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 () => {
-    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()
 
     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/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.populateTransaction(name, {
     contract,
-    '0x0000000000000000000000000000000000000000',
-    options,
-  )
+    address: '0x0000000000000000000000000000000000000000',
+  })
 }