@ensdomains/ensjs 3.0.0-alpha.41 → 3.0.0-alpha.42

package/dist/esm/generated/factories/UniversalResolver__factory.mjs

@@ -56,6 +56,25 @@ var _abi = [
     name: "OffchainLookup",
     type: "error"
   },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
   {
     inputs: [
       {
@@ -143,6 +162,19 @@ var _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "registry",
@@ -156,6 +188,13 @@ var _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -308,7 +347,7 @@ var _abi = [
         type: "address"
       }
     ],
-    stateMutability: "nonpayable",
+    stateMutability: "view",
     type: "function"
   },
   {
@@ -337,7 +376,7 @@ var _abi = [
         type: "address"
       }
     ],
-    stateMutability: "nonpayable",
+    stateMutability: "view",
     type: "function"
   },
   {
@@ -449,6 +488,19 @@ var _abi = [
         type: "address"
       }
     ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string[]",
+        name: "_urls",
+        type: "string[]"
+      }
+    ],
+    name: "setGatewayURLs",
+    outputs: [],
     stateMutability: "nonpayable",
     type: "function"
   },
@@ -470,6 +522,19 @@ var _abi = [
     ],
     stateMutability: "view",
     type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
   }
 ];
 var UniversalResolver__factory = class {

package/dist/esm/index.mjs

@@ -278,16 +278,17 @@ var ENS = class {
   transferController = this.generateWriteFunction("transferController", ["contracts"]);
   wrapName = this.generateWriteFunction(
     "wrapName",
-    ["contracts", "getExpiry"]
+    ["contracts"]
   );
   unwrapName = this.generateWriteFunction(
     "unwrapName",
     ["contracts"]
   );
-  burnFuses = this.generateWriteFunction(
-    "burnFuses",
+  setFuses = this.generateWriteFunction(
+    "setFuses",
     ["contracts"]
   );
+  setChildFuses = this.generateWriteFunction("setFuses", ["contracts"], "setChildFuses");
   importDNSSECName = this.generateWriteFunction("importDNSSECName", ["contracts", "provider", "signer"]);
   createSubname = this.generateWriteFunction("createSubname", ["contracts", "getExpiry"]);
   deleteSubname = this.generateWriteFunction("deleteSubname", ["contracts"]);
@@ -301,7 +302,7 @@ var ENS = class {
     "renewNames",
     ["contracts"]
   );
-  renewNameWithData = this.generateWriteFunction("renewNames", ["contracts"], "renewNameWithData");
+  extendWrappedName = this.generateWriteFunction("renewNames", ["contracts"], "extendWrappedName");
 };
 export {
   ENS,

package/dist/esm/utils/consts.mjs

@@ -1,5 +1,7 @@
 // src/utils/consts.ts
 var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
+var MAX_INT_64 = 2n ** 64n - 1n;
 export {
-  EMPTY_ADDRESS
+  EMPTY_ADDRESS,
+  MAX_INT_64
 };

package/dist/esm/utils/fuses.mjs

@@ -1,23 +1,43 @@
 // src/utils/fuses.ts
-import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
 var CANNOT_UNWRAP = 1;
 var CANNOT_BURN_FUSES = 2;
 var CANNOT_TRANSFER = 4;
 var CANNOT_SET_RESOLVER = 8;
 var CANNOT_SET_TTL = 16;
 var CANNOT_CREATE_SUBDOMAIN = 32;
-var PARENT_CANNOT_CONTROL = 64;
+var PARENT_CANNOT_CONTROL = 65536;
+var IS_DOT_ETH = 131072;
+var CAN_EXTEND_EXPIRY = 262144;
+var CHILD_CONTROLLED_FUSES = 65535;
+var PARENT_CONTROLLED_FUSES = 4294901760;
+var USER_SETTABLE_FUSES = 4294836223;
 var CAN_DO_EVERYTHING = 0;
-var fuseEnum = {
+var childFuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
   CANNOT_SET_RESOLVER,
   CANNOT_SET_TTL,
-  CANNOT_CREATE_SUBDOMAIN,
-  PARENT_CANNOT_CONTROL
+  CANNOT_CREATE_SUBDOMAIN
 };
-var unnamedFuses = [
+var parentFuseEnum = {
+  PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY
+};
+var fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH
+};
+var userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum
+};
+var fullFuseEnum = {
+  ...userSettableFuseEnum,
+  CAN_DO_EVERYTHING
+};
+var unnamedChildFuses = [
+  64,
   128,
   256,
   512,
@@ -26,10 +46,9 @@ var unnamedFuses = [
   4096,
   8192,
   16384,
-  32768,
-  65536,
-  131072,
-  262144,
+  32768
+];
+var unnamedParentFuses = [
   524288,
   1048576,
   2097152,
@@ -42,74 +61,220 @@ var unnamedFuses = [
   268435456,
   536870912,
   1073741824,
-  2147483648,
-  4294967296
+  2147483648
 ];
-var fullFuseEnum = {
-  ...fuseEnum,
-  CAN_DO_EVERYTHING
+var unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses
+];
+var childFuseKeys = Object.keys(
+  childFuseEnum
+);
+var parentFuseKeys = Object.keys(
+  parentFuseEnum
+);
+var fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum
+);
+var userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum
+);
+var checkNumber = (fuses) => {
+  if (fuses > 2 ** 32 || fuses < 1) {
+    throw new Error(
+      `Fuse number must be limited to uint32, ${fuses} was too ${fuses < 1 ? "low" : "high"}.`
+    );
+  } else if (fuses % 1 !== 0) {
+    throw new Error(`Fuse number must be an integer, ${fuses} was not.`);
+  } else if ((fuses & USER_SETTABLE_FUSES) !== fuses) {
+    throw new Error(
+      `Fuse number must be limited to user settable fuses, ${fuses} was not.`
+    );
+  }
 };
-var validateFuses = (fuses) => {
-  const isNumber = "fuseNumberToBurn" in fuses;
-  const hasNamedArray = "namedFusesToBurn" in fuses;
-  const hasUnnamedArray = "unnamedFusesToBurn" in fuses;
+var testFuses = (fuses) => {
+  if ("named" in fuses && fuses.named.length > 0) {
+    return true;
+  }
+  if ("unnamed" in fuses && fuses.unnamed.length > 0) {
+    return true;
+  }
+  if ("number" in fuses && fuses.number !== 0) {
+    return true;
+  }
+  return false;
+};
+var hasFuses = (fuses) => {
+  if (typeof fuses === "number") {
+    return fuses !== 0;
+  }
+  if (typeof fuses === "object") {
+    if ("child" in fuses && testFuses(fuses.child)) {
+      return true;
+    }
+    if ("parent" in fuses && testFuses(fuses.parent)) {
+      return true;
+    }
+    if (testFuses(fuses)) {
+      return true;
+    }
+  }
+  return false;
+};
+function encodeFuses(fuses, restrictTo) {
   let encodedFuses = 0;
-  if (isNumber) {
-    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
-      throw new Error(
-        `Fuse number must be limited to uint32, ${fuses.fuseNumberToBurn} was too ${fuses.fuseNumberToBurn < 1 ? "low" : "high"}.`
-      );
-    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
-      throw new Error(
-        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`
-      );
+  if (typeof fuses === "number") {
+    if (restrictTo) {
+      throw new Error("Cannot specify an exact fuse value when restricted.");
     }
-    encodedFuses = fuses.fuseNumberToBurn;
+    checkNumber(fuses);
+    encodedFuses = fuses;
   } else {
-    if (!hasNamedArray && !hasUnnamedArray) {
-      throw new Error("Please provide fuses to burn");
+    let fusesRef = fuses;
+    let allowedNamed = [];
+    let allowedUnnamed = [];
+    let namedArray = [];
+    let unnamedArray = [];
+    if (restrictTo) {
+      if ("parent" in fuses || "child" in fuses) {
+        throw new Error("Can't specify fuse category when restricted.");
+      }
+      allowedNamed = restrictTo === "child" ? childFuseKeys : parentFuseKeys;
+      allowedUnnamed = restrictTo === "child" ? unnamedChildFuses : unnamedParentFuses;
+      fusesRef = { [restrictTo]: fuses };
+    } else {
+      allowedNamed = userSettableFuseKeys;
+      allowedUnnamed = unnamedUserSettableFuses;
+    }
+    if ("parent" in fusesRef) {
+      if ("named" in fusesRef.parent)
+        namedArray = fusesRef.parent.named;
+      if ("unnamed" in fusesRef.parent)
+        unnamedArray = fusesRef.parent.unnamed;
+      if ("number" in fusesRef.parent) {
+        if ("named" in fusesRef.parent || "unnamed" in fusesRef.parent) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.parent.number);
+        if ((fusesRef.parent.number & PARENT_CONTROLLED_FUSES) !== fusesRef.parent.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the parent's control."
+          );
+        }
+        encodedFuses |= fusesRef.parent.number;
+      }
+    }
+    if ("child" in fusesRef) {
+      if ("named" in fusesRef.child)
+        namedArray = [...namedArray, ...fusesRef.child.named];
+      if ("unnamed" in fusesRef.child)
+        unnamedArray = [...unnamedArray, ...fusesRef.child.unnamed];
+      if ("number" in fusesRef.child) {
+        if ("named" in fusesRef.child || "unnamed" in fusesRef.child) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.child.number);
+        if ((fusesRef.child.number & CHILD_CONTROLLED_FUSES) !== fusesRef.child.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the owner's control."
+          );
+        }
+        encodedFuses |= fusesRef.child.number;
+      }
     }
-    if (hasNamedArray) {
-      for (const fuse of fuses.namedFusesToBurn) {
-        if (!(fuse in fuseEnum)) {
+    if (!namedArray.length && !unnamedArray.length && !encodedFuses) {
+      throw new Error("Must specify at least one fuse.");
+    }
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse)) {
           throw new Error(`${fuse} is not a valid named fuse.`);
         }
-        encodedFuses |= fuseEnum[fuse];
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
       }
+      encodedFuses |= userSettableFuseEnum[fuse];
     }
-    if (hasUnnamedArray) {
-      for (const fuse of fuses.unnamedFusesToBurn) {
-        if (!unnamedFuses.includes(fuse)) {
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.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.`
+            `${fuse} is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.`
           );
         }
-        encodedFuses |= fuse;
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
       }
+      encodedFuses |= fuse;
     }
   }
   return encodedFuses;
-};
-var decodeFuses = (fuses) => {
-  const bnFuses = BigNumber.from(fuses);
+}
+var decodeNamedFuses = (fuses, arr) => {
   const fuseObj = Object.fromEntries(
-    Object.keys(fuseEnum).map((fuse) => [
+    arr.map((fuse) => [
       fuse,
-      bnFuses.and(fuseEnum[fuse]).gt(0)
+      (fuses & userSettableFuseEnum[fuse]) > 0
     ])
   );
-  if (bnFuses.eq(0)) {
-    fuseObj.CAN_DO_EVERYTHING = true;
-  } else {
-    fuseObj.CAN_DO_EVERYTHING = false;
-  }
   return fuseObj;
 };
+var decodeUnnamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) > 0])
+  );
+  return fuseObj;
+};
+var decodeFuses = (fuses) => {
+  const parentNamedFuses = decodeNamedFuses(
+    fuses,
+    fullParentFuseKeys
+  );
+  const parentUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedParentFuses
+  );
+  const childNamedFuses = decodeNamedFuses(
+    fuses,
+    childFuseKeys
+  );
+  const childUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedChildFuses
+  );
+  return {
+    parent: {
+      ...parentNamedFuses,
+      unnamed: parentUnnamedFuses
+    },
+    child: {
+      ...childNamedFuses,
+      CAN_DO_EVERYTHING: (fuses & CHILD_CONTROLLED_FUSES) === 0,
+      unnamed: childUnnamedFuses
+    }
+  };
+};
 var fuses_default = fullFuseEnum;
 export {
+  CHILD_CONTROLLED_FUSES,
+  PARENT_CONTROLLED_FUSES,
+  USER_SETTABLE_FUSES,
+  childFuseEnum,
+  childFuseKeys,
   decodeFuses,
   fuses_default as default,
-  fuseEnum,
-  unnamedFuses,
-  validateFuses
+  encodeFuses,
+  fullFuseEnum,
+  fullParentFuseEnum,
+  fullParentFuseKeys,
+  hasFuses,
+  parentFuseEnum,
+  parentFuseKeys,
+  unnamedChildFuses,
+  unnamedParentFuses,
+  unnamedUserSettableFuses,
+  userSettableFuseEnum,
+  userSettableFuseKeys
 };

