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

package/dist/cjs/contracts/index.d.ts

@@ -5,12 +5,12 @@ export default class ContractManager {
     private fetchAddress;
     constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
     private generateContractGetter;
-    getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
-    getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ENSRegistry>;
-    getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
-    getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
+    getPublicResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").PublicResolver>;
+    getUniversalResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").UniversalResolver>;
+    getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated").ENSRegistry>;
+    getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").ReverseRegistrar>;
+    getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated").NameWrapper>;
+    getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").BaseRegistrarImplementation>;
+    getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated").Multicall>;
 }

package/dist/cjs/functions/burnFuses.d.ts

@@ -1,5 +1,32 @@
 import { ENSArgs } from '..';
-import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
-    fusesToBurn: FuseOptions;
-}): Promise<import("ethers").PopulatedTransaction>;
+import { fuseEnum, unnamedFuses } from '../utils/fuses';
+declare type FuseObj = typeof fuseEnum;
+declare type UnnamedFuseType = typeof unnamedFuses;
+declare type Fuse = keyof FuseObj;
+declare type UnnamedFuseValues = UnnamedFuseType[number];
+declare 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.
+ */
+declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
+] : [
+    Head,
+    ...FusesWithoutDuplicates<Tail, Head | B>
+] : A : [
+];
+declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
+    namedFusesToBurn: FusesWithoutDuplicates<A>;
+};
+declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+declare type FusePropsNumber = {
+    fuseNumberToBurn: number;
+};
+declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
+export {};

package/dist/cjs/functions/burnFuses.js

