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

package/dist/cjs/utils/fuses.js

@@ -18,32 +18,66 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var fuses_exports = {};
 __export(fuses_exports, {
+  CHILD_CONTROLLED_FUSES: () => CHILD_CONTROLLED_FUSES,
+  PARENT_CONTROLLED_FUSES: () => PARENT_CONTROLLED_FUSES,
+  USER_SETTABLE_FUSES: () => USER_SETTABLE_FUSES,
+  childFuseEnum: () => childFuseEnum,
+  childFuseKeys: () => childFuseKeys,
   decodeFuses: () => decodeFuses,
   default: () => fuses_default,
-  fuseEnum: () => fuseEnum,
-  unnamedFuses: () => unnamedFuses,
-  validateFuses: () => validateFuses
+  encodeFuses: () => encodeFuses,
+  fullFuseEnum: () => fullFuseEnum,
+  fullParentFuseEnum: () => fullParentFuseEnum,
+  fullParentFuseKeys: () => fullParentFuseKeys,
+  hasFuses: () => hasFuses,
+  parentFuseEnum: () => parentFuseEnum,
+  parentFuseKeys: () => parentFuseKeys,
+  unnamedChildFuses: () => unnamedChildFuses,
+  unnamedParentFuses: () => unnamedParentFuses,
+  unnamedUserSettableFuses: () => unnamedUserSettableFuses,
+  userSettableFuseEnum: () => userSettableFuseEnum,
+  userSettableFuseKeys: () => userSettableFuseKeys
 });
 module.exports = __toCommonJS(fuses_exports);
-var import_bignumber = require("@ethersproject/bignumber/lib/bignumber");
 const CANNOT_UNWRAP = 1;
 const CANNOT_BURN_FUSES = 2;
 const CANNOT_TRANSFER = 4;
 const CANNOT_SET_RESOLVER = 8;
 const CANNOT_SET_TTL = 16;
 const CANNOT_CREATE_SUBDOMAIN = 32;
-const PARENT_CANNOT_CONTROL = 64;
+const PARENT_CANNOT_CONTROL = 65536;
+const IS_DOT_ETH = 131072;
+const CAN_EXTEND_EXPIRY = 262144;
+const CHILD_CONTROLLED_FUSES = 65535;
+const PARENT_CONTROLLED_FUSES = 4294901760;
+const USER_SETTABLE_FUSES = 4294836223;
 const CAN_DO_EVERYTHING = 0;
-const fuseEnum = {
+const childFuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
   CANNOT_SET_RESOLVER,
   CANNOT_SET_TTL,
-  CANNOT_CREATE_SUBDOMAIN,
-  PARENT_CANNOT_CONTROL
+  CANNOT_CREATE_SUBDOMAIN
 };
