@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/src/functions/transferSubname.ts

@@ -0,0 +1,63 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { Expiry, makeExpiry } from '../utils/wrapperExpiry'
+
+type BaseArgs = {
+  owner: string
+  resolverAddress?: string
+  contract: 'registry' | 'nameWrapper'
+}
+
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  expiry?: Expiry
+} & BaseArgs
+
+type Args = BaseArgs | NameWrapperArgs
+
+export default async function (
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  name: string,
+  { contract, owner, resolverAddress, ...wrapperArgs }: Args,
+) {
+  const labels = name.split('.')
+  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.setSubnodeOwner(
+        parentNodehash,
+        labelhash,
+        owner,
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      const expiry = await makeExpiry(
+        { getExpiry },
+        labels.join('.'),
+        'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined,
+      )
+
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        owner,
+        '0',
+        expiry,
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/unwrapName.test.ts

@@ -0,0 +1,53 @@
+import { ethers, utils } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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('unwrapName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a .eth unwrap name transaction and succeed', async () => {
+    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 result = await baseRegistrar.ownerOf(
+      utils.solidityKeccak256(['string'], ['wrapped']),
+    )
+    expect(result).toBe(accounts[1])
+  })
+  it('should return a regular unwrap name transaction and succeed', async () => {
+    const tx = await ENSInstance.unwrapName('test.wrapped-with-subnames.eth', {
+      newController: accounts[1],
+      addressOrIndex: 2,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    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

@@ -0,0 +1,43 @@
+import { utils } from 'ethers'
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    newController,
+    newRegistrant,
+  }: {
+    newController: string
+    newRegistrant?: string
+  },
+) {
+  const labels = name.split('.')
+  const labelhash = utils.solidityKeccak256(['string'], [labels[0]])
+  const parentNodehash = namehash(labels.slice(1).join('.'))
+
+  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.populateTransaction.unwrapETH2LD(
+      labelhash,
+      newRegistrant,
+      newController,
+    )
+  } else {
+    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

@@ -0,0 +1,142 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+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())
+  accounts = await provider.listAccounts()
+})
+
+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()
+  })
+  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 [fuses] = await nameWrapper.getFuses(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: {
+          cannotUnwrap: true,
+          cannotSetTtl: true,
+        },
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const [fuses] = await nameWrapper.getFuses(namehash('test123.eth'))
+      expect(fuses).toBe(81)
+    })
+    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 universalResolver =
+        await ENSInstance.contracts!.getUniversalResolver()!
+      const [result] = await universalResolver.findResolver(
+        hexEncodeName('test123.eth'),
+      )
+      expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
+    })
+  })
+  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.getFuses(
+        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('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

@@ -0,0 +1,142 @@
+import { BigNumber, ethers } from 'ethers'
+import { ENSArgs } from '..'
+import type { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { Expiry, makeExpiry } from '../utils/wrapperExpiry'
+
+async function wrapETH(
+  { contracts }: ENSArgs<'contracts'>,
+  labels: string[],
+  wrappedOwner: string,
+  expiry: BigNumber,
+  decodedFuses: string,
+  resolverAddress: string,
+  signer: ethers.Signer,
+  address: string,
+) {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const baseRegistrar = (await contracts?.getBaseRegistrar()!).connect(signer)
+
+  const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]])
+
+  const data = ethers.utils.defaultAbiCoder.encode(
+    ['string', 'address', 'uint32', 'uint64', 'address'],
+    [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress],
+  )
+
+  return baseRegistrar.populateTransaction[
+    'safeTransferFrom(address,address,uint256,bytes)'
+  ](address, nameWrapper.address, labelhash, data)
+}
+
+async function wrapOther(
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  wrappedOwner: string,
+  resolverAddress: string,
+  address: string,
+  signer: ethers.Signer,
+) {
+  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+  const registry = await contracts?.getRegistry()!
+
+  const hasApproval = await registry.isApprovedForAll(
+    address,
+    nameWrapper.address,
+  )
+
+  if (!hasApproval) {
+    throw new Error(
+      'NameWrapper must have approval to wrap a name from this address.',
+    )
+  }
+
+  return nameWrapper.populateTransaction.wrap(
+    hexEncodeName(name),
+    wrappedOwner,
+    resolverAddress,
+  )
+}
+
+export default async function (
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  name: string,
+  {
+    wrappedOwner,
+    fuseOptions,
+    expiry,
+    resolverAddress,
+  }: {
+    wrappedOwner: string
+    fuseOptions?: FuseOptions | string | number
+    expiry?: Expiry
+    resolverAddress?: string
+  },
+) {
+  const address = await signer.getAddress()
+
+  let decodedFuses: string
+
+  const publicResolver = await contracts?.getPublicResolver()!
+  if (!resolverAddress) resolverAddress = publicResolver.address
+
+  const labels = name.split('.')
+  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 {
+    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,
+    )
+  }
+}