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

package/dist/esm/utils/generateFuseInput.mjs

@@ -0,0 +1,15 @@
+// src/utils/generateFuseInput.ts
+import { ethers } from "ethers";
+import fuses from "./fuses.mjs";
+var generateFuseInput_default = (fuseOptions) => {
+  const fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt] === true
+  );
+  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
+    return prev.or(fuses[curr]);
+  }, ethers.BigNumber.from(0));
+  return bigNumberFuses.toHexString();
+};
+export {
+  generateFuseInput_default as default
+};

package/dist/esm/utils/hexEncodedName.mjs

@@ -0,0 +1,6 @@
+// src/utils/hexEncodedName.ts
+import packet from "dns-packet";
+var hexEncodeName = (name) => `0x${packet.name.encode(name).toString("hex")}`;
+export {
+  hexEncodeName
+};

package/dist/esm/utils/labels.mjs

@@ -0,0 +1,109 @@
+// src/utils/labels.ts
+import { solidityKeccak256 } from "ethers/lib/utils.js";
+import { truncateFormat } from "./format.mjs";
+var hasLocalStorage = typeof localStorage !== "undefined";
+var labelhash = (input) => solidityKeccak256(["string"], [input]);
+var keccakFromString = (input) => labelhash(input);
+function decodeLabelhash(hash) {
+  if (!(hash.startsWith("[") && hash.endsWith("]"))) {
+    throw Error(
+      "Expected encoded labelhash to start and end with square brackets"
+    );
+  }
+  if (hash.length !== 66) {
+    throw Error("Expected encoded labelhash to have a length of 66");
+  }
+  return `0x${hash.slice(1, -1)}`;
+}
+function encodeLabelhash(hash) {
+  if (!hash.startsWith("0x")) {
+    throw new Error("Expected label hash to start with 0x");
+  }
+  if (hash.length !== 66) {
+    throw new Error("Expected label hash to have a length of 66");
+  }
+  return `[${hash.slice(2)}]`;
+}
+function isEncodedLabelhash(hash) {
+  return hash.startsWith("[") && hash.endsWith("]") && hash.length === 66;
+}
+function getLabels() {
+  return hasLocalStorage ? JSON.parse(localStorage.getItem("ensjs:labels")) || {} : {};
+}
+function _saveLabel(hash, label) {
+  if (!hasLocalStorage)
+    return hash;
+  const labels = getLabels();
+  localStorage.setItem(
+    "ensjs:labels",
+    JSON.stringify({
+      ...labels,
+      [hash]: label
+    })
+  );
+  return hash;
+}
+function saveLabel(label) {
+  const hash = `${labelhash(label.toLowerCase())}`;
+  return _saveLabel(hash, label);
+}
+function saveName(name) {
+  const nameArray = name.split(".");
+  nameArray.forEach((label) => {
+    saveLabel(label);
+  });
+}
+function checkLabel(hash) {
+  const labels = getLabels();
+  if (isEncodedLabelhash(hash)) {
+    return labels[decodeLabelhash(hash)];
+  }
+  if (hash.startsWith("0x")) {
+    return labels[`${hash.slice(2)}`];
+  }
+}
+function encodeLabel(label) {
+  try {
+    return encodeLabelhash(label);
+  } catch {
+    return label;
+  }
+}
+function parseName(name) {
+  const nameArray = name.split(".");
+  return nameArray.map((label) => encodeLabel(label)).join(".");
+}
+function checkIsDecrypted(string) {
+  return !string?.includes("[");
+}
+function decryptName(name) {
+  return name.split(".").map((label) => checkLabel(label) || label).join(".");
+}
+var truncateUndecryptedName = (name) => truncateFormat(name);
+function checkLocalStorageSize() {
+  if (!hasLocalStorage)
+    return "Empty (0 KB)";
+  let allStrings = "";
+  for (const key in window.localStorage) {
+    if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
+      allStrings += window.localStorage[key];
+    }
+  }
+  return allStrings ? `${3 + allStrings.length * 16 / (8 * 1024)} KB` : "Empty (0 KB)";
+}
+export {
+  checkIsDecrypted,
+  checkLabel,
+  checkLocalStorageSize,
+  decodeLabelhash,
+  decryptName,
+  encodeLabel,
+  encodeLabelhash,
+  isEncodedLabelhash,
+  keccakFromString,
+  labelhash,
+  parseName,
+  saveLabel,
+  saveName,
+  truncateUndecryptedName
+};

