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

package/src/functions/unwrapName.test.ts

@@ -1,15 +1,15 @@
 import { ethers, utils } 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())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -22,47 +22,32 @@ describe('unwrapName', () => {
     await revert()
   })
   it('should return a .eth unwrap name transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-
-    const tx = await ENSInstance.unwrapName(
-      'parthtejpal.eth',
-      accounts[0],
-      accounts[0],
-    )
+    const tx = await ensInstance.unwrapName('wrapped.eth', {
+      newController: accounts[1],
+      newRegistrant: accounts[1],
+      addressOrIndex: 1,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
+    const baseRegistrar = await ensInstance.contracts!.getBaseRegistrar()!
     const result = await baseRegistrar.ownerOf(
-      utils.solidityKeccak256(['string'], ['parthtejpal']),
+      utils.solidityKeccak256(['string'], ['wrapped']),
     )
-    expect(result).toBe(accounts[0])
+    expect(result).toBe(accounts[1])
   })
   it('should return a regular unwrap name transaction and succeed', 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],
-      shouldWrap: true,
-      options: { addressOrIndex: 0 },
+    const tx = await ensInstance.unwrapName('test.wrapped-with-subnames.eth', {
+      newController: accounts[1],
+      addressOrIndex: 2,
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.unwrapName('test.parthtejpal.eth', accounts[0])
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
-    expect(result).toBe(accounts[0])
+    const registry = await ensInstance.contracts!.getRegistry()!
+    const result = await registry.owner(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe(accounts[1])
   })
 })

package/src/functions/unwrapName.ts

@@ -1,39 +1,43 @@
-import { utils } from 'ethers'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
+
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  newController: string,
-  newRegistrant?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    newController,
+    newRegistrant,
+  }: {
+    newController: string
+    newRegistrant?: string
+  },
 ) {
-  const signer = provider?.getSigner(options?.addressOrIndex)
-
-  const address = await signer?.getAddress()
-
-  if (!signer || !address) {
-    throw new Error('No signer found')
-  }
-
   const labels = name.split('.')
-  const labelhash = utils.solidityKeccak256(['string'], [labels[0]])
+  const labelhash = solidityKeccak256(['string'], [labels[0]])
   const parentNodehash = namehash(labels.slice(1).join('.'))
 
-  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
 
   if (labels.length === 2 && labels[1] === 'eth') {
     if (!newRegistrant) {
       throw new Error('newRegistrant must be specified for .eth names')
     }
 
-    return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController)
-  } else {
-    if (newRegistrant) {
-      throw new Error('newRegistrant can only be specified for .eth names')
-    }
-
-    return nameWrapper.unwrap(parentNodehash, labelhash, newController)
+    return nameWrapper.populateTransaction.unwrapETH2LD(
+      labelhash,
+      newRegistrant,
+      newController,
+    )
   }
+  if (newRegistrant) {
+    throw new Error('newRegistrant can only be specified for .eth names')
+  }
+
+  return nameWrapper.populateTransaction.unwrap(
+    parentNodehash,
+    labelhash,
+    newController,
+  )
 }

package/src/functions/wrapName.test.ts

@@ -1,17 +1,16 @@
-import { BigNumber, ethers } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
-import setup from '../tests/setup'
 
-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()
 })
 
@@ -19,46 +18,133 @@ afterAll(async () => {
   await revert()
 })
 
