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

package/dist/cjs/GqlManager.d.ts

@@ -1,6 +1,8 @@
-export declare const enter: (node: any) => any;
-export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
-export declare const responseMiddleware: (traverse: any) => (response: any) => any;
+import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
+import type Traverse from 'traverse';
+export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
+export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
+export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/cjs/GqlManager.js

@@ -24,7 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.responseMiddleware = exports.requestMiddleware = exports.enter = void 0;
-// @ts-nocheck
 const normalise_1 = require("./utils/normalise");
 const generateSelection = (selection) => ({
     kind: 'Field',
@@ -38,25 +37,34 @@ const generateSelection = (selection) => ({
     selectionSet: undefined,
 });
 const enter = (node) => {
-    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');
-        if (!id && name) {
-            node.selections = [...node.selections, generateSelection('id')];
-            return node;
+    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) {
+        node.selections = [...node.selections, generateSelection('id')];
+        return node;
+    }
 };
 exports.enter = enter;
-const requestMiddleware = (visit, parse) => (request) => {
+const requestMiddleware = (visit, parse, print) => (request) => {
     const requestBody = JSON.parse(request.body);
     const rawQuery = requestBody.query;
     const parsedQuery = parse(rawQuery);
-    const updatedQuery = visit(parsedQuery, { enter: exports.enter });
-    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    const updatedQuery = visit(parsedQuery, {
+        SelectionSet: {
+            enter: exports.enter,
+        },
+    });
     return {
         ...request,
-        body: JSON.stringify(updatedBody),
+        body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
     };
 };
 exports.requestMiddleware = requestMiddleware;
@@ -81,13 +89,13 @@ class GqlManager {
     client = null;
     setUrl = async (url) => {
         if (url) {
-            const [imported, traverse, { visit, parse }] = await Promise.all([
+            const [imported, traverse, { visit, parse, print }] = await Promise.all([
                 Promise.resolve().then(() => __importStar(require('graphql-request'))),
                 Promise.resolve().then(() => __importStar(require('traverse'))),
                 Promise.resolve().then(() => __importStar(require('graphql/language'))),
             ]);
             this.client = new imported.GraphQLClient(url, {
-                requestMiddleware: (0, exports.requestMiddleware)(visit, parse),
+                requestMiddleware: (0, exports.requestMiddleware)(visit, parse, print),
                 responseMiddleware: (0, exports.responseMiddleware)(traverse.default),
             });
             this.gql = imported.gql;

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/GqlManager.d.ts

@@ -1,6 +1,8 @@
-export declare const enter: (node: any) => any;
-export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
-export declare const responseMiddleware: (traverse: any) => (response: any) => any;
+import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
+import type Traverse from 'traverse';
+export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
+export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
+export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/esm/GqlManager.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { namehash } from './utils/normalise';
 const generateSelection = (selection) => ({
     kind: 'Field',
@@ -12,24 +11,33 @@ const generateSelection = (selection) => ({
     selectionSet: undefined,
 });
 export const enter = (node) => {
-    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');
-        if (!id && name) {
-            node.selections = [...node.selections, generateSelection('id')];
-            return node;
+    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) {
+        node.selections = [...node.selections, generateSelection('id')];
+        return node;
+    }
 };
-export const requestMiddleware = (visit, parse) => (request) => {
+export const requestMiddleware = (visit, parse, print) => (request) => {
     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 };
+    const updatedQuery = visit(parsedQuery, {
+        SelectionSet: {
+            enter,
+        },
+    });
     return {
         ...request,
-        body: JSON.stringify(updatedBody),
+        body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
     };
 };
 export const responseMiddleware = (traverse) => (response) => {
@@ -53,13 +61,13 @@ export default class GqlManager {
         this.client = null;
         this.setUrl = async (url) => {
             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/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;