@ensdomains/ensjs 3.0.0-alpha.40 → 3.0.0-alpha.42

package/src/functions/getSpecificRecord.ts

@@ -1,5 +1,7 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
-import { hexStripZeros, isBytesLike } from '@ethersproject/bytes'
+import { BigNumber } from '@ethersproject/bignumber'
+import { arrayify, hexStripZeros, isBytesLike } from '@ethersproject/bytes'
+import { toUtf8String } from '@ethersproject/strings'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
 import { namehash } from '../utils/normalise'
@@ -234,3 +236,95 @@ export const getAddr = {
     return _getAddr.decode({ contracts }, urData.data, _name, coinType)
   },
 }
+
+// Supported content types as bitwise OR
+// ID 1: JSON
+// ID 2: zlib compressed JSON
+// ID 4: CBOR
+// ID 8: URI
+const supportedContentTypes = '0xf'
+
+export const _getABI = {
+  raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    return {
+      to: '0x0000000000000000000000000000000000000000',
+      data: publicResolver.interface.encodeFunctionData('ABI', [
+        namehash(name),
+        supportedContentTypes,
+      ]),
+    }
+  },
+  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    const [bnContentType, encodedABIData] =
+      publicResolver.interface.decodeFunctionResult('ABI', data)
+    if (!bnContentType || !data) {
+      return
+    }
+    const contentType = (bnContentType as BigNumber).toNumber()
+    if (!contentType) {
+      return
+    }
+    let abiData: string | object
+    let decoded = false
+    switch (contentType) {
+      // JSON
+      case 1:
+        abiData = JSON.parse(toUtf8String(encodedABIData))
+        decoded = true
+        break
+      // zlib compressed JSON
+      case 2: {
+        const { inflate } = await import('pako/dist/pako_inflate.min.js')
+        abiData = JSON.parse(
+          inflate(arrayify(encodedABIData), { to: 'string' }),
+        )
+        decoded = true
+        break
+      }
+      // CBOR
+      case 4: {
+        const { decodeFirst } = await import('cbor')
+        abiData = await decodeFirst(arrayify(encodedABIData))
+        decoded = true
+        break
+      }
+      // URI
+      case 8:
+        abiData = toUtf8String(encodedABIData)
+        decoded = false
+        break
+      default:
+        try {
+          abiData = toUtf8String(encodedABIData)
+        } catch {
+          abiData = encodedABIData
+        }
+        decoded = false
+    }
+    return {
+      contentType,
+      decoded,
+      abi: abiData,
+    }
+  },
+}
+
+export const getABI = {
+  raw: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    name: string,
+  ) => {
+    const prData = await _getABI.raw({ contracts }, name)
+    return universalWrapper.raw(name, prData.data)
+  },
+  decode: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    data: string,
+  ) => {
+    const urData = await universalWrapper.decode(data)
+    if (!urData) return
+    return _getABI.decode({ contracts }, urData.data)
+  },
+}

package/src/functions/getWrapperData.test.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from 'ethers'
 import { ENS } from '../index'
 import setup from '../tests/setup'
 
@@ -7,22 +6,6 @@ let revert: Awaited<ReturnType<typeof setup>>['revert']
 let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
 let withWrappedSnapshot: any
 
