@ensdomains/ensjs 3.0.0-alpha.13 → 3.0.0-alpha.16

package/dist/esm/functions/getFuses.js

@@ -1,32 +1,21 @@
 import { BigNumber } from 'ethers';
-import { testable as fuseEnums } from '../utils/fuses';
+import { fuseEnum } from '../utils/fuses';
 import { namehash } from '../utils/normalise';
-const NameSafety = [
-    'Safe',
-    'RegistrantNotWrapped',
-    'ControllerNotWrapped',
-    'SubdomainReplacementAllowed',
-    'Expired',
-];
 const raw = async ({ contracts }, name) => {
     const nameWrapper = await contracts?.getNameWrapper();
     return {
         to: nameWrapper.address,
-        data: nameWrapper.interface.encodeFunctionData('getFuses', [
-            namehash(name),
-        ]),
+        data: nameWrapper.interface.encodeFunctionData('getData', [namehash(name)]),
     };
 };
-const decode = async ({ contracts }, data, name) => {
+const decode = async ({ contracts }, data) => {
     const nameWrapper = await contracts?.getNameWrapper();
     try {
-        const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const { owner, fuses: _fuses, expiry, } = nameWrapper.interface.decodeFunctionResult('getData', data);
         const fuses = BigNumber.from(_fuses);
-        const fuseObj = Object.fromEntries(Object.keys(fuseEnums).map((fuseEnum) => [
-            fuseEnum
-                .toLowerCase()
-                .replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', '')),
-            fuses.and(fuseEnums[fuseEnum]).gt(0),
+        const fuseObj = Object.fromEntries(Object.keys(fuseEnum).map((fuse) => [
+            fuse,
+            fuses.and(fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
             fuseObj.canDoEverything = true;
@@ -39,9 +28,11 @@ const decode = async ({ contracts }, data, name) => {
             fuseObj,
             expiryDate,
             rawFuses: fuses,
+            owner,
         };
     }
-    catch {
+    catch (e) {
+        console.error('Error decoding fuses data: ', e);
         return;
     }
 };

package/dist/esm/functions/getSpecificRecord.d.ts

@@ -52,21 +52,21 @@ export declare const getText: {
     decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
 };
 export declare const _getAddr: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number, bypassFormat?: boolean) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;
 };
 export declare const getAddr: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number | undefined) => Promise<{
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;

package/dist/esm/index.d.ts

@@ -75,6 +75,16 @@ export declare class ENS {
     contracts?: ContractManager;
     getContractAddress: (networkId: SupportedNetworkId) => import("./contracts/getContractAddress").ContractAddressFetch;
     gqlInstance: GqlManager;
+    fuses: {
+        CAN_DO_EVERYTHING: number;
+        CANNOT_UNWRAP: 1;
+        CANNOT_BURN_FUSES: 2;
+        CANNOT_TRANSFER: 4;
+        CANNOT_SET_RESOLVER: 8;
+        CANNOT_SET_TTL: 16;
+        CANNOT_CREATE_SUBDOMAIN: 32;
+        PARENT_CANNOT_CONTROL: 64;
+    };
     constructor(options?: ENSOptions);
     /**
      * Checks for an initial provider and if it exists, sets it as the provider
@@ -229,12 +239,13 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
             fuseObj: {
                 [k: string]: boolean;
             };
             expiryDate: Date;
             rawFuses: ethers.BigNumber;
+            owner: any;
         } | undefined>;
     }>;
     getHistory: (name: string) => Promise<{

package/dist/esm/index.js

@@ -3,6 +3,7 @@ import { getContractAddress as _getContractAddress } from './contracts/getContra
 import GqlManager from './GqlManager';
 import singleCall from './utils/singleCall';
 import writeTx from './utils/writeTx';
+import fuseEnum from './utils/fuses';
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -13,6 +14,7 @@ export class ENS {
     constructor(options) {
         this.getContractAddress = _getContractAddress;
         this.gqlInstance = new GqlManager();
+        this.fuses = fuseEnum;
         /**
          * Checks for an initial provider and if it exists, sets it as the provider
          * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed

package/dist/esm/utils/fuses.d.ts

@@ -1,20 +1,21 @@
-export declare const testable: {
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
+export declare const fuseEnum: {
+    readonly CANNOT_UNWRAP: 1;
+    readonly CANNOT_BURN_FUSES: 2;
+    readonly CANNOT_TRANSFER: 4;
+    readonly CANNOT_SET_RESOLVER: 8;
+    readonly CANNOT_SET_TTL: 16;
+    readonly CANNOT_CREATE_SUBDOMAIN: 32;
+    readonly PARENT_CANNOT_CONTROL: 64;
 };
-declare const _default: {
+export declare const unnamedFuses: readonly [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296];
+declare const fullFuseEnum: {
     CAN_DO_EVERYTHING: number;
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
+    CANNOT_UNWRAP: 1;
+    CANNOT_BURN_FUSES: 2;
+    CANNOT_TRANSFER: 4;
+    CANNOT_SET_RESOLVER: 8;
+    CANNOT_SET_TTL: 16;
+    CANNOT_CREATE_SUBDOMAIN: 32;
+    PARENT_CANNOT_CONTROL: 64;
 };
-export default _default;
+export default fullFuseEnum;

package/dist/esm/utils/fuses.js

@@ -6,7 +6,7 @@ const CANNOT_SET_TTL = 16;
 const CANNOT_CREATE_SUBDOMAIN = 32;
 const PARENT_CANNOT_CONTROL = 64;
 const CAN_DO_EVERYTHING = 0;
-export const testable = {
+export const fuseEnum = {
     CANNOT_UNWRAP,
     CANNOT_BURN_FUSES,
     CANNOT_TRANSFER,
@@ -15,7 +15,13 @@ export const testable = {
     CANNOT_CREATE_SUBDOMAIN,
     PARENT_CANNOT_CONTROL,
 };
-export default {
-    ...testable,
+export const unnamedFuses = [
+    128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+    524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+    134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+];
+const fullFuseEnum = {
+    ...fuseEnum,
     CAN_DO_EVERYTHING,
 };
+export default fullFuseEnum;

package/dist/esm/utils/wrapperExpiry.d.ts

@@ -2,4 +2,4 @@ import { BigNumber } from 'ethers';
 import { ENSArgs } from '..';
 export declare type Expiry = string | number | Date | BigNumber;
 export declare const MAX_EXPIRY: BigNumber;
-export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry | undefined) => Promise<BigNumber>;
+export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.13",
+  "version": "3.0.0-alpha.16",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",

package/src/GqlManager.test.ts

@@ -1,7 +1,7 @@
+import { parse, print, visit } from 'graphql'
 import traverse from 'traverse'
-import { visit, parse } from 'graphql'
 
-import { requestMiddleware, responseMiddleware, enter } from './GqlManager'
+import { requestMiddleware, responseMiddleware } from './GqlManager'
 import { namehash } from './utils/normalise'
 
 describe('GqlManager', () => {
@@ -153,8 +153,9 @@ query getNames($id: ID!, $expiryDate: Int) {
 
   describe('requestMiddleware', () => {
     it('should add id to a SelectionSet if name is present and id is not', () => {
-      const result = requestMiddleware(visit, parse)(mockRequest)
-      expect(result.body.includes('id')).toBe(true)
+      const result = requestMiddleware(visit, parse, print)(mockRequest)
+      const body = result.body as string
+      expect(body.match(/domain.*id.*id.*domains.*id.*id/)?.length).toBe(1)
     })
   })
   describe('responseMiddleware', () => {

package/src/GqlManager.ts

@@ -1,10 +1,17 @@
-// @ts-nocheck
+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',
+  kind: 'Field' as Kind.FIELD,
   name: {
-    kind: 'Name',
+    kind: 'Name' as Kind.NAME,
     value: selection,
   },
   arguments: [],
@@ -13,47 +20,58 @@ const generateSelection = (selection: any) => ({
   selectionSet: undefined,
 })
 
-export const enter = (node: any) => {
-  if (node.kind === 'SelectionSet') {
-    const id = node.selections.find((x) => x.name && x.name.value === 'id')
-    const name = node.selections.find((x) => x.name && x.name.value === 'name')
+export const enter = (node: SelectionSetNode) => {
+  let hasName = false
+  let hasId = false
 
-    if (!id && name) {
-      node.selections = [...node.selections, generateSelection('id')]
-      return node
+  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) {
+    node.selections = [...node.selections, generateSelection('id')]
+    return node
+  }
 }
 
-export const requestMiddleware = (visit, parse) => (request: any) => {
-  const requestBody = JSON.parse(request.body)
-  const rawQuery = requestBody.query
-  const parsedQuery = parse(rawQuery)
-  const updatedQuery = visit(parsedQuery, { enter })
-  const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body }
+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, {
+      SelectionSet: {
+        enter,
+      },
+    })
 
-  return {
-    ...request,
-    body: JSON.stringify(updatedBody),
+    return {
+      ...request,
+      body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
+    }
   }
-}
 
-export const responseMiddleware = (traverse) => (response: any) => {
-  traverse(response).forEach(function (responseItem: any) {
-    if (responseItem instanceof Object && responseItem.name) {
-      //Name already in hashed form
-      if (responseItem.name && responseItem.name.includes('[')) {
-        return
-      }
+export const responseMiddleware =
+  (traverse: typeof Traverse) => (response: any) => {
+    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 })
+        const hashedName = namehash(responseItem.name)
+        if (responseItem.id !== hashedName) {
+          this.update({ ...responseItem, name: hashedName, invalidName: true })
+        }
       }
-    }
-  })
-  return response
-}
+    })
+    return response
+  }
 
 export default class GqlManager {
   public gql: any = () => null
@@ -61,14 +79,14 @@ export default class GqlManager {
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const [imported, traverse, { visit, parse }] = await Promise.all([
+      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),
+        requestMiddleware: requestMiddleware(visit, parse, print),
         responseMiddleware: responseMiddleware(traverse.default),
       })
       this.gql = imported.gql

package/src/functions/burnFuses.test.ts

@@ -21,20 +21,128 @@ describe('burnFuses', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should return a burnFuses transaction and succeed', async () => {
-    const tx = await ENSInstance.burnFuses('wrapped.eth', {
-      fusesToBurn: {
-        cannotUnwrap: true,
-        cannotCreateSubdomain: true,
-        cannotSetTtl: true,
-      },
-      addressOrIndex: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    await tx.wait()
-
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
-    expect(fuses).toBe(113)
+  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.getFuses(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.getFuses(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.getFuses(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.getFuses(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.')
+      }
+    })
   })
 })

package/src/functions/burnFuses.ts

@@ -1,21 +1,112 @@
 import { ENSArgs } from '..'
-import { FuseOptions } from '../@types/FuseOptions'
-import generateFuseInput from '../utils/generateFuseInput'
+import { fuseEnum, unnamedFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
-export default async function (
+type FuseObj = typeof fuseEnum
+type UnnamedFuseType = typeof unnamedFuses
+type Fuse = keyof FuseObj
+type NamedFuseValues = FuseObj[Fuse]
+type UnnamedFuseValues = UnnamedFuseType[number]
+
+// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
+type FuseArrayPossibilities =
+  | [Fuse]
+  | [Fuse, Fuse]
+  | [Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+// CLAUSE A: This extension unwraps the type as a fuse tuple.
+type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
+  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.
+    A extends [infer Head, ...infer Tail]
+    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.
+      Head extends B
+      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.
+        []
+      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.
+        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]
+    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.
+      A
+  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
+    []
+
+type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
+  namedFusesToBurn: FusesWithoutDuplicates<A>
+}
+
+type FusePropsUnnamedArray = {
+  unnamedFusesToBurn: UnnamedFuseValues[]
+}
+
+type FusePropsNumber = {
+  fuseNumberToBurn: number
+}
+
+type FuseProps<A extends FuseArrayPossibilities> =
+  | (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>)
+  | FusePropsNumber
+
+export default async function <A extends FuseArrayPossibilities>(
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  {
-    fusesToBurn,
-  }: {
-    fusesToBurn: FuseOptions
-  },
+  props: FuseProps<A>,
 ) {
+  const isNumber = 'fuseNumberToBurn' in props
+  const hasNamedArray = 'namedFusesToBurn' in props
+  const hasUnnamedArray = 'unnamedFusesToBurn' in props
+
+  let encodedFuses: number = 0
+
+  if (isNumber) {
+    if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${
+          props.fuseNumberToBurn
+        } was too ${props.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
+      )
+    } else if (props.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`,
+      )
+    }
+    encodedFuses = props.fuseNumberToBurn
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error('Please provide fuses to burn')
+    }
+    if (hasNamedArray) {
+      for (const fuse of props.namedFusesToBurn!) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`)
+        }
+        encodedFuses |= fuseEnum[fuse]
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of props.unnamedFusesToBurn!) {
+        if (!unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
+          )
+        }
+        encodedFuses |= fuse
+      }
+    }
+  }
+
   const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
   const hash = namehash(name)
 
-  const encodedFuses = generateFuseInput(fusesToBurn)
-
   return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
 }