package/dist/esm/utils/normalise.mjs

@@ -1,7 +1,7 @@
 // src/utils/normalise.ts
 import { concat, hexlify } from "@ethersproject/bytes";
 import { keccak256 } from "@ethersproject/keccak256";
-import { toUtf8Bytes } from "@ethersproject/strings/lib.esm/utf8.js";
+import { toUtf8Bytes } from "@ethersproject/strings";
 import uts46 from "idna-uts46-hx/uts46bundle.js";
 import { decodeLabelhash, isEncodedLabelhash } from "./labels.mjs";
 var zeros = new Uint8Array(32);

package/dist/esm/utils/recordHelpers.mjs

@@ -1,6 +1,7 @@
 // src/utils/recordHelpers.ts
 import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
-import { isBytesLike, toUtf8Bytes } from "ethers/lib/utils";
+import { isBytesLike } from "@ethersproject/bytes";
+import { toUtf8Bytes } from "@ethersproject/strings";
 import { encodeContenthash } from "./contentHash.mjs";
 var generateSetAddr = (namehash, coinType, address, resolver) => {
   let coinTypeInstance;

package/dist/esm/utils/registerHelpers.mjs

@@ -1,11 +1,10 @@
 // src/utils/registerHelpers.ts
 import { defaultAbiCoder } from "@ethersproject/abi/lib.esm/abi-coder.js";
 import { keccak256 } from "@ethersproject/keccak256";
-import generateFuseInput from "./generateFuseInput.mjs";
+import { encodeFuses, hasFuses } from "./fuses.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")}`;
@@ -18,13 +17,12 @@ var makeCommitmentData = ({
   records,
   reverseRecord,
   fuses,
-  wrapperExpiry,
   secret
 }) => {
-  const label = labelhash(name.split(".")[0]);
+  const labelHash = labelhash(name.split(".")[0]);
   const hash = namehash(name);
   const resolverAddress = resolver.address;
-  const fuseData = fuses ? generateFuseInput(fuses) : "0";
+  const fuseData = hasFuses(fuses) ? encodeFuses(fuses, "child") : 0;
   if (reverseRecord) {
     if (!records) {
       records = { coinTypes: [{ key: "ETH", value: owner }] };
@@ -36,23 +34,20 @@ var makeCommitmentData = ({
   }
   const data = records ? generateRecordCallArray(hash, records, resolver) : [];
   return [
-    label,
+    labelHash,
     owner,
     duration,
+    secret,
     resolverAddress,
     data,
-    secret,
     !!reverseRecord,
-    fuseData,
-    wrapperExpiry || MAX_INT_64
+    fuseData
   ];
 };
 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) => {
@@ -62,12 +57,11 @@ var _makeCommitment = (params) => {
         "bytes32",
         "address",
         "uint256",
+        "bytes32",
         "address",
         "bytes[]",
-        "bytes32",
         "bool",
-        "uint32",
-        "uint64"
+        "uint16"
       ],
       params
     )
@@ -84,12 +78,10 @@ var makeCommitment = ({
   const commitment = _makeCommitment(generatedParams);
   return {
     secret,
-    commitment,
-    wrapperExpiry: generatedParams[8]
+    commitment
   };
 };
 export {
-  MAX_INT_64,
   _makeCommitment,
   makeCommitment,
   makeCommitmentData,

package/dist/esm/utils/wrapper.mjs

@@ -1,6 +1,6 @@
 // src/utils/wrapper.ts
 import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
-import { toUtf8Bytes } from "@ethersproject/strings/lib.esm/utf8.js";
+import { toUtf8Bytes } from "@ethersproject/strings";
 var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
 var makeExpiry = async ({ getExpiry }, name, expiry) => {
   if (expiry) {

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

@@ -7,7 +7,6 @@ export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { re
     customData: {
         secret: string;
         commitment: string;
-        wrapperExpiry: import("ethers").BigNumberish;
     };
     to?: string | undefined;
     from?: string | undefined;

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

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-import { FuseOptions } from '../utils/fuses';
+import { CombinedFuseInput } from '../utils/fuses';
 import { Expiry } from '../utils/wrapper';
 declare type BaseArgs = {
     owner: string;
@@ -8,7 +8,7 @@ declare type BaseArgs = {
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
-    fuses?: FuseOptions;
+    fuses?: CombinedFuseInput;
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;

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

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL' | 'WrappedTransfer' | 'NameWrapped' | 'NameUnwrapped' | 'FusesSet';
+declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL' | 'WrappedTransfer' | 'NameWrapped' | 'NameUnwrapped' | 'FusesSet' | 'ExpiryExtended';
 declare type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred';
 declare type ResolverEvent = 'AddrChanged' | 'MulticoinAddrChanged' | 'NameChanged' | 'AbiChanged' | 'PubkeyChanged' | 'TextChanged' | 'ContenthashChanged' | 'InterfaceChanged' | 'AuthorisationChanged' | 'VersionChanged';
 export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name: string): Promise<{

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

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-import { CurrentFuses } from '../utils/fuses';
+import { AllCurrentFuses } from '../utils/fuses';
 export declare type Name = {
     id: string;
     labelName: string | null;
@@ -13,7 +13,7 @@ export declare type Name = {
     createdAt?: Date;
     registrationDate?: Date;
     expiryDate?: Date;
-    fuses?: CurrentFuses;
+    fuses?: AllCurrentFuses;
     registration?: {
         expiryDate: Date;
         registrationDate: Date;
@@ -37,7 +37,7 @@ declare type OwnerParams = {
 };
 declare type WrappedOwnerParams = {
     type: 'wrappedOwner';
-    orderBy?: 'expiryDate' | 'labelName';
+    orderBy?: 'expiryDate' | 'name';
 };
 declare type AllParams = {
     type: 'all';

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

@@ -3,6 +3,7 @@ declare type Owner = {
     registrant?: string;
     owner?: string;
     ownershipLevel: 'nameWrapper' | 'registry' | 'registrar';
+    expired?: boolean;
 };
 declare const _default: {
     raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{