package/dist/esm/utils/makeHashIndexes.mjs

@@ -0,0 +1,10 @@
+// src/utils/makeHashIndexes.ts
+import { namehash } from "./normalise.mjs";
+var makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
+var makeNamehashIndexes = (data, name) => Array.from(data.matchAll(namehash(name).substring(2))).map(
+  (x) => x.index / 2 - 1
+);
+export {
+  makeNamehashIndexes,
+  makeOtherIndexes
+};

package/dist/esm/utils/normalise.mjs

@@ -0,0 +1,30 @@
+// src/utils/normalise.ts
+import { concat, hexlify, keccak256, toUtf8Bytes } from "ethers/lib/utils.js";
+import uts46 from "idna-uts46-hx/uts46bundle.js";
+import { decodeLabelhash, isEncodedLabelhash } from "./labels.mjs";
+var zeros = new Uint8Array(32);
+zeros.fill(0);
+var normalise = (name) => name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name;
+var namehash = (name) => {
+  let result = zeros;
+  if (name) {
+    const labels = name.split(".");
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+      let labelSha;
+      if (isEncodedLabelhash(labels[i])) {
+        labelSha = decodeLabelhash(labels[i]);
+      } else {
+        const normalised = normalise(labels[i]);
+        labelSha = keccak256(toUtf8Bytes(normalised));
+      }
+      result = keccak256(concat([result, labelSha]));
+    }
+  } else {
+    result = hexlify(zeros);
+  }
+  return result;
+};
+export {
+  namehash,
+  normalise
+};

package/dist/esm/utils/recordHelpers.mjs

@@ -0,0 +1,75 @@
+// src/utils/recordHelpers.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { encodeContenthash } from "./contentHash.mjs";
+var generateSetAddr = (namehash, coinType, address, resolver) => {
+  let coinTypeInstance;
+  if (!Number.isNaN(parseInt(coinType))) {
+    coinTypeInstance = formatsByCoinType[parseInt(coinType)];
+  } else {
+    coinTypeInstance = formatsByName[coinType.toUpperCase()];
+  }
+  const inputCoinType = coinTypeInstance.coinType;
+  const encodedAddress = coinTypeInstance.decoder(address);
+  return resolver?.interface.encodeFunctionData(
+    "setAddr(bytes32,uint256,bytes)",
+    [namehash, inputCoinType, encodedAddress]
+  );
+};
+function generateSingleRecordCall(namehash, resolver, type) {
+  if (type === "contentHash") {
+    return (_r) => {
+      const record = _r;
+      let _contentHash = "";
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record);
+        if (encoded.error)
+          throw new Error(encoded.error);
+        _contentHash = encoded.encoded;
+      }
+      return resolver.interface.encodeFunctionData("setContenthash", [
+        namehash,
+        _contentHash
+      ]);
+    };
+  }
+  return (_r) => {
+    const record = _r;
+    if (type === "text") {
+      return resolver.interface.encodeFunctionData("setText", [
+        namehash,
+        record.key,
+        record.value
+      ]);
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver);
+  };
+}
+var generateRecordCallArray = (namehash, records, resolver) => {
+  const calls = [];
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData("clearRecords", [namehash])
+    );
+  }
+  if (records.contentHash) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      "contentHash"
+    )(records.contentHash);
+    if (data)
+      calls.push(data);
+  }
+  if (records.texts && records.texts.length > 0) {
+    records.texts.map(generateSingleRecordCall(namehash, resolver, "text")).forEach((call) => calls.push(call));
+  }
+  if (records.coinTypes && records.coinTypes.length > 0) {
+    records.coinTypes.map(generateSingleRecordCall(namehash, resolver, "addr")).forEach((call) => calls.push(call));
+  }
+  return calls;
+};
+export {
+  generateRecordCallArray,
+  generateSetAddr,
+  generateSingleRecordCall
+};

