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

package/src/functions/renewNames.ts

@@ -1,39 +1,33 @@
-import { BigNumber, BigNumberish } from '@ethersproject/bignumber/lib/bignumber'
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber'
 import { ENSArgs } from '..'
-import { FuseProps, validateFuses } from '../utils/fuses'
-import { MAX_INT_64 } from '../utils/registerHelpers'
+import { MAX_INT_64 } from '../utils/consts'
+import { labelhash } from '../utils/labels'
+import { namehash } from '../utils/normalise'
 
 type BaseProps = {
   duration: number
   value: BigNumber
 }
 
-export async function renewNameWithData(
+type WrappedProps = {
+  duration: BigNumberish
+}
+
+export async function extendWrappedName(
   { contracts }: ENSArgs<'contracts'>,
   name: string,
-  {
-    duration,
-    value,
-    fuses,
-    wrapperExpiry = MAX_INT_64,
-  }: BaseProps & {
-    fuses?: FuseProps
-    wrapperExpiry?: BigNumberish
-  },
+  options?: WrappedProps,
 ) {
+  const expiry = options?.duration || MAX_INT_64
   const labels = name.split('.')
-  if (labels.length !== 2 || labels[1] !== 'eth') {
-    throw new Error('Currently only .eth TLD renewals are supported')
-  }
+  const labelHash = labelhash(labels.shift()!)
+  const parentNode = namehash(labels.join('.'))
 
-  const encodedFuses = fuses ? validateFuses(fuses) : 0
-  const controller = await contracts!.getEthRegistrarController()
-  return controller.populateTransaction.renewWithFuses(
-    labels[0],
-    duration,
-    encodedFuses,
-    wrapperExpiry,
-    { value },
+  const nameWrapper = await contracts!.getNameWrapper()
+  return nameWrapper.populateTransaction.extendExpiry(
+    parentNode,
+    labelHash,
+    expiry,
   )
 }
 

package/src/functions/setFuses.test.ts

@@ -0,0 +1,240 @@
+import { ethers } from 'ethers'
+import { ENS } from '../index'
+import setup from '../tests/setup'
+import { unnamedUserSettableFuses, userSettableFuseEnum } from '../utils/fuses'
+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()
+})
+
+const checkFuses = (
+  fuses: number,
+  expected: (keyof typeof userSettableFuseEnum)[],
+) => {
+  // eslint-disable-next-line guard-for-in
+  for (const fuse in userSettableFuseEnum) {
+    const active =
+      (fuses &
+        userSettableFuseEnum[fuse as keyof typeof userSettableFuseEnum]) >
+      0
+    if (expected.includes(fuse as keyof typeof userSettableFuseEnum)) {
+      try {
+        expect(active).toBeTruthy()
+      } catch {
+        throw new Error(`${fuse} should be true but is false`)
+      }
+    } else if (active) {
+      try {
+        expect(active).toBeFalsy()
+      } catch {
+        throw new Error(`${fuse} should be false but is true`)
+      }
+    }
+  }
+}
+
+const checkUnnamedFuses = (
+  fuses: number,
+  expected: (keyof typeof unnamedUserSettableFuses)[],
+) => {
+  // eslint-disable-next-line guard-for-in
+  for (const fuse of unnamedUserSettableFuses) {
+    const active = (fuses & fuse) > 0
+    if (expected.includes(fuse as keyof typeof unnamedUserSettableFuses)) {
+      try {
+        expect(active).toBeTruthy()
+      } catch {
+        throw new Error(`${fuse} should be true but is false`)
+      }
+    } else if (active) {
+      try {
+        expect(active).toBeFalsy()
+      } catch {
+        throw new Error(`${fuse} should be false but is true`)
+      }
+    }
+  }
+}
+
+describe('setFuses', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  describe('Array', () => {
+    it('should return a setFuses transaction from a named fuse array and succeed', async () => {
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        named: ['CANNOT_UNWRAP', 'CANNOT_CREATE_SUBDOMAIN', 'CANNOT_SET_TTL'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkFuses(fuses, [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'PARENT_CANNOT_CONTROL',
+      ])
+    })
+    it('should return a setFuses transaction from an unnamed fuse array and succeed', async () => {
+      const tx0 = await ensInstance.setFuses('wrapped.eth', {
+        named: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx0).toBeTruthy()
+      await tx0.wait()
+
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        unnamed: [128, 256, 512],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkUnnamedFuses(fuses, [128, 256, 512])
+    })
+    it('should return a setFuses transaction from both an unnamed and named fuse array and succeed', async () => {
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        named: ['CANNOT_UNWRAP', 'CANNOT_CREATE_SUBDOMAIN', 'CANNOT_SET_TTL'],
+        unnamed: [128, 256, 512],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkFuses(fuses, [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'PARENT_CANNOT_CONTROL',
+      ])
+      checkUnnamedFuses(fuses, [128, 256, 512])
+    })
+    it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          unnamed: [32] as any,
+          addressOrIndex: accounts[1],
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          '32 is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.',
+        )
+      }
+    })
+    it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          named: ['COOL_SWAG_FUSE'] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('COOL_SWAG_FUSE is not a valid named fuse.')
+      }
+    })
+  })
+  describe('Number', () => {
+    it('should return a setFuses transaction from a number and succeed', async () => {
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        number: 49,
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkFuses(fuses, [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'PARENT_CANNOT_CONTROL',
+      ])
+    })
+    it('should throw an error if the number is too high', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          number: 4294967297,
+          addressOrIndex: accounts[1],
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, 4294967297 was too high.',
+        )
+      }
+    })
+    it('should throw an error if the number is too low', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          number: -1,
+          addressOrIndex: accounts[1],
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, -1 was too low.',
+        )
+      }
+    })
+    it('should throw an error if the number is not an integer', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          number: 7.5,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('Fuse number must be an integer, 7.5 was not.')
+      }
+    })
+  })
+})
+
+describe('setChildFuses', () => {
+  it('should return a setChildFuses transaction and succeed', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const setParentTx = await ensInstance.setFuses(
+      'wrapped-with-subnames.eth',
+      {
+        named: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      },
+    )
+    expect(setParentTx).toBeTruthy()
+    await setParentTx.wait()
+
+    const tx = await ensInstance.setChildFuses(
+      'test.wrapped-with-subnames.eth',
+      {
+        fuses: 65537,
+        addressOrIndex: accounts[1],
+      },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const [, fuses] = await nameWrapper.getData(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+
+    checkFuses(fuses, ['CANNOT_UNWRAP', 'PARENT_CANNOT_CONTROL'])
+  })
+})

package/src/functions/setFuses.ts

@@ -0,0 +1,44 @@
+import { ENSArgs } from '../index'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
+import { labelhash } from '../utils/labels'
+import { namehash } from '../utils/normalise'
+
+export async function setChildFuses(
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    fuses,
+    expiry = 0,
+  }: {
+    fuses: Partial<CombinedFuseInput> | number
+    expiry?: number
+  },
+) {
+  const encodedFuses = encodeFuses(fuses)
+
+  const labels = name.split('.')
+  const labelHash = labelhash(labels.shift()!)
+  const parentNode = namehash(labels.join('.'))
+
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+
+  return nameWrapper.populateTransaction.setChildFuses(
+    parentNode,
+    labelHash,
+    encodedFuses,
+    expiry,
+  )
+}
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  props: CombinedFuseInput['child'],
+) {
+  const encodedFuses = encodeFuses(props, 'child')
+
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+  const hash = namehash(name)
+
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
+}

