@ensdomains/ensjs 3.0.0-alpha.45 → 3.0.0-alpha.47

package/dist/cjs/functions/deleteSubname.js

@@ -23,17 +23,17 @@ __export(deleteSubname_exports, {
 module.exports = __toCommonJS(deleteSubname_exports);
 var import_solidity = require("@ethersproject/solidity");
 var import_normalise = require("../utils/normalise");
-async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+async function deleteSubname_default({ contracts, signer }, name, { contract, ...args }) {
   const labels = name.split(".");
   if (labels.length < 3) {
     throw new Error(`${name} is not a valid subname`);
   }
-  const label = labels.shift();
-  const labelhash = (0, import_solidity.keccak256)(["string"], [label]);
-  const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
   switch (contract) {
     case "registry": {
       const registry = (await contracts.getRegistry()).connect(signer);
+      const label = labels.shift();
+      const labelhash = (0, import_solidity.keccak256)(["string"], [label]);
+      const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
@@ -44,12 +44,22 @@ async function deleteSubname_default({ contracts, signer }, name, { contract })
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      return nameWrapper.populateTransaction.setSubnodeRecord(
+      const { method } = args;
+      if (method === "setRecord") {
+        const node = (0, import_normalise.namehash)(name);
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          "0x0000000000000000000000000000000000000000",
+          "0x0000000000000000000000000000000000000000",
+          0
+        );
+      }
+      const label = labels.shift();
+      const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
+      return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
         "0x0000000000000000000000000000000000000000",
-        "0x0000000000000000000000000000000000000000",
-        0,
         0,
         0
       );

package/dist/cjs/functions/getNames.js

@@ -28,6 +28,16 @@ const mapDomain = ({ name, ...domain }) => {
   const decrypted = name ? (0, import_labels.decryptName)(name) : void 0;
   return {
     ...domain,
+    ...domain.registration ? {
+      registration: {
+        expiryDate: new Date(
+          parseInt(domain.registration.expiryDate) * 1e3
+        ),
+        registrationDate: new Date(
+          parseInt(domain.registration.registrationDate) * 1e3
+        )
+      }
+    } : {},
     name: decrypted,
     truncatedName: decrypted ? (0, import_format.truncateFormat)(decrypted) : void 0,
     createdAt: new Date(parseInt(domain.createdAt) * 1e3),
@@ -35,19 +45,13 @@ const mapDomain = ({ name, ...domain }) => {
   };
 };
 const mapWrappedDomain = (wrappedDomain) => {
-  const domain = mapDomain(wrappedDomain.domain);
-  if (domain.registration) {
-    domain.registration = {
-      expiryDate: new Date(
-        parseInt(domain.registration.expiryDate) * 1e3
-      ),
-      registrationDate: new Date(
-        parseInt(domain.registration.registrationDate) * 1e3
-      )
-    };
+  const expiryDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+  if (expiryDate && expiryDate < new Date() && (0, import_fuses.checkPCCBurned)(wrappedDomain.fuses)) {
+    return null;
   }
+  const domain = mapDomain(wrappedDomain.domain);
   return {
-    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    expiryDate,
     fuses: (0, import_fuses.decodeFuses)(wrappedDomain.fuses),
     ...domain,
     type: "wrappedDomain"
@@ -106,6 +110,10 @@ const getNames = async ({ gqlInstance }, {
           domains(first: 1000) {
             ${domainQueryData}
             createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
           }
           wrappedDomains(first: 1000) {
             expiryDate
@@ -137,6 +145,10 @@ const getNames = async ({ gqlInstance }, {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
               createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -310,7 +322,7 @@ const getNames = async ({ gqlInstance }, {
     return [
       ...(account == null ? void 0 : account.domains.map(mapDomain)) || [],
       ...(account == null ? void 0 : account.registrations.map(mapRegistration)) || [],
-      ...(account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain)) || []
+      ...(account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain).filter((d) => d)) || []
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -328,7 +340,7 @@ const getNames = async ({ gqlInstance }, {
     return (account == null ? void 0 : account.domains.map(mapDomain)) || [];
   }
   if (type === "wrappedOwner") {
-    return (account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain)) || [];
+    return (account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain).filter((d) => d)) || [];
   }
   return (account == null ? void 0 : account.registrations.map(mapRegistration)) || [];
 };

package/dist/cjs/functions/getSubnames.js

@@ -22,6 +22,7 @@ __export(getSubnames_exports, {
 });
 module.exports = __toCommonJS(getSubnames_exports);
 var import_format = require("../utils/format");
+var import_fuses = require("../utils/fuses");
 var import_labels = require("../utils/labels");
 var import_normalise = require("../utils/normalise");
 const largeQuery = async ({ gqlInstance }, {
@@ -77,6 +78,13 @@ const largeQuery = async ({ gqlInstance }, {
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
@@ -92,14 +100,30 @@ const largeQuery = async ({ gqlInstance }, {
   };
   const response = await client.request(finalQuery, queryVars);
   const domain = response == null ? void 0 : response.domain;
-  const subdomains = domain.subdomains.map((subname) => {
-    const decrypted = (0, import_labels.decryptName)(subname.name);
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: (0, import_format.truncateFormat)(decrypted)
-    };
-  });
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }) => {
+      const decrypted = (0, import_labels.decryptName)(subname.name);
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || "",
+        name: decrypted,
+        truncatedName: (0, import_format.truncateFormat)(decrypted),
+        owner: subname.owner.id,
+        type: "domain"
+      };
+      if (wrappedDomain) {
+        obj.type = "wrappedDomain";
+        const expiryDateAsDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date();
+        obj.expiryDate = expiryDateAsDate;
+        obj.fuses = (0, import_fuses.decodeFuses)(hasExpired ? 0 : wrappedDomain.fuses);
+        obj.pccExpired = hasExpired ? (0, import_fuses.checkPCCBurned)(wrappedDomain.fuses) : false;
+        obj.owner = obj.pccExpired ? void 0 : wrappedDomain.owner.id;
+      }
+      return obj;
+    }
+  );
   return {
     subnames: subdomains,
     subnameCount: domain.subdomainCount

package/dist/cjs/functions/transferSubname.js

@@ -24,11 +24,7 @@ module.exports = __toCommonJS(transferSubname_exports);
 var import_solidity = require("@ethersproject/solidity");
 var import_normalise = require("../utils/normalise");
 var import_wrapper = require("../utils/wrapper");
-async function transferSubname_default({
-  contracts,
-  signer,
-  getExpiry
-}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+async function transferSubname_default({ contracts, signer }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
   const labels = name.split(".");
   const label = labels.shift();
   const labelhash = (0, import_solidity.keccak256)(["string"], [label]);
@@ -44,10 +40,9 @@ async function transferSubname_default({
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      const expiry = await (0, import_wrapper.makeExpiry)(
-        { getExpiry },
-        labels.join("."),
-        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      const expiry = (0, import_wrapper.expiryToBigNumber)(
+        wrapperArgs.expiry,
+        0
       );
       return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,

package/dist/cjs/index.js

@@ -316,7 +316,7 @@ class ENS {
     this.importDNSSECName = this.generateWriteFunction("importDNSSECName", ["contracts", "provider", "signer"]);
     this.createSubname = this.generateWriteFunction("createSubname", ["contracts", "getExpiry"]);
     this.deleteSubname = this.generateWriteFunction("deleteSubname", ["contracts"]);
-    this.transferSubname = this.generateWriteFunction("transferSubname", ["contracts", "getExpiry"]);
+    this.transferSubname = this.generateWriteFunction("transferSubname", ["contracts"]);
     this.commitName = this.generateWriteFunction(
       "commitName",
       ["contracts"]

package/dist/cjs/utils/consts.js

@@ -23,4 +23,4 @@ __export(consts_exports, {
 });
 module.exports = __toCommonJS(consts_exports);
 const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
-const MAX_INT_64 = 2n ** 64n - 1n;
+const MAX_INT_64 = BigInt("18446744073709551615");

package/dist/cjs/utils/fuses.js

@@ -21,6 +21,7 @@ __export(fuses_exports, {
   CHILD_CONTROLLED_FUSES: () => CHILD_CONTROLLED_FUSES,
   PARENT_CONTROLLED_FUSES: () => PARENT_CONTROLLED_FUSES,
   USER_SETTABLE_FUSES: () => USER_SETTABLE_FUSES,
+  checkPCCBurned: () => checkPCCBurned,
   childFuseEnum: () => childFuseEnum,
   childFuseKeys: () => childFuseKeys,
   decodeFuses: () => decodeFuses,
@@ -297,4 +298,5 @@ const decodeFuses = (fuses) => {
     }
   };
 };
+const checkPCCBurned = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
 var fuses_default = fullFuseEnum;

package/dist/cjs/utils/registry.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 registry_exports = {};
+__export(registry_exports, {
+  makeResolver: () => makeResolver
+});
+module.exports = __toCommonJS(registry_exports);
+var import_normalise = require("./normalise");
+const makeResolver = async ({ contracts }, name, resolver) => {
+  if (resolver)
+    return resolver;
+  const registry = await contracts.getRegistry();
+  const node = (0, import_normalise.namehash)(name);
+  const _resolver = await registry.resolver(node);
+  return _resolver;
+};

package/dist/cjs/utils/wrapper.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var wrapper_exports = {};
 __export(wrapper_exports, {
   MAX_EXPIRY: () => MAX_EXPIRY,
+  expiryToBigNumber: () => expiryToBigNumber,
   makeExpiry: () => makeExpiry,
   wrappedLabelLengthCheck: () => wrappedLabelLengthCheck
 });
@@ -26,16 +27,20 @@ module.exports = __toCommonJS(wrapper_exports);
 var import_bignumber = require("@ethersproject/bignumber");
 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) {
-    if (expiry instanceof Date) {
-      return import_bignumber.BigNumber.from(expiry.getTime() / 1e3);
-    }
-    if (expiry instanceof import_bignumber.BigNumber) {
-      return expiry;
-    }
-    return import_bignumber.BigNumber.from(expiry);
+const expiryToBigNumber = (expiry, defaultValue = 0) => {
+  if (!expiry)
+    return import_bignumber.BigNumber.from(defaultValue);
+  if (expiry instanceof Date) {
+    return import_bignumber.BigNumber.from(expiry.getTime() / 1e3);
+  }
+  if (expiry instanceof import_bignumber.BigNumber) {
+    return expiry;
   }
+  return import_bignumber.BigNumber.from(expiry);
+};
+const makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry)
+    return expiryToBigNumber(expiry);
   if (name.endsWith(".eth")) {
     const expResponse = await getExpiry(name);
     if (!(expResponse == null ? void 0 : expResponse.expiry))

package/dist/esm/functions/deleteSubname.mjs

@@ -1,17 +1,17 @@
 // src/functions/deleteSubname.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { namehash } from "../utils/normalise.mjs";
-async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+async function deleteSubname_default({ contracts, signer }, name, { contract, ...args }) {
   const labels = name.split(".");
   if (labels.length < 3) {
     throw new Error(`${name} is not a valid subname`);
   }
-  const label = labels.shift();
-  const labelhash = solidityKeccak256(["string"], [label]);
-  const parentNodehash = namehash(labels.join("."));
   switch (contract) {
     case "registry": {
       const registry = (await contracts.getRegistry()).connect(signer);
+      const label = labels.shift();
+      const labelhash = solidityKeccak256(["string"], [label]);
+      const parentNodehash = namehash(labels.join("."));
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
@@ -22,12 +22,22 @@ async function deleteSubname_default({ contracts, signer }, name, { contract })
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      return nameWrapper.populateTransaction.setSubnodeRecord(
+      const { method } = args;
+      if (method === "setRecord") {
+        const node = namehash(name);
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          "0x0000000000000000000000000000000000000000",
+          "0x0000000000000000000000000000000000000000",
+          0
+        );
+      }
+      const label = labels.shift();
+      const parentNodehash = namehash(labels.join("."));
+      return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
         "0x0000000000000000000000000000000000000000",
-        "0x0000000000000000000000000000000000000000",
-        0,
         0,
         0
       );

package/dist/esm/functions/getNames.mjs

@@ -1,11 +1,21 @@
 // src/functions/getNames.ts
 import { truncateFormat } from "../utils/format.mjs";
-import { decodeFuses } from "../utils/fuses.mjs";
+import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
 var mapDomain = ({ name, ...domain }) => {
   const decrypted = name ? decryptName(name) : void 0;
   return {
     ...domain,
+    ...domain.registration ? {
+      registration: {
+        expiryDate: new Date(
+          parseInt(domain.registration.expiryDate) * 1e3
+        ),
+        registrationDate: new Date(
+          parseInt(domain.registration.registrationDate) * 1e3
+        )
+      }
+    } : {},
     name: decrypted,
     truncatedName: decrypted ? truncateFormat(decrypted) : void 0,
     createdAt: new Date(parseInt(domain.createdAt) * 1e3),
@@ -13,19 +23,13 @@ var mapDomain = ({ name, ...domain }) => {
   };
 };
 var mapWrappedDomain = (wrappedDomain) => {
-  const domain = mapDomain(wrappedDomain.domain);
-  if (domain.registration) {
-    domain.registration = {
-      expiryDate: new Date(
-        parseInt(domain.registration.expiryDate) * 1e3
-      ),
-      registrationDate: new Date(
-        parseInt(domain.registration.registrationDate) * 1e3
-      )
-    };
+  const expiryDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+  if (expiryDate && expiryDate < new Date() && checkPCCBurned(wrappedDomain.fuses)) {
+    return null;
   }
+  const domain = mapDomain(wrappedDomain.domain);
   return {
-    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    expiryDate,
     fuses: decodeFuses(wrappedDomain.fuses),
     ...domain,
     type: "wrappedDomain"
@@ -84,6 +88,10 @@ var getNames = async ({ gqlInstance }, {
           domains(first: 1000) {
             ${domainQueryData}
             createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
           }
           wrappedDomains(first: 1000) {
             expiryDate
@@ -115,6 +123,10 @@ var getNames = async ({ gqlInstance }, {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
               createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -288,7 +300,7 @@ var getNames = async ({ gqlInstance }, {
     return [
       ...account?.domains.map(mapDomain) || [],
       ...account?.registrations.map(mapRegistration) || [],
-      ...account?.wrappedDomains.map(mapWrappedDomain) || []
+      ...account?.wrappedDomains.map(mapWrappedDomain).filter((d) => d) || []
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -306,7 +318,7 @@ var getNames = async ({ gqlInstance }, {
     return account?.domains.map(mapDomain) || [];
   }
   if (type === "wrappedOwner") {
-    return account?.wrappedDomains.map(mapWrappedDomain) || [];
+    return account?.wrappedDomains.map(mapWrappedDomain).filter((d) => d) || [];
   }
   return account?.registrations.map(mapRegistration) || [];
 };

package/dist/esm/functions/getSubnames.mjs

@@ -1,5 +1,6 @@
 // src/functions/getSubnames.ts
 import { truncateFormat } from "../utils/format.mjs";
+import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var largeQuery = async ({ gqlInstance }, {
@@ -55,6 +56,13 @@ var largeQuery = async ({ gqlInstance }, {
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
@@ -70,14 +78,30 @@ var largeQuery = async ({ gqlInstance }, {
   };
   const response = await client.request(finalQuery, queryVars);
   const domain = response?.domain;
-  const subdomains = domain.subdomains.map((subname) => {
-    const decrypted = decryptName(subname.name);
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted)
-    };
-  });
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }) => {
+      const decrypted = decryptName(subname.name);
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || "",
+        name: decrypted,
+        truncatedName: truncateFormat(decrypted),
+        owner: subname.owner.id,
+        type: "domain"
+      };
+      if (wrappedDomain) {
+        obj.type = "wrappedDomain";
+        const expiryDateAsDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date();
+        obj.expiryDate = expiryDateAsDate;
+        obj.fuses = decodeFuses(hasExpired ? 0 : wrappedDomain.fuses);
+        obj.pccExpired = hasExpired ? checkPCCBurned(wrappedDomain.fuses) : false;
+        obj.owner = obj.pccExpired ? void 0 : wrappedDomain.owner.id;
+      }
+      return obj;
+    }
+  );
   return {
     subnames: subdomains,
     subnameCount: domain.subdomainCount

package/dist/esm/functions/transferSubname.mjs

@@ -1,12 +1,8 @@
 // src/functions/transferSubname.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { namehash } from "../utils/normalise.mjs";
-import { makeExpiry } from "../utils/wrapper.mjs";
-async function transferSubname_default({
-  contracts,
-  signer,
-  getExpiry
-}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+import { expiryToBigNumber } from "../utils/wrapper.mjs";
+async function transferSubname_default({ contracts, signer }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
   const labels = name.split(".");
   const label = labels.shift();
   const labelhash = solidityKeccak256(["string"], [label]);
@@ -22,10 +18,9 @@ async function transferSubname_default({
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      const expiry = await makeExpiry(
-        { getExpiry },
-        labels.join("."),
-        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      const expiry = expiryToBigNumber(
+        wrapperArgs.expiry,
+        0
       );
       return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,

package/dist/esm/index.mjs

@@ -293,7 +293,7 @@ var ENS = class {
   importDNSSECName = this.generateWriteFunction("importDNSSECName", ["contracts", "provider", "signer"]);
   createSubname = this.generateWriteFunction("createSubname", ["contracts", "getExpiry"]);
   deleteSubname = this.generateWriteFunction("deleteSubname", ["contracts"]);
-  transferSubname = this.generateWriteFunction("transferSubname", ["contracts", "getExpiry"]);
+  transferSubname = this.generateWriteFunction("transferSubname", ["contracts"]);
   commitName = this.generateWriteFunction(
     "commitName",
     ["contracts"]

package/dist/esm/utils/consts.mjs

@@ -1,6 +1,6 @@
 // src/utils/consts.ts
 var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
-var MAX_INT_64 = 2n ** 64n - 1n;
+var MAX_INT_64 = BigInt("18446744073709551615");
 export {
   EMPTY_ADDRESS,
   MAX_INT_64

package/dist/esm/utils/fuses.mjs

@@ -257,11 +257,13 @@ var decodeFuses = (fuses) => {
     }
   };
 };
+var checkPCCBurned = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
 var fuses_default = fullFuseEnum;
 export {
   CHILD_CONTROLLED_FUSES,
   PARENT_CONTROLLED_FUSES,
   USER_SETTABLE_FUSES,
+  checkPCCBurned,
   childFuseEnum,
   childFuseKeys,
   decodeFuses,

package/dist/esm/utils/registry.mjs

@@ -0,0 +1,13 @@
+// src/utils/registry.ts
+import { namehash } from "./normalise.mjs";
+var makeResolver = async ({ contracts }, name, resolver) => {
+  if (resolver)
+    return resolver;
+  const registry = await contracts.getRegistry();
+  const node = namehash(name);
+  const _resolver = await registry.resolver(node);
+  return _resolver;
+};
+export {
+  makeResolver
+};

package/dist/esm/utils/wrapper.mjs

@@ -2,16 +2,20 @@
 import { BigNumber } from "@ethersproject/bignumber";
 import { toUtf8Bytes } from "@ethersproject/strings";
 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);
+var expiryToBigNumber = (expiry, defaultValue = 0) => {
+  if (!expiry)
+    return BigNumber.from(defaultValue);
+  if (expiry instanceof Date) {
+    return BigNumber.from(expiry.getTime() / 1e3);
+  }
+  if (expiry instanceof BigNumber) {
+    return expiry;
   }
+  return BigNumber.from(expiry);
+};
+var makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry)
+    return expiryToBigNumber(expiry);
   if (name.endsWith(".eth")) {
     const expResponse = await getExpiry(name);
     if (!expResponse?.expiry)
@@ -27,6 +31,7 @@ var wrappedLabelLengthCheck = (label) => {
 };
 export {
   MAX_EXPIRY,
+  expiryToBigNumber,
   makeExpiry,
   wrappedLabelLengthCheck
 };

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

@@ -1,6 +1,12 @@
 import { ENSArgs } from '..';
-declare type Args = {
+declare type BaseArgs = {
     contract: 'registry' | 'nameWrapper';
+    method?: 'setRecord' | 'setSubnodeOwner';
 };
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract }: Args): Promise<import("ethers").PopulatedTransaction>;
+declare type NameWrapperArgs = {
+    contract: 'nameWrapper';
+    method: 'setRecord' | 'setSubnodeOwner';
+};
+declare type Args = BaseArgs | NameWrapperArgs;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, ...args }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};