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

package/src/GqlManager.ts

@@ -1,11 +1,99 @@
+import type {
+  Kind,
+  parse as Parse,
+  print as Print,
+  SelectionSetNode,
+  visit as Visit,
+} from 'graphql'
+import type Traverse from 'traverse'
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field' as Kind.FIELD,
+  name: {
+    kind: 'Name' as Kind.NAME,
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: SelectionSetNode) => {
+  let hasName = false
+  let hasId = false
+
+  for (const selection of node.selections) {
+    if ('name' in selection) {
+      if (selection.name.value === 'name') hasName = true
+      else if (selection.name.value === 'id') hasId = true
+    }
+  }
+
+  if (hasName && !hasId) {
+    // eslint-disable-next-line no-param-reassign
+    node.selections = [...node.selections, generateSelection('id')]
+    return node
+  }
+}
+
+export const requestMiddleware =
+  (visit: typeof Visit, parse: typeof Parse, print: typeof Print) =>
+  (request: any) => {
+    const requestBody = JSON.parse(request.body)
+    const rawQuery = requestBody.query
+    const parsedQuery = parse(rawQuery)
+    const updatedQuery = visit(parsedQuery, {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      SelectionSet: {
+        enter,
+      },
+    })
+
+    return {
+      ...request,
+      body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
+    }
+  }
+
+export const responseMiddleware =
+  (traverse: typeof Traverse) => (response: any) => {
+    // eslint-disable-next-line func-names
+    traverse(response).forEach(function (responseItem: any) {
+      if (responseItem instanceof Object && responseItem.name) {
+        // Name already in hashed form
+        if (responseItem.name && responseItem.name.includes('[')) {
+          return
+        }
+
+        const hashedName = namehash(responseItem.name)
+        if (responseItem.id !== hashedName) {
+          this.update({ ...responseItem, name: hashedName, invalidName: true })
+        }
+      }
+    })
+    return response
+  }
+
 export default class GqlManager {
+  // eslint-disable-next-line class-methods-use-this
   public gql: any = () => null
+
   public client?: any | null = null
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const imported = await import('graphql-request')
-      this.client = new imported.GraphQLClient(url)
+      const [imported, traverse, { visit, parse, print }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse, print),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
       this.gql = imported.gql
     } else {
       this.client = null

package/src/contracts/bulkRenewal.ts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers'
+import { BulkRenewal__factory } from '../generated/factories/BulkRenewal__factory'
+
+// Use a higher-order function to overide the address that is passed in from getContractAddress()
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  BulkRenewal__factory.connect(address, provider)

package/src/contracts/dnsRegistrar.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { DNSRegistrar__factory } from '../generated/factories/DNSRegistrar__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  DNSRegistrar__factory.connect(address, provider)

package/src/contracts/getContractAddress.ts

@@ -4,22 +4,35 @@ const addresses: Record<
   ContractName,
   Partial<Record<SupportedNetworkId, string>> | string
 > = {
+  /* eslint-disable @typescript-eslint/naming-convention */
   BaseRegistrarImplementation: {
     '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
   },
+  DNSRegistrar: {
+    '1': '0x58774Bb8acD458A640aF0B88238369A167546ef2',
+    '3': '0xdB328BA5FEcb432AF325Ca59E3778441eF5aa14F',
+    '5': '0x8edc487D26F6c8Fa76e032066A3D4F87E273515d',
+  },
   ETHRegistrarController: {
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '3': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '5': '0x9C51161bA2FB02Cc0a403332B607117685f34831',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
-  NameWrapper: '0x0000000000000000000000000000000000000000',
+  NameWrapper: {
+    '1': '0x0000000000000000000000000000000000000000',
+    '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
+    '4': '0x0000000000000000000000000000000000000000',
+    '5': '0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8',
+  },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
+    '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
+    '5': '0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852',
   },
   ENSRegistryWithFallback: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
@@ -29,11 +42,21 @@ const addresses: Record<
   },
   ReverseRegistrar: {
     '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
+    '3': '0x806246b52f8cB61655d3038c58D2f63Aa55d4edE',
+    '5': '0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48',
   },
   UniversalResolver: {
     '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
+    '3': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
     '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
+    '5': '0x687c30Cc44bFA39A1449e86E172BF002E7b3f0b0',
+  },
+  BulkRenewal: {
+    '1': '0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035',
+    '3': '0x051b02245D826757EfaF5C6209D4D79FB39FBC45',
+    '5': '0xa9e1df95a79C768aA435805b28E1B54Bb5ead063',
   },
+  /* eslint-enable @typescript-eslint/naming-convention */
 }
 
 export type ContractAddressFetch = (contractName: ContractName) => string