package/src/functions/types.ts

@@ -4,11 +4,11 @@ import type {
   resolverMulticallWrapper,
   universalWrapper,
 } from './batchWrappers'
-import type burnFuses from './burnFuses'
 import type commitName from './commitName'
 import type createSubname from './createSubname'
 import type deleteSubname from './deleteSubname'
 import type getAvailable from './getAvailable'
+import type getDecryptedName from './getDecryptedName'
 import type getDNSOwner from './getDNSOwner'
 import type getExpiry from './getExpiry'
 import type { getHistory } from './getHistory'
@@ -36,8 +36,10 @@ import type registerName from './registerName'
 import type {
   // eslint-disable-next-line import/no-named-default
   default as renewNames,
-  renewNameWithData,
+  extendWrappedName,
 } from './renewNames'
+import type setFuses from './setFuses'
+import type { setChildFuses } from './setFuses'
 import type setName from './setName'
 import type setRecord from './setRecord'
 import type setRecords from './setRecords'
@@ -54,11 +56,13 @@ type Function = {
   multicallWrapper: typeof multicallWrapper
   resolverMulticallWrapper: typeof resolverMulticallWrapper
   universalWrapper: typeof universalWrapper
-  burnFuses: typeof burnFuses
+  setFuses: typeof setFuses
+  setChildFuses: typeof setChildFuses
   commitName: typeof commitName
   createSubname: typeof createSubname
   deleteSubname: typeof deleteSubname
   getAvailable: typeof getAvailable
+  getDecryptedName: typeof getDecryptedName
   getDNSOwner: typeof getDNSOwner
   getExpiry: typeof getExpiry
   getHistory: typeof getHistory
@@ -82,7 +86,7 @@ type Function = {
   importDNSSECName: typeof importDNSSECName
   registerName: typeof registerName
   renewNames: typeof renewNames
-  renewNameWithData: typeof renewNameWithData
+  extendWrappedName: typeof extendWrappedName
   setName: typeof setName
   setRecord: typeof setRecord
   setRecords: typeof setRecords

package/src/functions/wrapName.test.ts

@@ -46,15 +46,15 @@ describe('wrapName', () => {
       const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
       const [, fuses] = await nameWrapper.getData(namehash('test123.eth'))
 
-      // parent cannot control
-      expect(fuses).toBe(64)
+      expect(fuses).toBe(196608)
     })
     it('should allow initial fuses', async () => {
       const tx = await ensInstance.wrapName('test123.eth', {
         wrappedOwner: accounts[2],
         fuseOptions: {
-          CANNOT_UNWRAP: true,
-          CANNOT_SET_TTL: true,
+          child: {
+            named: ['CANNOT_UNWRAP', 'CANNOT_SET_TTL'],
+          },
         },
         addressOrIndex: 1,
       })
@@ -63,7 +63,7 @@ describe('wrapName', () => {
 
       const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
       const [, fuses] = await nameWrapper.getData(namehash('test123.eth'))
-      expect(fuses).toBe(81)
+      expect(fuses).toBe(196625)
     })
     it('should allow an initial resolver address', async () => {
       const tx = await ensInstance.wrapName('test123.eth', {
@@ -139,8 +139,9 @@ describe('wrapName', () => {
         ensInstance.wrapName('test.with-subnames.eth', {
           wrappedOwner: accounts[2],
           fuseOptions: {
-            cannotUnwrap: true,
-            cannotSetTtl: true,
+            child: {
+              named: ['CANNOT_UNWRAP', 'CANNOT_SET_TTL'],
+            },
           },
           addressOrIndex: 1,
         }),

package/src/functions/wrapName.ts

@@ -1,19 +1,16 @@
-import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
+import { defaultAbiCoder } from '@ethersproject/abi'
 import { Signer } from '@ethersproject/abstract-signer'
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
-import { FuseOptions } from '../utils/fuses'
-import generateFuseInput from '../utils/generateFuseInput'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
+import { Expiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
 async function wrapETH(
   { contracts }: ENSArgs<'contracts'>,
   labels: string[],
   wrappedOwner: string,
-  expiry: BigNumber,
-  decodedFuses: string,
+  decodedFuses: number,
   resolverAddress: string,
   signer: Signer,
   address: string,
@@ -24,8 +21,8 @@ async function wrapETH(
   const labelhash = solidityKeccak256(['string'], [labels[0]])
 
   const data = defaultAbiCoder.encode(
-    ['string', 'address', 'uint32', 'uint64', 'address'],
-    [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress],
+    ['string', 'address', 'uint16', 'address'],
+    [labels[0], wrappedOwner, decodedFuses, resolverAddress],
   )
 
   return baseRegistrar.populateTransaction[
@@ -63,11 +60,7 @@ async function wrapOther(
 }
 
 export default async function (
-  {
-    contracts,
-    signer,
-    getExpiry,
-  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
   {
     wrappedOwner,
@@ -76,14 +69,14 @@ export default async function (
     resolverAddress,
   }: {
     wrappedOwner: string
-    fuseOptions?: FuseOptions | string | number
+    fuseOptions?: Partial<CombinedFuseInput> | number
     expiry?: Expiry
     resolverAddress?: string
   },
 ) {
   const address = await signer.getAddress()
 
-  let decodedFuses: string
+  let decodedFuses: number
 
   const publicResolver = await contracts?.getPublicResolver()!
   if (!resolverAddress) resolverAddress = publicResolver.address
@@ -94,19 +87,15 @@ export default async function (
   if (labels.length === 2 && labels[1] === 'eth') {
     switch (typeof fuseOptions) {
       case 'object': {
-        decodedFuses = generateFuseInput(fuseOptions)
+        decodedFuses = encodeFuses(fuseOptions)
         break
       }
       case 'number': {
-        decodedFuses = fuseOptions.toString(16)
-        break
-      }
-      case 'string': {
         decodedFuses = fuseOptions
         break
       }
       case 'undefined': {
-        decodedFuses = '0'
+        decodedFuses = 0
         break
       }
       default: {
@@ -114,13 +103,10 @@ export default async function (
       }
     }
 
-    const expiryToUse = await makeExpiry({ getExpiry }, name, expiry)
-
     return wrapETH(
       { contracts },
       labels,
       wrappedOwner,
-      expiryToUse,
       decodedFuses,
       resolverAddress,
       signer,