package/dist/esm/utils/registerHelpers.mjs

@@ -0,0 +1,97 @@
+// src/utils/registerHelpers.ts
+import { utils } from "ethers";
+import generateFuseInput from "./generateFuseInput.mjs";
+import { labelhash } from "./labels.mjs";
+import { namehash } from "./normalise.mjs";
+import { generateRecordCallArray } from "./recordHelpers.mjs";
+var MAX_INT_64 = 2n ** 64n - 1n;
+var randomSecret = () => {
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+var makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  wrapperExpiry,
+  secret
+}) => {
+  const label = labelhash(name.split(".")[0]);
+  const hash = namehash(name);
+  const resolverAddress = resolver.address;
+  const fuseData = fuses ? generateFuseInput(fuses) : "0";
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: "ETH", value: owner }] };
+    } else if (!records.coinTypes?.find((c) => c.key === "ETH")) {
+      if (!records.coinTypes)
+        records.coinTypes = [];
+      records.coinTypes.push({ key: "ETH", value: owner });
+    }
+  }
+  const data = records ? generateRecordCallArray(hash, records, resolver) : [];
+  return [
+    label,
+    owner,
+    duration,
+    resolverAddress,
+    data,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || MAX_INT_64
+  ];
+};
+var makeRegistrationData = (params) => {
+  const commitmentData = makeCommitmentData(params);
+  const label = params.name.split(".")[0];
+  commitmentData[0] = label;
+  const secret = commitmentData.splice(5, 1)[0];
+  commitmentData.splice(3, 0, secret);
+  return commitmentData;
+};
+var _makeCommitment = (params) => {
+  return utils.keccak256(
+    utils.defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "address",
+        "bytes[]",
+        "bytes32",
+        "bool",
+        "uint32",
+        "uint64"
+      ],
+      params
+    )
+  );
+};
+var makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8]
+  };
+};
+export {
+  MAX_INT_64,
+  _makeCommitment,
+  makeCommitment,
+  makeCommitmentData,
+  makeRegistrationData,
+  randomSecret
+};

package/dist/esm/utils/singleCall.mjs

@@ -0,0 +1,5 @@
+// src/utils/singleCall.ts
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true })).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+export {
+  singleCall_default as default
+};

package/dist/esm/utils/validation.mjs

@@ -0,0 +1,67 @@
+// src/utils/validation.ts
+import { isAddress } from "ethers/lib/utils.js";
+import { isEncodedLabelhash, saveName } from "./labels.mjs";
+import { normalise } from "./normalise.mjs";
+var validateName = (name) => {
+  const nameArray = name.split(".");
+  const hasEmptyLabels = nameArray.some((label) => label.length === 0);
+  if (hasEmptyLabels)
+    throw new Error("Name cannot have empty labels");
+  const normalizedArray = nameArray.map((label) => {
+    if (label === "[root]") {
+      return label;
+    }
+    return isEncodedLabelhash(label) ? label : normalise(label);
+  });
+  const normalizedName = normalizedArray.join(".");
+  saveName(normalizedName);
+  return normalizedName;
+};
+var validateTLD = (name) => {
+  const labels = name.split(".");
+  return validateName(labels[labels.length - 1]);
+};
+var parseInputType = (input) => {
+  const validTLD = validateTLD(input);
+  const regex = /[^.]+$/;
+  try {
+    validateName(input);
+  } catch (e) {
+    return {
+      type: "unknown"
+    };
+  }
+  if (input.indexOf(".") !== -1) {
+    const termArray = input.split(".");
+    const tld = input.match(regex) ? input.match(regex)[0] : "";
+    if (validTLD) {
+      if (tld === "eth" && [...termArray[termArray.length - 2]].length < 3) {
+        return {
+          type: "name",
+          info: "short"
+        };
+      }
+      return {
+        type: "name",
+        info: "supported"
+      };
+    }
+    return {
+      type: "name",
+      info: "unsupported"
+    };
+  }
+  if (isAddress(input)) {
+    return {
+      type: "address"
+    };
+  }
+  return {
+    type: "label"
+  };
+};
+export {
+  parseInputType,
+  validateName,
+  validateTLD
+};