@@ -1,14 +1,44 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+const fuses_1 = require("../utils/fuses");
 const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, signer }, name, { fusesToBurn, }) {
+async function default_1({ contracts, signer }, name, props) {
+    const isNumber = 'fuseNumberToBurn' in props;
+    const hasNamedArray = 'namedFusesToBurn' in props;
+    const hasUnnamedArray = 'unnamedFusesToBurn' in props;
+    let encodedFuses = 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 fuses_1.fuseEnum)) {
+                    throw new Error(`${fuse} is not a valid named fuse.`);
+                }
+                encodedFuses |= fuses_1.fuseEnum[fuse];
+            }
+        }
+        if (hasUnnamedArray) {
+            for (const fuse of props.unnamedFusesToBurn) {
+                if (!fuses_1.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 = (0, normalise_1.namehash)(name);
-    const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
     return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
 }
 exports.default = default_1;

package/dist/cjs/functions/getFuses.d.ts

@@ -5,12 +5,13 @@ declare const _default: {
         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: BigNumber;
+        owner: any;
     } | undefined>;
 };
 export default _default;

package/dist/cjs/functions/getFuses.js

@@ -3,32 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const fuses_1 = require("../utils/fuses");
 const normalise_1 = require("../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', [
-            (0, normalise_1.namehash)(name),
-        ]),
+        data: nameWrapper.interface.encodeFunctionData('getData', [(0, normalise_1.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 = ethers_1.BigNumber.from(_fuses);
-        const fuseObj = Object.fromEntries(Object.keys(fuses_1.testable).map((fuseEnum) => [
-            fuseEnum
-                .toLowerCase()
-                .replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', '')),
-            fuses.and(fuses_1.testable[fuseEnum]).gt(0),
+        const fuseObj = Object.fromEntries(Object.keys(fuses_1.fuseEnum).map((fuse) => [
+            fuse,
+            fuses.and(fuses_1.fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
             fuseObj.canDoEverything = true;
@@ -41,9 +30,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/cjs/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/cjs/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/cjs/index.js

@@ -32,6 +32,7 @@ const getContractAddress_1 = require("./contracts/getContractAddress");
 const GqlManager_1 = __importDefault(require("./GqlManager"));
 const singleCall_1 = __importDefault(require("./utils/singleCall"));
 const writeTx_1 = __importDefault(require("./utils/writeTx"));
+const fuses_1 = __importDefault(require("./utils/fuses"));
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -46,6 +47,7 @@ class ENS {
     contracts;
     getContractAddress = getContractAddress_1.getContractAddress;
     gqlInstance = new GqlManager_1.default();
+    fuses = fuses_1.default;
     constructor(options) {
         this.options = options;
         this.getContractAddress = options?.getContractAddress || getContractAddress_1.getContractAddress;

package/dist/cjs/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/cjs/utils/fuses.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testable = void 0;
+exports.unnamedFuses = exports.fuseEnum = void 0;
 const CANNOT_UNWRAP = 1;
 const CANNOT_BURN_FUSES = 2;
 const CANNOT_TRANSFER = 4;
@@ -9,7 +9,7 @@ const CANNOT_SET_TTL = 16;
 const CANNOT_CREATE_SUBDOMAIN = 32;
 const PARENT_CANNOT_CONTROL = 64;
 const CAN_DO_EVERYTHING = 0;
-exports.testable = {
+exports.fuseEnum = {
     CANNOT_UNWRAP,
     CANNOT_BURN_FUSES,
     CANNOT_TRANSFER,
@@ -18,7 +18,13 @@ exports.testable = {
     CANNOT_CREATE_SUBDOMAIN,
     PARENT_CANNOT_CONTROL,
 };
-exports.default = {
-    ...exports.testable,
+exports.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 = {
+    ...exports.fuseEnum,
     CAN_DO_EVERYTHING,
 };
+exports.default = fullFuseEnum;

package/dist/cjs/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/dist/esm/contracts/index.d.ts

@@ -5,12 +5,12 @@ export default class ContractManager {
     private fetchAddress;
     constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
     private generateContractGetter;
-    getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
-    getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ENSRegistry>;
-    getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
-    getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
+    getPublicResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").PublicResolver>;
+    getUniversalResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").UniversalResolver>;
+    getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated").ENSRegistry>;
+    getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").ReverseRegistrar>;
+    getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated").NameWrapper>;
+    getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").BaseRegistrarImplementation>;
+    getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated").Multicall>;
 }

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

@@ -1,5 +1,32 @@
 import { ENSArgs } from '..';
-import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
-    fusesToBurn: FuseOptions;
-}): Promise<import("ethers").PopulatedTransaction>;
+import { fuseEnum, unnamedFuses } from '../utils/fuses';
+declare type FuseObj = typeof fuseEnum;
+declare type UnnamedFuseType = typeof unnamedFuses;
+declare type Fuse = keyof FuseObj;
+declare type UnnamedFuseValues = UnnamedFuseType[number];
+declare 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.
+ */
+declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
+] : [
+    Head,
+    ...FusesWithoutDuplicates<Tail, Head | B>
+] : A : [
+];
+declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
+    namedFusesToBurn: FusesWithoutDuplicates<A>;
+};
+declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+declare type FusePropsNumber = {
+    fuseNumberToBurn: number;
+};
+declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
+export {};

package/dist/esm/functions/burnFuses.js

@@ -1,8 +1,41 @@
-import generateFuseInput from '../utils/generateFuseInput';
+import { fuseEnum, unnamedFuses } from '../utils/fuses';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
+export default async function ({ contracts, signer }, name, props) {
+    const isNumber = 'fuseNumberToBurn' in props;
+    const hasNamedArray = 'namedFusesToBurn' in props;
+    const hasUnnamedArray = 'unnamedFusesToBurn' in props;
+    let encodedFuses = 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);
 }

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

@@ -5,12 +5,13 @@ declare const _default: {
         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: BigNumber;
+        owner: any;
     } | undefined>;
 };
 export default _default;

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.14",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",

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)
 }

package/src/functions/getFuses.test.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
@@ -9,6 +9,22 @@ let provider: ethers.providers.JsonRpcProvider
 let accounts: string[]
 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,
+    canDoEverything: true,
+  },
+  owner: '0x0000000000000000000000000000000000000000',
+  rawFuses: BigNumber.from(0),
+}
+
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
@@ -26,9 +42,11 @@ afterAll(async () => {
 })
 
 describe('getFuses', () => {
-  it('should return null for an unwrapped name', async () => {
+  it('should return default data for an unwrapped name', async () => {
     const result = await ENSInstance.getFuses('with-profile.eth')
-    expect(result).toBeUndefined()
+    expect({ ...result, expiryDate: result?.expiryDate.toString() }).toEqual(
+      unwrappedNameDefault,
+    )
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
@@ -47,11 +65,11 @@ describe('getFuses', () => {
   })
   it('should return with other correct fuses', async () => {
     const tx = await ENSInstance.burnFuses('wrapped.eth', {
-      fusesToBurn: {
-        cannotUnwrap: true,
-        cannotSetTtl: true,
-        cannotCreateSubdomain: true,
-      },
+      namedFusesToBurn: [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+      ],
       addressOrIndex: 1,
     })
     await tx.wait()
@@ -60,13 +78,13 @@ describe('getFuses', () => {
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj).toMatchObject({
-        cannotUnwrap: true,
-        cannotBurnFuses: false,
-        cannotTransfer: false,
-        cannotSetResolver: false,
-        cannotSetTtl: true,
-        cannotCreateSubdomain: true,
-        parentCannotControl: true,
+        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,
         canDoEverything: false,
       })
       expect(result.rawFuses.toHexString()).toBe('0x71')

package/src/functions/getFuses.ts

@@ -1,48 +1,34 @@
 import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
-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 }: ENSArgs<'contracts'>, name: string) => {
   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 }: ENSArgs<'contracts'>,
   data: string,
-  name: string,
 ) => {
   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: string) =>
-            group.toUpperCase().replace('-', '').replace('_', ''),
-          ),
-        fuses.and(fuseEnums[fuseEnum as keyof typeof fuseEnums]).gt(0),
+      Object.keys(fuseEnum).map((fuse) => [
+        fuse,
+        fuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
       ]),
     )
 
@@ -58,8 +44,10 @@ const decode = async (
       fuseObj,
       expiryDate,
       rawFuses: fuses,
+      owner,
     }
-  } catch {
+  } catch (e) {
+    console.error('Error decoding fuses data: ', e)
     return
   }
 }

package/src/index.ts

@@ -46,6 +46,7 @@ import type wrapName from './functions/wrapName'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
+import fuseEnum from './utils/fuses'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -157,6 +158,7 @@ export class ENS {
   contracts?: ContractManager
   getContractAddress = _getContractAddress
   gqlInstance = new GqlManager()
+  fuses = fuseEnum
 
   constructor(options?: ENSOptions) {
     this.options = options

package/src/utils/fuses.ts

@@ -7,7 +7,7 @@ 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,9 +15,17 @@ export const testable = {
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
   PARENT_CANNOT_CONTROL,
-}
+} as const
+
+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,
+] as const
 
-export default {
-  ...testable,
+const fullFuseEnum = {
+  ...fuseEnum,
   CAN_DO_EVERYTHING,
 }
+
+export default fullFuseEnum