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

package/src/functions/commitName.ts

@@ -0,0 +1,36 @@
+import { ENSArgs } from '..'
+import { CommitmentParams, makeCommitment } from '../utils/registerHelpers'
+
+type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+  resolverAddress?: string
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, ...params }: Params,
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD registrations are supported')
+
+  const controller = await contracts!.getEthRegistrarController()
+  const resolver = await contracts!.getPublicResolver(
+    undefined,
+    resolverAddress,
+  )
+  const { secret, commitment, wrapperExpiry } = makeCommitment({
+    name,
+    resolver,
+    ...params,
+  })
+
+  return {
+    ...(await controller.populateTransaction.commit(commitment)),
+    customData: {
+      secret,
+      commitment,
+      wrapperExpiry,
+    },
+  }
+}

package/src/functions/createSubname.test.ts

@@ -23,33 +23,29 @@ describe('createSubname', () => {
     await revert()
   })
   it('should allow creating a subname on the registry', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.createSubname('test.test123.eth', {
       contract: 'registry',
       owner: accounts[0],
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.createSubname('test.wrapped.eth', {
       contract: 'nameWrapper',
       owner: accounts[0],
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(namehash('test.wrapped.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/functions/createSubname.ts

@@ -1,8 +1,9 @@
-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 = {
   owner: string
@@ -13,12 +14,17 @@ type BaseArgs = {
 type NameWrapperArgs = {
   contract: 'nameWrapper'
   fuses?: FuseOptions
+  expiry?: Expiry
 } & BaseArgs
 
 type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
   { owner, resolverAddress, contract, ...wrapperArgs }: Args,
 ) {
@@ -54,6 +60,11 @@ 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
@@ -67,6 +78,7 @@ export default async function (
         resolverAddress,
         0,
         generatedFuses,
+        expiry,
       )
     }
     default: {

package/src/functions/deleteSubname.test.ts

@@ -22,51 +22,32 @@ describe('deleteSubname', () => {
     await revert()
   })
   it('should allow deleting a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
+    const tx = await ENSInstance.deleteSubname(
+      'test.wrapped-with-subnames.eth',
       {
         contract: 'nameWrapper',
-        owner: accounts[0],
-        addressOrIndex: 0,
+        addressOrIndex: 1,
       },
     )
-    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(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 })

package/src/functions/deleteSubname.ts

@@ -1,7 +1,7 @@
 import { ENSArgs } from '..'
 
 export default async function (
-  { transferSubname }: ENSArgs<'transferSubname'>,
+  { transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>,
   name: string,
   {
     contract,
@@ -11,6 +11,7 @@ export default async function (
 ) {
   return transferSubname.populateTransaction(name, {
     contract,
-    address: '0x0000000000000000000000000000000000000000',
+    owner: '0x0000000000000000000000000000000000000000',
+    signer,
   })
 }

package/src/functions/getDNSOwner.test.ts

@@ -1,7 +1,5 @@
-import * as packet from 'dns-packet'
-import fetch from 'node-fetch'
 import nock from 'nock'
-
+import fetch from 'node-fetch'
 import getDNSOwner, { encodeURLParams } from './getDNSOwner'
 
 function hex_decode(string: string) {
@@ -39,7 +37,6 @@ describe('getDNSOwner', () => {
     })
       .get('/dns-query')
       .query((queryObject) => {
-        console.log('queryObject: ', queryObject)
         return (
           queryObject.ct === 'application/dns-udpwireformat' &&
           queryObject.dns ===
@@ -82,7 +79,6 @@ describe('getDNSOwner', () => {
     })
       .get('/dns-query')
       .query((queryObject) => {
-        console.log('queryObject: ', queryObject)
         return (
           queryObject.ct === 'application/dns-udpwireformat' &&
           queryObject.dns ===

package/src/functions/getExpiry.test.ts

@@ -17,8 +17,8 @@ afterAll(async () => {
 })
 
 describe('getExpiry', () => {
-  it('should get the expiry for a name', async () => {
-    const result = await ENSInstance.getExpiry('jefflau.eth')
+  it('should get the expiry for a .eth name with no other args', async () => {
+    const result = await ENSInstance.getExpiry('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       const { expiry, gracePeriod } = result
@@ -26,9 +26,31 @@ describe('getExpiry', () => {
       expect(gracePeriod).toBe(7776000000)
     }
   })
-  it('should throw an error for a non .eth name', async () => {
+  it('should get the expiry for a wrapped name', async () => {
+    const result = await ENSInstance.getExpiry('wrapped.eth', {
+      contract: 'nameWrapper',
+    })
+
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(null)
+    }
+  })
+  it('should throw an error for a non .eth name if not wrapped', async () => {
+    try {
+      await ENSInstance.getExpiry('sub.with-profile.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+  it('should throw an error for a non .eth name if registrar is specified', async () => {
     try {
-      await ENSInstance.getExpiry('sub.jefflau.eth')
+      await ENSInstance.getExpiry('sub.with-profile.eth', {
+        contract: 'registrar',
+      })
       expect(false).toBeTruthy()
     } catch {
       expect(true).toBeTruthy()

package/src/functions/getExpiry.ts

@@ -1,19 +1,24 @@
 import { BigNumber } from 'ethers'
 import { solidityKeccak256 } from 'ethers/lib/utils'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
-const raw = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
-) => {
-  const baseRegistrar = await contracts?.getBaseRegistrar()!
+type ContractOption = 'registrar' | 'nameWrapper'
 
-  const labels = name.split('.')
+type Args = {
+  contract?: ContractOption
+}
 
+const getRegistrarExpiry = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  labels: string[],
+) => {
   if (labels.length > 2 || labels[1] !== 'eth') {
-    throw new Error('Only .eth names have expiry dates')
+    throw new Error('Only .eth names have expiry dates on the registrar')
   }
 
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
   const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
     solidityKeccak256(['string'], [labels[0]]),
   ])
@@ -32,11 +37,49 @@ const raw = async (
   ])
 }
 
-const decode = async (
+const getWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  labels: string[],
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+    namehash(labels.join('.')),
+  ])
+  return {
+    to: nameWrapper.address,
+    data: expiryCall,
+  }
+}
+
+const getContractToUse = (
+  contract: ContractOption | undefined,
+  labels: string[],
+) => {
+  if (contract) return contract
+  if (labels.length === 2 && labels[1] === 'eth') {
+    return 'registrar'
+  }
+  return 'nameWrapper'
+}
+
+const raw = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+  { contract }: Args = {},
+) => {
+  const labels = name.split('.')
+
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? getWrapperExpiry(ensArgs, labels)
+    : getRegistrarExpiry(ensArgs, labels)
+}
+
+const decodeRegistrarExpiry = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
   data: string,
 ) => {
-  if (data === null) return
   const result = await multicallWrapper.decode(data)
   const baseRegistrar = await contracts?.getBaseRegistrar()!
   try {
@@ -57,6 +100,41 @@ const decode = async (
   }
 }
 
+const decodeWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [_owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getData',
+      data,
+    )
+    return {
+      expiry: new Date(expiry * 1000),
+      gracePeriod: null,
+    }
+  } catch {
+    return
+  }
+}
+
+const decode = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+  name: string,
+  { contract }: Args = {},
+) => {
+  if (data === null) return
+
+  const labels = name.split('.')
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? decodeWrapperExpiry(ensArgs, data)
+    : decodeRegistrarExpiry(ensArgs, data)
+}
+
 export default {
   raw,
   decode,

package/src/functions/getFuses.test.ts

@@ -12,10 +12,6 @@ let withWrappedSnapshot: any
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
-    wrappedOwner: accounts[0],
-  })
-  await tx.wait()
 
   withWrappedSnapshot = await createSnapshot()
 })
@@ -31,18 +27,12 @@ afterAll(async () => {
 
 describe('getFuses', () => {
   it('should return null for an unwrapped name', async () => {
-    const result = await ENSInstance.getFuses('jefflau.eth')
+    const result = await ENSInstance.getFuses('with-profile.eth')
     expect(result).toBeUndefined()
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      owner: accounts[0],
-      addressOrIndex: 0,
-    })
-    await tx.wait()
-
-    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await ENSInstance.getFuses('test.wrapped-with-subnames.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj.canDoEverything).toBe(true)
@@ -56,15 +46,17 @@ describe('getFuses', () => {
     }
   })
   it('should return with other correct fuses', async () => {
-    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
+    const tx = await ENSInstance.burnFuses('wrapped.eth', {
       fusesToBurn: {
         cannotUnwrap: true,
         cannotSetTtl: true,
         cannotCreateSubdomain: true,
       },
+      addressOrIndex: 1,
     })
     await tx.wait()
-    const result = await ENSInstance.getFuses('parthtejpal.eth')
+
+    const result = await ENSInstance.getFuses('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj).toMatchObject({
@@ -80,26 +72,11 @@ describe('getFuses', () => {
       expect(result.rawFuses.toHexString()).toBe('0x71')
     }
   })
-  it('should return correct vulnerability data for an invulnerable node', async () => {
-    const result = await ENSInstance.getFuses('parthtejpal.eth')
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.vulnerability).toBe('Safe')
-      expect(result.vulnerableNode).toBeNull()
-    }
-  })
-  it('should return correct vulnerability data for a vulnerable node', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
-      owner: accounts[0],
-      contract: 'nameWrapper',
-    })
-    await tx.wait()
-
-    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+  it('should return correct expiry', async () => {
+    const result = await ENSInstance.getFuses('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.vulnerability).toBe('SubdomainReplacementAllowed')
-      expect(result.vulnerableNode).toBe('parthtejpal.eth')
+      expect(result.expiryDate).toBeInstanceOf(Date)
     }
   })
 })

package/src/functions/getFuses.ts

@@ -1,4 +1,4 @@
-import { BigNumber, utils } from 'ethers'
+import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
 import { testable as fuseEnums } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
@@ -28,8 +28,12 @@ const decode = async (
 ) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [fuses, vulnerability, vulnerableNode] =
-      nameWrapper.interface.decodeFunctionResult('getFuses', data)
+    const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getFuses',
+      data,
+    )
+
+    const fuses = BigNumber.from(_fuses)
 
     const fuseObj = Object.fromEntries(
       Object.keys(fuseEnums).map((fuseEnum) => [
@@ -48,22 +52,12 @@ const decode = async (
       fuseObj.canDoEverything = false
     }
 
-    let returnVulnerableNode: string | null = null
-    if (utils.hexStripZeros(vulnerableNode) !== '0x') {
-      name.split('.').forEach((label, index, arr) => {
-        const node = arr.slice(index).join('.')
-        const nodehash = namehash(node)
-        if (nodehash === vulnerableNode) {
-          returnVulnerableNode = node
-        }
-      })
-    }
+    const expiryDate = new Date(expiry * 1000)
 
     return {
       fuseObj,
-      vulnerability: NameSafety[vulnerability] || vulnerability,
-      vulnerableNode: returnVulnerableNode,
-      rawFuses: fuses as BigNumber,
+      expiryDate,
+      rawFuses: fuses,
     }
   } catch {
     return

package/src/functions/getHistory.test.ts

@@ -2,21 +2,23 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-  jest.setTimeout(20000)
+  ;({ ENSInstance, revert } = await setup())
 })
 
-describe('getHistory', () => {
-  let textEventsWithValue: any[]
+afterAll(async () => {
+  await revert()
+})
 
+describe('getHistory', () => {
   it('should return null for a non-existent name', async () => {
     const result = await ENSInstance.getHistory('test123123cool.eth')
     expect(result).toBeUndefined()
   })
   it('should return the history of a name', async () => {
-    const result = await ENSInstance.getHistory('jefflau.eth')
+    const result = await ENSInstance.getHistory('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result).toHaveProperty('domain')
@@ -24,78 +26,4 @@ describe('getHistory', () => {
       expect(result).toHaveProperty('registration')
     }
   })
-  describe('getHistoryWithDetail', () => {
-    it('should return null for a non-existent name', async () => {
-      const result = await ENSInstance.getHistoryWithDetail(
-        'test123123cool.eth',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return the history of a name with TextChanged event detail', async () => {
-      const result = await ENSInstance.getHistoryWithDetail('jefflau.eth')
-      expect(result).toBeTruthy()
-      if (result) {
-        const textEvents = result.resolver.filter(
-          (x) => x.type === 'TextChanged',
-        )
-        textEvents.forEach((event) =>
-          expect(event.data).toHaveProperty('value'),
-        )
-        textEventsWithValue = textEvents
-      }
-    })
-  })
-  describe('getHistoryDetailForTransactionHash', () => {
-    it('should throw an error for an invalid transaction hash', async () => {
-      try {
-        await ENSInstance.getHistoryDetailForTransactionHash('0x234')
-        expect(false).toBeTruthy()
-      } catch (error) {
-        expect((error as any).message).toContain('invalid hash')
-      }
-    })
-    it('should return null for a transaction hash with no text events', async () => {
-      const result = await ENSInstance.getHistoryDetailForTransactionHash(
-        '0x0fd7b555e3076ef38dbbe2e40deefe44c9a0530d43f6b3f60dbed4ba49d229b7',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return single item for a given transaction hash with one event', async () => {
-      const eventToUse = textEventsWithValue[0]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        eventToUse.transactionHash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(1)
-      if (result) {
-        expect(result[0]).toMatchObject(eventToUse.data)
-      }
-    })
-    it('should return multiple items for a given transaction hash with multiple events', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const dataArr = [
-        { key: 'description', value: 'Not so super description' },
-        { key: 'url', value: 'facebook.com' },
-      ]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(dataArr.length)
-      if (result) {
-        result.forEach((item, index) =>
-          expect(item).toMatchObject(dataArr[index]),
-        )
-      }
-    })
-    it('should return a single item when an index is specified for a hash', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const data = { key: 'url', value: 'facebook.com' }
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-        1,
-      )) as { key: any; value: any }
-      expect(result).toMatchObject(data)
-    })
-  })
 })