package/src/contracts/index.ts

@@ -4,14 +4,17 @@ import getEthRegistrarController from './ethRegistrarController'
 import { ContractAddressFetch } from './getContractAddress'
 import getMulticall from './multicall'
 import getNameWrapper from './nameWrapper'
+import getDNSRegistrar from './dnsRegistrar'
 import getPublicResolver from './publicResolver'
 import getRegistry from './registry'
 import getReverseRegistrar from './reverseRegistrar'
 import { ContractName } from './types'
 import getUniversalResolver from './universalResolver'
+import getBulkRenewal from './bulkRenewal'
 
 export default class ContractManager {
   private provider: ethers.providers.Provider
+
   private fetchAddress: ContractAddressFetch
 
   constructor(
@@ -25,7 +28,7 @@ export default class ContractManager {
   private generateContractGetter = <C extends (...args: any) => any>(
     name: ContractName,
     func: C,
-  ) => {
+  ): ((passedProvider?: any, address?: string) => Promise<ReturnType<C>>) => {
     return async (
       passedProvider?: any,
       address?: string,
@@ -40,29 +43,46 @@ export default class ContractManager {
     'PublicResolver',
     getPublicResolver,
   )
+
   public getUniversalResolver = this.generateContractGetter(
     'UniversalResolver',
     getUniversalResolver,
   )
+
   public getRegistry = this.generateContractGetter(
     'ENSRegistryWithFallback',
     getRegistry,
   )
+
   public getReverseRegistrar = this.generateContractGetter(
     'ReverseRegistrar',
     getReverseRegistrar,
   )
+
   public getNameWrapper = this.generateContractGetter(
     'NameWrapper',
     getNameWrapper,
   )
+
+  public getDNSRegistrar = this.generateContractGetter(
+    'DNSRegistrar',
+    getDNSRegistrar,
+  )
+
   public getBaseRegistrar = this.generateContractGetter(
     'BaseRegistrarImplementation',
     getBaseRegistrar,
   )
+
   public getEthRegistrarController = this.generateContractGetter(
     'ETHRegistrarController',
     getEthRegistrarController,
   )
+
   public getMulticall = this.generateContractGetter('Multicall', getMulticall)
+
+  public getBulkRenewal = this.generateContractGetter(
+    'BulkRenewal',
+    getBulkRenewal,
+  )
 }

package/src/contracts/multicall.ts

@@ -1,24 +1,5 @@
 import { ethers } from 'ethers'
 import { Multicall__factory } from '../generated/factories/Multicall__factory'
 
-const ABI = [
-  'function aggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes[] returnData)',
-  'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-  'function aggregate3Value(tuple(address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-  'function blockAndAggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
-  'function getBasefee() view returns (uint256 basefee)',
-  'function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)',
-  'function getBlockNumber() view returns (uint256 blockNumber)',
-  'function getChainId() view returns (uint256 chainid)',
-  'function getCurrentBlockCoinbase() view returns (address coinbase)',
-  'function getCurrentBlockDifficulty() view returns (uint256 difficulty)',
-  'function getCurrentBlockGasLimit() view returns (uint256 gaslimit)',
-  'function getCurrentBlockTimestamp() view returns (uint256 timestamp)',
-  'function getEthBalance(address addr) view returns (uint256 balance)',
-  'function getLastBlockHash() view returns (bytes32 blockHash)',
-  'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-  'function tryBlockAndAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
-]
-
 export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
   Multicall__factory.connect(address, provider)

package/src/contracts/types.ts

@@ -5,7 +5,9 @@ export type ContractName =
   | 'ETHRegistrarController'
   | 'Multicall'
   | 'NameWrapper'
+  | 'DNSRegistrar'
   | 'PublicResolver'
   | 'ENSRegistryWithFallback'
   | 'ReverseRegistrar'
   | 'UniversalResolver'
+  | 'BulkRenewal'

package/src/functions/batch.test.ts

@@ -1,32 +1,32 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('batch', () => {
   it('should batch calls together', async () => {
-    const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
-      ENSInstance.getAddr.batch('jefflau.eth'),
-      ENSInstance.getName.batch('0x866B3c4994e1416B7C738B9818b31dC246b95eEE'),
+    const result = await ensInstance.batch(
+      ensInstance.getText.batch('with-profile.eth', 'description'),
+      ensInstance.getAddr.batch('with-profile.eth'),
+      ensInstance.getName.batch('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'),
     )
     expect(result).toBeTruthy()
     if (result) {
       expect(result[0]).toBe('Hello2')
-      expect(result[1]).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      expect(result[1]).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
       expect(result[2]).toMatchObject({
-        name: 'jefflau.eth',
+        name: 'with-profile.eth',
         match: true,
       })
     }
   })
   it('should batch a single call', async () => {
-    const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
+    const result = await ensInstance.batch(
+      ensInstance.getText.batch('with-profile.eth', 'description'),
     )
     expect(result).toBeTruthy()
     if (result) {

package/src/functions/batch.ts

@@ -5,11 +5,11 @@ const raw = async (
   ...items: BatchFunctionResult<RawFunction>[]
 ) => {
   const rawDataArr: { to: string; data: string }[] = await Promise.all(
-    items.map(({ args, raw }, i: number) => {
-      if (!raw) {
+    items.map(({ args, raw: rawRef }, i: number) => {
+      if (!rawRef) {
         throw new Error(`Function ${i} is not batchable`)
       }
-      return raw(...args)
+      return rawRef(...args)
     }),
   )
   return multicallWrapper.raw(rawDataArr)

package/src/functions/batchWrappers.test.ts

@@ -1,31 +1,31 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('batchWrappers', () => {
   it('should batch calls together', async () => {
-    const batch = await ENSInstance.resolverMulticallWrapper.raw([
-      await ENSInstance._getText.raw('jefflau.eth', 'description'),
-      await ENSInstance._getText.raw('jefflau.eth', 'url'),
-      await ENSInstance._getAddr.raw('jefflau.eth'),
+    const batch = await ensInstance.resolverMulticallWrapper.raw([
+      await ensInstance._getText.raw('with-profile.eth', 'description'),
+      await ensInstance._getText.raw('with-profile.eth', 'url'),
+      await ensInstance._getAddr.raw('with-profile.eth'),
     ])
-    const universalResponse = await ENSInstance.universalWrapper(
-      'jefflau.eth',
+    const universalResponse = await ensInstance.universalWrapper(
+      'with-profile.eth',
       batch.data,
     )
-    const [batchDecoded] = await ENSInstance.resolverMulticallWrapper.decode(
+    const [batchDecoded] = await ensInstance.resolverMulticallWrapper.decode(
       universalResponse?.data,
     )
-    const decoded1 = await ENSInstance._getText.decode(batchDecoded[0])
-    const decoded2 = await ENSInstance._getText.decode(batchDecoded[1])
-    const decoded3 = await ENSInstance._getAddr.decode(batchDecoded[2])
+    const decoded1 = await ensInstance._getText.decode(batchDecoded[0])
+    const decoded2 = await ensInstance._getText.decode(batchDecoded[1])
+    const decoded3 = await ensInstance._getAddr.decode(batchDecoded[2])
     expect(decoded1).toBe('Hello2')
     expect(decoded2).toBe('twitter.com')
-    expect(decoded3).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+    expect(decoded3).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
   })
 })

package/src/functions/batchWrappers.ts

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import ccipLookup from '../utils/ccip'
 import { hexEncodeName } from '../utils/hexEncodedName'
 
 export const universalWrapper = {
@@ -11,16 +12,16 @@ export const universalWrapper = {
     const universalResolver = await contracts?.getUniversalResolver()!
     return {
       to: universalResolver.address,
-      data: universalResolver.interface.encodeFunctionData('resolve', [
-        hexEncodeName(name),
-        data,
-      ]),
+      data: universalResolver.interface.encodeFunctionData(
+        'resolve(bytes,bytes)',
+        [hexEncodeName(name), data],
+      ),
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
     const universalResolver = await contracts?.getUniversalResolver()!
     const response = universalResolver.interface.decodeFunctionResult(
-      'resolve',
+      'resolve(bytes,bytes)',
       data,
     )
     if (!response || !response[0]) {
@@ -58,7 +59,7 @@ export const resolverMulticallWrapper = {
 }
 
 export const multicallWrapper = {
-  raw: async function (
+  async raw(
     { contracts }: ENSArgs<'contracts'>,
     transactions: ethers.providers.TransactionRequest[],
     requireSuccess: boolean = false,
@@ -75,7 +76,11 @@ export const multicallWrapper = {
       ]),
     }
   },
-  decode: async function ({ contracts }: ENSArgs<'contracts'>, data: string) {
+  async decode(
+    { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+    data: string,
+    transactions: ethers.providers.TransactionRequest[],
+  ) {
     if (!data) return
     const multicall = await contracts?.getMulticall()!
     try {
@@ -83,8 +88,34 @@ export const multicallWrapper = {
         'tryAggregate',
         data,
       )
-      return result
-    } catch {
+      const ccipChecked = await Promise.all(
+        (result as [boolean, string][]).map(
+          async ([success, returnData], i) => {
+            let newArr: [boolean, string] = [success, returnData]
+            // OffchainLookup(address,string[],bytes,bytes4,bytes)
+            if (!success && returnData.startsWith('0x556f1830')) {
+              try {
+                const newData = await ccipLookup(
+                  provider!,
+                  transactions[i],
+                  returnData,
+                )
+                if (newData) {
+                  newArr = [true, newData]
+                }
+              } catch {}
+            }
+            return {
+              ...newArr,
+              success: newArr[0],
+              returnData: newArr[1],
+            }
+          },
+        ),
+      )
+      return ccipChecked
+    } catch (e: any) {
+      console.error(e)
       return
     }
   },

package/src/functions/burnFuses.test.ts

@@ -1,15 +1,15 @@
-import { BigNumber, ethers } from 'ethers'
+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())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -21,24 +21,128 @@ describe('burnFuses', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should return a burnFuses transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-
-    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
-      cannotUnwrap: true,
-      cannotCreateSubdomain: true,
-      cannotSetTtl: true,
-    })
-    expect(tx).toBeTruthy()
-    await tx.wait()
-
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
-    const fuseBN = result.fuses as BigNumber
-    expect(fuseBN.toHexString()).toBe('0x71')
+  describe('Array', () => {
+    it('should return a burnFuses transaction from a named fuse array and succeed', async () => {
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: [
+          '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'))
+      expect(fuses).toBe(113)
+    })
+    it('should return a burnFuses transaction from an unnamed fuse array and succeed', async () => {
+      const tx0 = await ensInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx0).toBeTruthy()
+      await tx0.wait()
+
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        unnamedFusesToBurn: [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'))
+      expect(fuses).toBe(961)
+    })
+    it('should return a burnFuses transaction from both an unnamed and named fuse array and succeed', async () => {
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: [
+          'CANNOT_UNWRAP',
+          'CANNOT_CREATE_SUBDOMAIN',
+          'CANNOT_SET_TTL',
+        ],
+        unnamedFusesToBurn: [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'))
+      expect(fuses).toBe(1009)
+    })
+    it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          unnamedFusesToBurn: [64] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          '64 is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.',
+        )
+      }
+    })
+    it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          namedFusesToBurn: ['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 burnFuses transaction from a number and succeed', async () => {
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        fuseNumberToBurn: 49,
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      expect(fuses).toBe(113)
+    })
+    it('should throw an error if the number is too high', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: 4294967297,
+        })
+        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.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: -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.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: 7.5,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('Fuse number must be an integer, 7.5 was not.')
+      }
+    })
   })
 })