package/dist/esm/utils/wrapper.mjs

@@ -0,0 +1,32 @@
+// src/utils/wrapper.ts
+import { BigNumber } from "ethers";
+import { toUtf8Bytes } from "ethers/lib/utils.js";
+var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
+var makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1e3);
+    }
+    if (expiry instanceof BigNumber) {
+      return expiry;
+    }
+    return BigNumber.from(expiry);
+  }
+  if (name.endsWith(".eth")) {
+    const expResponse = await getExpiry(name);
+    if (!expResponse?.expiry)
+      throw new Error("Couldn't get expiry for name, please provide one.");
+    return BigNumber.from(expResponse.expiry.getTime() / 1e3);
+  }
+  return MAX_EXPIRY;
+};
+var wrappedLabelLengthCheck = (label) => {
+  const bytes = toUtf8Bytes(label);
+  if (bytes.byteLength > 255)
+    throw new Error("Label can't be longer than 255 bytes");
+};
+export {
+  MAX_EXPIRY,
+  makeExpiry,
+  wrappedLabelLengthCheck
+};

package/dist/esm/utils/writeTx.mjs

@@ -0,0 +1,6 @@
+// src/utils/writeTx.ts
+var withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+var writeTx_default = (signer, populate) => ({ customData, ...tx }) => populate ? withCustomData(tx, customData) : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));
+export {
+  writeTx_default as default
+};

package/dist/types/GqlManager.d.ts

@@ -0,0 +1,11 @@
+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;
+    setUrl: (url: string | null) => Promise<void>;
+    request: (...arg: any[]) => any;
+}

package/dist/{cjs/contracts/ethRegistrarController.d.ts → types/contracts/bulkRenewal.d.ts}

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ETHRegistrarController;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BulkRenewal").BulkRenewal;
 export default _default;

package/dist/{cjs/contracts/publicResolver.d.ts → types/contracts/dnsRegistrar.d.ts}

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").PublicResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/DNSRegistrar").DNSRegistrar;
 export default _default;

package/dist/{esm → types}/contracts/ethRegistrarController.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ETHRegistrarController;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ETHRegistrarController").ETHRegistrarController;
 export default _default;

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

@@ -0,0 +1,18 @@
+import { ethers } from 'ethers';
+import { ContractAddressFetch } from './getContractAddress';
+export default class ContractManager {
+    private provider;
+    private fetchAddress;
+    constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
+    private generateContractGetter;
+    getPublicResolver: (passedProvider?: any, address?: string) => Promise<import("../generated/PublicResolver").PublicResolver>;
+    getUniversalResolver: (passedProvider?: any, address?: string) => Promise<import("../generated/UniversalResolver").UniversalResolver>;
+    getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
+    getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/ReverseRegistrar").ReverseRegistrar>;
+    getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated/NameWrapper").NameWrapper>;
+    getDNSRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/DNSRegistrar").DNSRegistrar>;
+    getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
+    getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated/ETHRegistrarController").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated/Multicall").Multicall>;
+    getBulkRenewal: (passedProvider?: any, address?: string) => Promise<import("../generated/BulkRenewal").BulkRenewal>;
+}