-const unnamedFuses = [
+const parentFuseEnum = {
+  PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY
+};
+const fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH
+};
+const userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum
+};
+const fullFuseEnum = {
+  ...userSettableFuseEnum,
+  CAN_DO_EVERYTHING
+};
+const unnamedChildFuses = [
+  64,
   128,
   256,
   512,
@@ -52,10 +86,9 @@ const unnamedFuses = [
   4096,
   8192,
   16384,
-  32768,
-  65536,
-  131072,
-  262144,
+  32768
+];
+const unnamedParentFuses = [
   524288,
   1048576,
   2097152,
@@ -68,67 +101,199 @@ const unnamedFuses = [
   268435456,
   536870912,
   1073741824,
-  2147483648,
-  4294967296
+  2147483648
 ];
-const fullFuseEnum = {
-  ...fuseEnum,
-  CAN_DO_EVERYTHING
+const unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses
+];
+const childFuseKeys = Object.keys(
+  childFuseEnum
+);
+const parentFuseKeys = Object.keys(
+  parentFuseEnum
+);
+const fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum
+);
+const userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum
+);
+const 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.`
+    );
+  }
 };
-const validateFuses = (fuses) => {
-  const isNumber = "fuseNumberToBurn" in fuses;
-  const hasNamedArray = "namedFusesToBurn" in fuses;
-  const hasUnnamedArray = "unnamedFusesToBurn" in fuses;
+const 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;
+};
+const 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;
-};
-const decodeFuses = (fuses) => {
-  const bnFuses = import_bignumber.BigNumber.from(fuses);
+}
+const 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;
 };
+const decodeUnnamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) > 0])
+  );
+  return fuseObj;
+};
+const 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;

package/dist/cjs/utils/normalise.js

@@ -30,7 +30,7 @@ __export(normalise_exports, {
 module.exports = __toCommonJS(normalise_exports);
 var import_bytes = require("@ethersproject/bytes");
 var import_keccak256 = require("@ethersproject/keccak256");
-var import_utf8 = require("@ethersproject/strings/lib/utf8");
+var import_strings = require("@ethersproject/strings");
 var import_uts46bundle = __toESM(require("idna-uts46-hx/uts46bundle.js"));
 var import_labels = require("./labels");
 const zeros = new Uint8Array(32);
@@ -46,7 +46,7 @@ const namehash = (name) => {
         labelSha = (0, import_labels.decodeLabelhash)(labels[i]);
       } else {
         const normalised = normalise(labels[i]);
-        labelSha = (0, import_keccak256.keccak256)((0, import_utf8.toUtf8Bytes)(normalised));
+        labelSha = (0, import_keccak256.keccak256)((0, import_strings.toUtf8Bytes)(normalised));
       }
       result = (0, import_keccak256.keccak256)((0, import_bytes.concat)([result, labelSha]));
     }

package/dist/cjs/utils/recordHelpers.js

@@ -31,7 +31,8 @@ __export(recordHelpers_exports, {
 });
 module.exports = __toCommonJS(recordHelpers_exports);
 var import_address_encoder = require("@ensdomains/address-encoder");
-var import_utils = require("ethers/lib/utils");
+var import_bytes = require("@ethersproject/bytes");
+var import_strings = require("@ethersproject/strings");
 var import_contentHash = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
   let coinTypeInstance;
@@ -97,11 +98,11 @@ function generateSingleRecordCall(namehash, resolver, type) {
       const record = _r;
       const { contentType = 1, data } = record;
       let encodedData = data;
-      if (!(0, import_utils.isBytesLike)(encodedData)) {
+      if (!(0, import_bytes.isBytesLike)(encodedData)) {
         if (typeof encodedData === "object") {
           encodedData = JSON.stringify(encodedData);
         }
-        encodedData = (0, import_utils.toUtf8Bytes)(encodedData);
+        encodedData = (0, import_strings.toUtf8Bytes)(encodedData);
       }
       return resolver.interface.encodeFunctionData("setABI", [
         namehash,

package/dist/cjs/utils/registerHelpers.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,9 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var registerHelpers_exports = {};
 __export(registerHelpers_exports, {
-  MAX_INT_64: () => MAX_INT_64,
   _makeCommitment: () => _makeCommitment,
   makeCommitment: () => makeCommitment,
   makeCommitmentData: () => makeCommitmentData,
@@ -34,11 +27,10 @@ __export(registerHelpers_exports, {
 module.exports = __toCommonJS(registerHelpers_exports);
 var import_abi_coder = require("@ethersproject/abi/lib/abi-coder");
 var import_keccak256 = require("@ethersproject/keccak256");
-var import_generateFuseInput = __toESM(require("./generateFuseInput"));
+var import_fuses = require("./fuses");
 var import_labels = require("./labels");
 var import_normalise = require("./normalise");
 var import_recordHelpers = require("./recordHelpers");
-const MAX_INT_64 = 2n ** 64n - 1n;
 const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32);
   return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
@@ -51,14 +43,13 @@ const makeCommitmentData = ({
   records,
   reverseRecord,
   fuses,
-  wrapperExpiry,
   secret
 }) => {
   var _a;
-  const label = (0, import_labels.labelhash)(name.split(".")[0]);
+  const labelHash = (0, import_labels.labelhash)(name.split(".")[0]);
   const hash = (0, import_normalise.namehash)(name);
   const resolverAddress = resolver.address;
-  const fuseData = fuses ? (0, import_generateFuseInput.default)(fuses) : "0";
+  const fuseData = (0, import_fuses.hasFuses)(fuses) ? (0, import_fuses.encodeFuses)(fuses, "child") : 0;
   if (reverseRecord) {
     if (!records) {
       records = { coinTypes: [{ key: "ETH", value: owner }] };
@@ -70,23 +61,20 @@ const makeCommitmentData = ({
   }
   const data = records ? (0, import_recordHelpers.generateRecordCallArray)(hash, records, resolver) : [];
   return [
-    label,
+    labelHash,
     owner,
     duration,
+    secret,
     resolverAddress,
     data,
-    secret,
     !!reverseRecord,
-    fuseData,
-    wrapperExpiry || MAX_INT_64
+    fuseData
   ];
 };
 const 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;
 };
 const _makeCommitment = (params) => {
@@ -96,12 +84,11 @@ const _makeCommitment = (params) => {
         "bytes32",
         "address",
         "uint256",
+        "bytes32",
         "address",
         "bytes[]",
-        "bytes32",
         "bool",
-        "uint32",
-        "uint64"
+        "uint16"
       ],
       params
     )
@@ -118,7 +105,6 @@ const makeCommitment = ({
   const commitment = _makeCommitment(generatedParams);
   return {
     secret,
-    commitment,
-    wrapperExpiry: generatedParams[8]
+    commitment
   };
 };

package/dist/cjs/utils/subgraph-types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subgraph_types_exports = {};
+module.exports = __toCommonJS(subgraph_types_exports);

package/dist/cjs/utils/wrapper.js

@@ -24,7 +24,7 @@ __export(wrapper_exports, {
 });
 module.exports = __toCommonJS(wrapper_exports);
 var import_bignumber = require("@ethersproject/bignumber/lib/bignumber");
-var import_utf8 = require("@ethersproject/strings/lib/utf8");
+var import_strings = require("@ethersproject/strings");
 const MAX_EXPIRY = import_bignumber.BigNumber.from(2).pow(64).sub(1);
 const makeExpiry = async ({ getExpiry }, name, expiry) => {
   if (expiry) {
@@ -45,7 +45,7 @@ const makeExpiry = async ({ getExpiry }, name, expiry) => {
   return MAX_EXPIRY;
 };
 const wrappedLabelLengthCheck = (label) => {
-  const bytes = (0, import_utf8.toUtf8Bytes)(label);
+  const bytes = (0, import_strings.toUtf8Bytes)(label);
   if (bytes.byteLength > 255)
     throw new Error("Label can't be longer than 255 bytes");
 };

package/dist/esm/contracts/getContractAddress.mjs

@@ -15,19 +15,19 @@ var addresses = {
     "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
     "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",
     "4": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
-    "5": "0x9C51161bA2FB02Cc0a403332B607117685f34831"
+    "5": "0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70"
   },
   Multicall: "0xcA11bde05977b3631167028862bE2a173976CA11",
   NameWrapper: {
     "1": "0x0000000000000000000000000000000000000000",
     "3": "0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C",
     "4": "0x0000000000000000000000000000000000000000",
-    "5": "0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8"
+    "5": "0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39"
   },
   PublicResolver: {
     "1": "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41",
     "3": "0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837",
-    "5": "0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852"
+    "5": "0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E"
   },
   ENSRegistry: {
     "1": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",
@@ -38,7 +38,7 @@ var addresses = {
   ReverseRegistrar: {
     "1": "0x084b1c3C81545d370f3634392De611CaaBFf8148",
     "3": "0x806246b52f8cB61655d3038c58D2f63Aa55d4edE",
-    "5": "0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48"
+    "5": "0x9a879320A9F7ad2BBb02063d67baF5551D6BD8B0"
   },
   UniversalResolver: {
     "1": "0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376",

package/dist/esm/functions/commitName.mjs

@@ -11,7 +11,7 @@ async function commitName_default({ contracts }, name, { resolverAddress, ...par
     void 0,
     resolverAddress
   );
-  const { secret, commitment, wrapperExpiry } = makeCommitment({
+  const { secret, commitment } = makeCommitment({
     name,
     resolver,
     ...params
@@ -20,8 +20,7 @@ async function commitName_default({ contracts }, name, { resolverAddress, ...par
     ...await controller.populateTransaction.commit(commitment),
     customData: {
       secret,
-      commitment,
-      wrapperExpiry
+      commitment
     }
   };
 }

package/dist/esm/functions/createSubname.mjs

@@ -1,6 +1,6 @@
 // src/functions/createSubname.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
-import generateFuseInput from "../utils/generateFuseInput.mjs";
+import { encodeFuses } from "../utils/fuses.mjs";
 import { namehash } from "../utils/normalise.mjs";
 import { makeExpiry, wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
 async function createSubname_default({
@@ -40,7 +40,7 @@ async function createSubname_default({
         name,
         "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
       );
-      const generatedFuses = "fuses" in wrapperArgs && wrapperArgs.fuses ? generateFuseInput(wrapperArgs.fuses) : "0";
+      const generatedFuses = "fuses" in wrapperArgs && wrapperArgs.fuses ? encodeFuses(wrapperArgs.fuses) : 0;
       return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,
         label,

package/dist/esm/functions/getHistory.mjs

@@ -7,17 +7,20 @@ import { namehash } from "../utils/normalise.mjs";
 var eventFormat = {
   Domain: {
     NewOwner: (args) => ({ owner: args.owner.id }),
-    NewResolver: (args) => ({ resolver: args.resolver.id.split("-")[0] }),
+    NewResolver: (args) => ({
+      resolver: args.resolver.id.split("-")[0]
+    }),
     Transfer: (args) => ({ owner: args.owner.id }),
     NewTTL: (args) => ({ ttl: args.ttl }),
     WrappedTransfer: (args) => ({ owner: args.owner.id }),
     NameWrapped: (args) => ({
       fuses: args.fuses,
       owner: args.owner.id,
-      expiry: args.expiry
+      expiryDate: args.expiryDate
     }),
     NameUnwrapped: (args) => ({ owner: args.owner.id }),
-    FusesSet: (args) => ({ fuses: args.fuses, expiry: args.expiry })
+    FusesSet: (args) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args) => ({ expiryDate: args.expiryDate })
   },
   Registration: {
     NameRegistered: (args) => ({
@@ -54,9 +57,11 @@ var eventFormat = {
     AbiChanged: (args) => ({ contentType: args.contentType }),
     PubkeyChanged: (args) => ({ x: args.x, y: args.y }),
     TextChanged: (args) => ({ key: args.key, value: args.value }),
-    ContenthashChanged: (args) => ({ hash: decodeContenthash(args.hash) }),
+    ContenthashChanged: (args) => ({
+      hash: decodeContenthash(args.hash)
+    }),
     InterfaceChanged: (args) => ({
-      interfaceId: args.interfaceId,
+      interfaceId: args.interfaceID,
       implementer: args.implementer
     }),
     AuthorisationChanged: (args) => ({
@@ -111,7 +116,7 @@ async function getHistory({ gqlInstance }, name) {
             }
             ...on NameWrapped {
               fuses
-              expiry
+              expiryDate
               owner {
                 id
               }
@@ -123,7 +128,9 @@ async function getHistory({ gqlInstance }, name) {
             }
             ...on FusesSet {
               fuses
-              expiry
+            }
+            ...on ExpiryExtended {
+              expiryDate
             }
           }
           registration {

package/dist/esm/functions/getNames.mjs

@@ -2,12 +2,12 @@
 import { truncateFormat } from "../utils/format.mjs";
 import { decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
-var mapDomain = (domain) => {
-  const decrypted = decryptName(domain.name);
+var mapDomain = ({ name, ...domain }) => {
+  const decrypted = name ? decryptName(name) : void 0;
   return {
     ...domain,
     name: decrypted,
-    truncatedName: truncateFormat(decrypted),
+    truncatedName: decrypted ? truncateFormat(decrypted) : void 0,
     createdAt: new Date(parseInt(domain.createdAt) * 1e3),
     type: "domain"
   };
@@ -16,8 +16,12 @@ var mapWrappedDomain = (wrappedDomain) => {
   const domain = mapDomain(wrappedDomain.domain);
   if (domain.registration) {
     domain.registration = {
-      expiryDate: new Date(parseInt(domain.registration.expiryDate) * 1e3),
-      registrationDate: new Date(domain.registration.registrationDate * 1e3)
+      expiryDate: new Date(
+        parseInt(domain.registration.expiryDate) * 1e3
+      ),
+      registrationDate: new Date(
+        parseInt(domain.registration.registrationDate) * 1e3
+      )
     };
   }
   return {
@@ -209,7 +213,7 @@ var getNames = async ({ gqlInstance }, {
         id: address,
         first: pageSize,
         skip: (page || 0) * pageSize,
-        orderBy,
+        orderBy: orderBy === "labelName" ? "name" : orderBy,
         orderDirection
       };
     }