+const approve = async () => {
+  const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+  const registry = (await ensInstance.contracts!.getRegistry()!).connect(
+    provider.getSigner(2),
+  )
+  const setApprovedForAllTx = await registry.setApprovalForAll(
+    nameWrapper.address,
+    true,
+  )
+  await setApprovedForAllTx?.wait()
+}
+
 describe('wrapName', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should return a wrap name transaction and succeed', async () => {
-    const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
-    expect(tx).toBeTruthy()
-    await tx.wait()
+  describe('.eth', () => {
+    it('should return a wrap name transaction and succeed', async () => {
+      const tx = await ensInstance.wrapName('test123.eth', {
+        wrappedOwner: accounts[2],
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
 
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const [result] = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
-    expect((result as BigNumber).toHexString()).toBe('0x40')
-  })
-  it('should allow initial fuses', async () => {
-    const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0], {
-      cannotUnwrap: true,
-      cannotSetTtl: true,
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('test123.eth'))
+
+      // parent cannot control
+      expect(fuses).toBe(64)
+    })
+    it('should allow initial fuses', async () => {
+      const tx = await ensInstance.wrapName('test123.eth', {
+        wrappedOwner: accounts[2],
+        fuseOptions: {
+          CANNOT_UNWRAP: true,
+          CANNOT_SET_TTL: true,
+        },
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('test123.eth'))
+      expect(fuses).toBe(81)
     })
-    expect(tx).toBeTruthy()
-    await tx.wait()
+    it('should allow an initial resolver address', async () => {
+      const tx = await ensInstance.wrapName('test123.eth', {
+        wrappedOwner: accounts[2],
+        resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
 
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const [result] = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
-    expect((result as BigNumber).toHexString()).toBe('0x51')
+      const universalResolver =
+        await ensInstance.contracts!.getUniversalResolver()!
+      const [result] = await universalResolver.findResolver(
+        hexEncodeName('test123.eth'),
+      )
+      expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
+    })
+    it('should throw an error for labels longer than 255 bytes', async () => {
+      const label = 'a'.repeat(256)
+      await expect(
+        ensInstance.wrapName(`${label}.eth`, {
+          wrappedOwner: accounts[2],
+          addressOrIndex: 1,
+        }),
+      ).rejects.toThrow("Label can't be longer than 255 bytes")
+    })
   })
-  it('should allow an initial resolver address', async () => {
-    const tx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-      undefined,
-      '0x42D63ae25990889E35F215bC95884039Ba354115',
-    )
-    expect(tx).toBeTruthy()
-    await tx.wait()
+  describe('other', () => {
+    it('should return a wrap name transaction and succeed', async () => {
+      await approve()
+
+      const tx = await ensInstance.wrapName('test.with-subnames.eth', {
+        wrappedOwner: accounts[2],
+        addressOrIndex: 2,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(
+        namehash('test.with-subnames.eth'),
+      )
+
+      expect(fuses).toBe(0)
+    })
+    it('should allow an initial resolver address', async () => {
+      await approve()
+      const tx = await ensInstance.wrapName('test.with-subnames.eth', {
+        wrappedOwner: accounts[2],
+        resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
+        addressOrIndex: 2,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
 
-    const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
-    const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
-    )
-    expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
+      const universalResolver =
+        await ensInstance.contracts!.getUniversalResolver()!
+      const [result] = await universalResolver.findResolver(
+        hexEncodeName('test.with-subnames.eth'),
+      )
+      expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
+    })
+    it('should throw an error if contract does not have approval', async () => {
+      await expect(
+        ensInstance.wrapName('test.with-subnames.eth', {
+          wrappedOwner: accounts[2],
+          addressOrIndex: 2,
+        }),
+      ).rejects.toThrow()
+    })
+    it('should throw an error if initial fuses are provided', async () => {
+      await expect(
+        ensInstance.wrapName('test.with-subnames.eth', {
+          wrappedOwner: accounts[2],
+          fuseOptions: {
+            cannotUnwrap: true,
+            cannotSetTtl: true,
+          },
+          addressOrIndex: 1,
+        }),
+      ).rejects.toThrow()
+    })
   })
 })

package/src/functions/wrapName.ts

@@ -1,45 +1,47 @@
-import { ethers } from 'ethers'
+import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
+import { Signer } from '@ethersproject/abstract-signer'
+import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
-import type { FuseOptions } from '../@types/FuseOptions'
+import { FuseOptions } from '../utils/fuses'
 import generateFuseInput from '../utils/generateFuseInput'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
 async function wrapETH(
   { contracts }: ENSArgs<'contracts'>,
   labels: string[],
   wrappedOwner: string,
+  expiry: BigNumber,
   decodedFuses: string,
   resolverAddress: string,
-  signer: ethers.Signer,
+  signer: Signer,
   address: string,
 ) {
   const nameWrapper = await contracts?.getNameWrapper()!
-  const baseRegistrar = (await contracts?.getBaseRegistrar()!).connect(signer)
+  const baseRegistrar = (await contracts!.getBaseRegistrar()!).connect(signer)
 
-  const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]])
+  const labelhash = solidityKeccak256(['string'], [labels[0]])
 
-  const data = ethers.utils.defaultAbiCoder.encode(
-    ['string', 'address', 'uint96', 'address'],
-    [labels[0], wrappedOwner, decodedFuses, resolverAddress],
+  const data = defaultAbiCoder.encode(
+    ['string', 'address', 'uint32', 'uint64', 'address'],
+    [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress],
   )
 
-  return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](
-    address,
-    nameWrapper.address,
-    labelhash,
-    data,
-  )
+  return baseRegistrar.populateTransaction[
+    'safeTransferFrom(address,address,uint256,bytes)'
+  ](address, nameWrapper.address, labelhash, data)
 }
 
 async function wrapOther(
   { contracts }: ENSArgs<'contracts'>,
   name: string,
   wrappedOwner: string,
-  decodedFuses: string,
   resolverAddress: string,
   address: string,
+  signer: Signer,
 ) {
-  const nameWrapper = await contracts?.getNameWrapper()!
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
   const registry = await contracts?.getRegistry()!
 
   const hasApproval = await registry.isApprovedForAll(
@@ -53,76 +55,92 @@ async function wrapOther(
     )
   }
 
-  return nameWrapper.wrap(
+  return nameWrapper.populateTransaction.wrap(
     hexEncodeName(name),
     wrappedOwner,
-    decodedFuses,
     resolverAddress,
   )
 }
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
-  wrappedOwner: string,
-  fuseOptions?: FuseOptions | string | number,
-  resolverAddress?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    wrappedOwner,
+    fuseOptions,
+    expiry,
+    resolverAddress,
+  }: {
+    wrappedOwner: string
+    fuseOptions?: FuseOptions | string | number
+    expiry?: Expiry
+    resolverAddress?: string
+  },
 ) {
-  const signer = provider?.getSigner(options?.addressOrIndex)
-
-  const address = await signer?.getAddress()
-
-  if (!signer || !address) {
-    throw new Error('No signer found')
-  }
+  const address = await signer.getAddress()
 
   let decodedFuses: string
 
-  switch (typeof fuseOptions) {
-    case 'object': {
-      decodedFuses = generateFuseInput(fuseOptions)
-      break
-    }
-    case 'number': {
-      decodedFuses = fuseOptions.toString(16)
-      break
-    }
-    case 'string': {
-      decodedFuses = fuseOptions
-      break
-    }
-    case 'undefined': {
-      decodedFuses = '0'
-      break
-    }
-    default: {
-      throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`)
-    }
-  }
-
   const publicResolver = await contracts?.getPublicResolver()!
   if (!resolverAddress) resolverAddress = publicResolver.address
 
   const labels = name.split('.')
-  if (labels.length < 3 && labels[labels.length - 1] === 'eth') {
+  wrappedLabelLengthCheck(labels[0])
+
+  if (labels.length === 2 && labels[1] === 'eth') {
+    switch (typeof fuseOptions) {
+      case 'object': {
+        decodedFuses = generateFuseInput(fuseOptions)
+        break
+      }
+      case 'number': {
+        decodedFuses = fuseOptions.toString(16)
+        break
+      }
+      case 'string': {
+        decodedFuses = fuseOptions
+        break
+      }
+      case 'undefined': {
+        decodedFuses = '0'
+        break
+      }
+      default: {
+        throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`)
+      }
+    }
+
+    const expiryToUse = await makeExpiry({ getExpiry }, name, expiry)
+
     return wrapETH(
       { contracts },
       labels,
       wrappedOwner,
+      expiryToUse,
       decodedFuses,
       resolverAddress,
       signer,
       address,
     )
-  } else {
-    return wrapOther(
-      { contracts },
-      name,
-      wrappedOwner,
-      decodedFuses,
-      resolverAddress,
-      address,
-    )
   }
+  if (fuseOptions)
+    throw new Error(
+      'Fuses can not be initially set when wrapping a non .eth name',
+    )
+  if (expiry)
+    throw new Error(
+      'Expiry can not be initially set when wrapping a non .eth name',
+    )
+  return wrapOther(
+    { contracts },
+    name,
+    wrappedOwner,
+    resolverAddress,
+    address,
+    signer,
+  )
 }