package/dist/{esm → types}/contracts/nameWrapper.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").NameWrapper;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/NameWrapper").NameWrapper;
 export default _default;

package/dist/{esm → types}/contracts/publicResolver.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").PublicResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/PublicResolver").PublicResolver;
 export default _default;

package/dist/{cjs → types}/contracts/reverseRegistrar.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ReverseRegistrar;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ReverseRegistrar").ReverseRegistrar;
 export default _default;

package/dist/types/contracts/types.d.ts

@@ -0,0 +1,2 @@
+export declare type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337';
+export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'DNSRegistrar' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver' | 'BulkRenewal';

package/dist/{cjs → types}/contracts/universalResolver.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").UniversalResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/UniversalResolver").UniversalResolver;
 export default _default;

package/dist/types/functions/batchWrappers.d.ts

@@ -0,0 +1,86 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export declare const universalWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, data: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
+        data: any;
+        resolver: any;
+    } | undefined>;
+};
+export declare const resolverMulticallWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, data: {
+        to: string;
+        data: string;
+    }[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<ethers.utils.Result | undefined>;
+};
+export declare const multicallWrapper: {
+    raw({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean): Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, data: string, transactions: ethers.providers.TransactionRequest[]): Promise<{
+        success: boolean;
+        returnData: string;
+        0: boolean;
+        1: string;
+        length: 2;
+        toString(): string;
+        toLocaleString(): string;
+        pop(): string | boolean | undefined;
+        push(...items: (string | boolean)[]): number;
+        concat(...items: ConcatArray<string | boolean>[]): (string | boolean)[];
+        concat(...items: (string | boolean | ConcatArray<string | boolean>)[]): (string | boolean)[];
+        join(separator?: string | undefined): string;
+        reverse(): (string | boolean)[];
+        shift(): string | boolean | undefined;
+        slice(start?: number | undefined, end?: number | undefined): (string | boolean)[];
+        sort(compareFn?: ((a: string | boolean, b: string | boolean) => number) | undefined): [boolean, string];
+        splice(start: number, deleteCount?: number | undefined): (string | boolean)[];
+        splice(start: number, deleteCount: number, ...items: (string | boolean)[]): (string | boolean)[];
+        unshift(...items: (string | boolean)[]): number;
+        indexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+        lastIndexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+        every<S extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => U, thisArg?: any): U[];
+        filter<S_1 extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S_1, thisArg?: any): S_1[];
+        filter(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): (string | boolean)[];
+        reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+        reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+        reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_1, initialValue: U_1): U_1;
+        reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+        reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+        reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_2, initialValue: U_2): U_2;
+        find<S_2 extends string | boolean>(predicate: (this: void, value: string | boolean, index: number, obj: (string | boolean)[]) => value is S_2, thisArg?: any): S_2 | undefined;
+        find(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): string | boolean | undefined;
+        findIndex(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): number;
+        fill(value: string | boolean, start?: number | undefined, end?: number | undefined): [boolean, string];
+        copyWithin(target: number, start: number, end?: number | undefined): [boolean, string];
+        entries(): IterableIterator<[number, string | boolean]>;
+        keys(): IterableIterator<number>;
+        values(): IterableIterator<string | boolean>;
+        includes(searchElement: string | boolean, fromIndex?: number | undefined): boolean;
+        flatMap<U_3, This = undefined>(callback: (this: This, value: string | boolean, index: number, array: (string | boolean)[]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        [Symbol.iterator](): IterableIterator<string | boolean>;
+        [Symbol.unscopables](): {
+            copyWithin: boolean;
+            entries: boolean;
+            fill: boolean;
+            find: boolean;
+            findIndex: boolean;
+            keys: boolean;
+            values: boolean;
+        };
+        at(index: number): string | boolean | undefined;
+    }[] | undefined>;
+};

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

@@ -0,0 +1,3 @@
+import { ENSArgs } from '..';
+import { FuseProps } from '../utils/fuses';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;