@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/functions/burnFuses.ts

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

package/src/functions/commitName.test.ts

@@ -0,0 +1,61 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { randomSecret } from '../utils/registerHelpers'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('commitName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a populated commit transaction with extra data and succeed', async () => {
+    const { customData, ...popTx } =
+      await ensInstance.commitName.populateTransaction('commitment.eth', {
+        duration: 31536000,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    expect(popTx).toBeTruthy()
+    expect(customData).toHaveProperty('secret')
+    expect(customData).toHaveProperty('commitment')
+    expect(customData).toHaveProperty('wrapperExpiry')
+
+    const tx = await provider.getSigner().sendTransaction(popTx)
+    await tx.wait()
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+  it('should return a customised commmit transaction and succeed', async () => {
+    const secret = randomSecret()
+    const tx = await ensInstance.commitName('commitment.eth', {
+      duration: 31536000,
+      owner: accounts[1],
+      addressOrIndex: accounts[1],
+      secret,
+      wrapperExpiry: 100000,
+    })
+    await tx.wait()
+    expect(tx.customData).toBeTruthy()
+    expect(tx.customData!.wrapperExpiry).toBe(100000)
+    expect(tx.customData!.secret).toBe(secret)
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(tx.customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+})

package/src/functions/commitName.ts

@@ -0,0 +1,39 @@
+import { ENSArgs } from '..'
+import { CommitmentParams, makeCommitment } from '../utils/registerHelpers'
+import { wrappedLabelLengthCheck } from '../utils/wrapper'
+
+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')
+
+  wrappedLabelLengthCheck(labels[0])
+
+  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

@@ -1,16 +1,15 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import { namehash } from '../utils/normalise'
 import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
 let provider: ethers.providers.JsonRpcProvider
 let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, createSnapshot, provider } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -23,36 +22,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(namehash('test.parthtejpal.eth'))
+    const registry = await ensInstance.contracts!.getRegistry()!
+    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(namehash('test.parthtejpal.eth'))
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('test.wrapped.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/functions/createSubname.ts

@@ -1,34 +1,33 @@
-import { ethers } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENSArgs } from '..'
-import { FuseOptions } from '../@types/FuseOptions'
+import { FuseOptions } from '../utils/fuses'
 import generateFuseInput from '../utils/generateFuseInput'
 import { namehash } from '../utils/normalise'
+import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
 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) {
@@ -49,9 +48,9 @@ export default async function (
 
   switch (contract) {
     case 'registry': {
-      const registry = (await contracts?.getRegistry()!).connect(signer)
+      const registry = (await contracts!.getRegistry()!).connect(signer)
 
-      return registry.setSubnodeRecord(
+      return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
         owner,
@@ -60,20 +59,27 @@ export default async function (
       )
     }
     case 'nameWrapper': {
-      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      wrappedLabelLengthCheck(label)
+      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/functions/deleteSubname.test.ts

@@ -1,16 +1,12 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
-import { namehash } from '../utils/normalise'
 import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
-let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -22,50 +18,52 @@ 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(namehash('test.parthtejpal.eth'))
+    const registry = await ensInstance.contracts!.getRegistry()!
+    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 nameWrapper = await ensInstance.contracts!.getNameWrapper()!
 
-    const tx = await ENSInstance.deleteSubname(
-      'test.parthtejpal.eth',
-      'nameWrapper',
-      { addressOrIndex: 0 },
+    const tx = await ensInstance.deleteSubname(
+      '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(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
+
+  it('should not allow deleting 1LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('eth', {
+        contract: 'nameWrapper',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
+
+  it('should not allow deleting 2LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('test123.eth', {
+        contract: 'registry',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
 })

package/src/functions/deleteSubname.ts

@@ -1,19 +1,53 @@
+import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+type Args = {
+  contract: 'registry' | 'nameWrapper'
+}
 
 export default async function (
-  {
-    contracts,
-    provider,
-    transferSubname,
-  }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
-  contract: 'registry' | 'nameWrapper',
-  options?: { addressOrIndex?: string | number },
+  { contract }: Args,
 ) {
-  return transferSubname(
-    name,
-    contract,
-    '0x0000000000000000000000000000000000000000',
-    options,
-  )
+  const labels = name.split('.')
+
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`)
+  }
+
+  const label = labels.shift() as string
+  const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
+  const parentNodehash = namehash(labels.join('.'))
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts!.getRegistry()!).connect(signer)
+
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        0,
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        0,
+        0,
+        0,
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
 }

package/src/functions/getDNSOwner.test.ts

@@ -1,13 +1,12 @@
-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) {
-  let bytes: any[] = []
-  string.replace(/../g, function (pair) {
+function hexDecode(string: string) {
+  const bytes: any[] = []
+  string.replace(/../g, (pair) => {
     bytes.push(parseInt(pair, 16))
+    return pair
   })
   return new Uint8Array(bytes).buffer
 }
@@ -26,20 +25,19 @@ describe('encodeURLParams', () => {
 
 describe('getDNSOwner', () => {
   beforeAll(() => {
-    global.fetch = fetch
+    global.fetch = fetch as any
   })
   afterAll(() => {
-    global.fetch = undefined
+    global.fetch = undefined as any
   })
   it('should return the address from the result of a dnsQuery', async () => {
     const dnsName = 'brantly.xyz'
 
-    const scope = nock('https://cloudflare-dns.com:443', {
+    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 ===
@@ -49,7 +47,7 @@ describe('getDNSOwner', () => {
       .reply(
         200,
         Buffer.from(
-          hex_decode(
+          hexDecode(
             '000181a00001000200000001045f656e73076272616e746c790378797a0000100001c00c0010000100000e10002d2c613d307839383331313033303936323044393131373331416330393332323139616630363039316236373434c00c002e000100000e10009f0010080300000e1062df366962c23569d89d076272616e746c790378797a0039c894ca1d7a60c1356e478066d39961a78ec1edbe62e1eb0f13d7947bb72097654648dc79be075ca32625f02e60267f45e88d7c05e9c3ec0cf21ab2dca67a8fbeb8e995644726357628446b888a144cafef5cbfca120c6511fe36de9d3c62dee27680825190c5404ca503904b98dbf62d9122f6fda393dc04b14a89ceb68c7a00002904d0000080000000',
           ),
         ),
@@ -70,19 +68,18 @@ describe('getDNSOwner', () => {
           '726c2b1d3bab6b74-TPE',
         ],
       )
-    expect(await getDNSOwner(dnsName)).toEqual(
+    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', {
+    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 ===
@@ -92,7 +89,7 @@ describe('getDNSOwner', () => {
       .reply(
         200,
         Buffer.from(
-          hex_decode(
+          hexDecode(
             '000181830001000000010001045f656e73046e69636b0378797a0000100001c0110006000100000258003b046e7337310d646f6d61696e636f6e74726f6c03636f6d0003646e73056a6f6d6178036e6574007876d1800000708000001c2000093a800000025800002904d0000080000000',
           ),
         ),
@@ -114,8 +111,8 @@ describe('getDNSOwner', () => {
         ],
       )
     try {
-      await getDNSOwner(dnsName)
-    } catch (error) {
+      await getDNSOwner({}, dnsName)
+    } catch (error: any) {
       expect(error.message).toEqual('DNS query failed: NXDOMAIN')
     }
   })

package/src/functions/getDNSOwner.ts

@@ -16,7 +16,7 @@ export const getDNS = async (q: packet.Packet): Promise<packet.Packet> => {
   )
   const arrayBuffer = await response.arrayBuffer()
   // @ts-ignore:next-line
-  const fromArrayBuffer = Buffer.from(arrayBuffer);
+  const fromArrayBuffer = Buffer.from(arrayBuffer)
   return packet.decode(fromArrayBuffer)
 }
 
@@ -54,7 +54,7 @@ export const dnsQuery = async (
   return response
 }
 
-export default async function (dnsName: string) {
+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/functions/getExpiry.test.ts

@@ -1,15 +1,11 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
-let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -17,8 +13,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 +22,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()