-const unwrappedNameDefault = {
-  expiryDate: new Date(0).toString(),
-  fuseObj: {
-    CANNOT_BURN_FUSES: false,
-    CANNOT_CREATE_SUBDOMAIN: false,
-    CANNOT_SET_RESOLVER: false,
-    CANNOT_SET_TTL: false,
-    CANNOT_TRANSFER: false,
-    CANNOT_UNWRAP: false,
-    PARENT_CANNOT_CONTROL: false,
-    CAN_DO_EVERYTHING: true,
-  },
-  owner: '0x0000000000000000000000000000000000000000',
-  rawFuses: BigNumber.from(0),
-}
-
 beforeAll(async () => {
   ;({ ensInstance, revert, createSnapshot } = await setup())
 
@@ -41,9 +24,9 @@ afterAll(async () => {
 describe('getWrapperData', () => {
   it('should return default data for an unwrapped name', async () => {
     const result = await ensInstance.getWrapperData('with-profile.eth')
-    expect({ ...result, expiryDate: result?.expiryDate.toString() }).toEqual(
-      unwrappedNameDefault,
-    )
+    expect(result?.expiryDate).toBeUndefined()
+    expect(result?.rawFuses).toEqual(0)
+    expect(result?.child.CAN_DO_EVERYTHING).toBeTruthy()
   })
   it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
     const result = await ensInstance.getWrapperData(
@@ -51,23 +34,13 @@ describe('getWrapperData', () => {
     )
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.fuseObj.CAN_DO_EVERYTHING).toBe(true)
-      expect(
-        Object.values(result.fuseObj).reduce(
-          (prev, curr) => (curr ? prev + 1 : prev),
-          0,
-        ),
-      ).toBe(1)
-      expect(result.rawFuses.toHexString()).toBe('0x00')
+      expect(result.child.CAN_DO_EVERYTHING).toBe(true)
+      expect(result.rawFuses).toBe(0)
     }
   })
   it('should return with other correct fuses', async () => {
-    const tx = await ensInstance.burnFuses('wrapped.eth', {
-      namedFusesToBurn: [
-        'CANNOT_UNWRAP',
-        'CANNOT_CREATE_SUBDOMAIN',
-        'CANNOT_SET_TTL',
-      ],
+    const tx = await ensInstance.setFuses('wrapped.eth', {
+      named: ['CANNOT_UNWRAP', 'CANNOT_CREATE_SUBDOMAIN', 'CANNOT_SET_TTL'],
       addressOrIndex: 1,
     })
     await tx.wait()
@@ -75,17 +48,10 @@ describe('getWrapperData', () => {
     const result = await ensInstance.getWrapperData('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.fuseObj).toMatchObject({
-        CANNOT_UNWRAP: true,
-        CANNOT_BURN_FUSES: false,
-        CANNOT_TRANSFER: false,
-        CANNOT_SET_RESOLVER: false,
-        CANNOT_SET_TTL: true,
-        CANNOT_CREATE_SUBDOMAIN: true,
-        PARENT_CANNOT_CONTROL: true,
-        CAN_DO_EVERYTHING: false,
-      })
-      expect(result.rawFuses.toHexString()).toBe('0x71')
+      expect(result.child.CAN_DO_EVERYTHING).toBe(false)
+      expect(result.child.CANNOT_UNWRAP).toBe(true)
+      expect(result.child.CANNOT_CREATE_SUBDOMAIN).toBe(true)
+      expect(result.child.CANNOT_SET_TTL).toBe(true)
     }
   })
   it('should return correct expiry', async () => {

package/src/functions/getWrapperData.ts

@@ -14,18 +14,20 @@ const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
 const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+    const [owner, fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
       'getData',
       data,
-    )
+    ) as [string, number, BigNumber]
 
-    const fuses = BigNumber.from(_fuses)
     const fuseObj = decodeFuses(fuses)
 
-    const expiryDate = new Date(expiry * 1000)
+    const expiryDate =
+      expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32))
+        ? new Date(expiry.mul(1000).toString())
+        : undefined
 
     return {
-      fuseObj,
+      ...fuseObj,
       expiryDate,
       rawFuses: fuses,
       owner,

package/src/functions/registerName.test.ts

@@ -23,6 +23,8 @@ describe('registerName', () => {
     await revert()
   })
   it('should return a registration transaction and succeed', async () => {
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+
     const name = 'cool-swag.eth'
     const duration = 31536000
     const { customData, ...commitPopTx } =
@@ -37,14 +39,12 @@ describe('registerName', () => {
     await provider.send('evm_increaseTime', [60])
     await provider.send('evm_mine', [])
 
-    const { secret, wrapperExpiry } = customData!
+    const { secret } = customData!
 
-    const controller = await ensInstance.contracts!.getEthRegistrarController()!
     const [price] = await controller.rentPrice(name, duration)
 
     const tx = await ensInstance.registerName(name, {
       secret,
-      wrapperExpiry,
       duration,
       owner: accounts[1],
       addressOrIndex: accounts[1],

package/src/functions/renewNames.ts

@@ -1,39 +1,33 @@
 import { BigNumber, BigNumberish } from '@ethersproject/bignumber/lib/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)
+}