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

package/dist/cjs/functions/setRecords.js

@@ -1,22 +1,51 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const normalise_1 = require("../utils/normalise");
-const recordHelpers_1 = require("../utils/recordHelpers");
-async function default_1({ contracts, provider, getResolver, }, name, records) {
-    if (!name.includes('.')) {
-        throw new Error('Input is not an ENS name');
-    }
-    const resolverAddress = await getResolver(name);
-    if (!resolverAddress) {
-        throw new Error('No resolver found for input address');
-    }
-    const address = await provider?.getSigner().getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
-    const resolver = (await contracts?.getPublicResolver(provider, resolverAddress))?.connect(provider?.getSigner());
-    const hash = (0, normalise_1.namehash)(name);
-    const calls = (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver);
-    return resolver?.multicall(calls);
+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 setRecords_exports = {};
+__export(setRecords_exports, {
+  default: () => setRecords_default
+});
+module.exports = __toCommonJS(setRecords_exports);
+var import_normalise = require("../utils/normalise");
+var import_recordHelpers = require("../utils/recordHelpers");
+async function setRecords_default({
+  contracts,
+  provider,
+  getResolver,
+  signer
+}, name, {
+  records,
+  resolverAddress
+}) {
+  if (!name.includes(".")) {
+    throw new Error("Input is not an ENS name");
+  }
+  let resolverToUse;
+  if (resolverAddress) {
+    resolverToUse = resolverAddress;
+  } else {
+    resolverToUse = await getResolver(name);
+  }
+  if (!resolverToUse) {
+    throw new Error("No resolver found for input address");
+  }
+  const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+  const hash = (0, import_normalise.namehash)(name);
+  const calls = (0, import_recordHelpers.generateRecordCallArray)(hash, records, resolver);
+  return resolver.populateTransaction.multicall(calls);
 }
-exports.default = default_1;

package/dist/cjs/functions/setResolver.js

@@ -1,28 +1,48 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, contract, resolver, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
+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 setResolver_exports = {};
+__export(setResolver_exports, {
+  default: () => setResolver_default
+});
+module.exports = __toCommonJS(setResolver_exports);
+var import_normalise = require("../utils/normalise");
+async function setResolver_default({ contracts, signer }, name, {
+  contract,
+  resolver
+}) {
+  if (!resolver) {
+    resolver = (await contracts.getPublicResolver()).address;
+  }
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts?.getRegistry()).connect(signer);
+      return registry.populateTransaction.setResolver((0, import_normalise.namehash)(name), resolver);
     }
-    if (!resolver) {
-        resolver = (await contracts?.getPublicResolver()).address;
+    case "nameWrapper": {
+      const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.setResolver(
+        (0, import_normalise.namehash)(name),
+        resolver
+      );
     }
-    switch (contract) {
-        case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setResolver((0, normalise_1.namehash)(name), resolver);
-        }
-        case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.setResolver((0, normalise_1.namehash)(name), resolver);
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
     }
+  }
 }
-exports.default = default_1;

package/dist/cjs/functions/transferController.js

@@ -0,0 +1,42 @@
+"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 transferController_exports = {};
+__export(transferController_exports, {
+  default: () => transferController_default
+});
+module.exports = __toCommonJS(transferController_exports);
+var import_ethers = require("ethers");
+async function transferController_default({ contracts, signer }, name, {
+  newOwner,
+  isOwner
+}) {
+  const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
+  const registry = (await contracts?.getRegistry()).connect(signer);
+  const labels = name.split(".");
+  if (isOwner) {
+    return registry.populateTransaction.setOwner(
+      import_ethers.ethers.utils.solidityKeccak256(["string"], [labels[0]]),
+      newOwner
+    );
+  }
+  return baseRegistrar.populateTransaction.reclaim(
+    import_ethers.ethers.utils.solidityKeccak256(["string"], [labels[0]]),
+    newOwner
+  );
+}

package/dist/cjs/functions/transferName.js

@@ -1,34 +1,64 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, newOwner, contract, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
+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 transferName_exports = {};
+__export(transferName_exports, {
+  default: () => transferName_default
+});
+module.exports = __toCommonJS(transferName_exports);
+var import_ethers = require("ethers");
+var import_normalise = require("../utils/normalise");
+async function transferName_default({ contracts, signer }, name, {
+  newOwner,
+  contract
+}) {
+  const address = await signer.getAddress();
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts?.getRegistry()).connect(signer);
+      return registry.populateTransaction.setOwner((0, import_normalise.namehash)(name), newOwner);
     }
-    switch (contract) {
-        case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setOwner((0, normalise_1.namehash)(name), newOwner);
-        }
-        case 'baseRegistrar': {
-            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(provider?.getSigner(options?.addressOrIndex));
-            const labels = name.split('.');
-            if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
-                throw new Error('Invalid name for baseRegistrar');
-            }
-            return baseRegistrar['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
-        }
-        case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
+    case "baseRegistrar": {
+      const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(
+        signer
+      );
+      const labels = name.split(".");
+      if (labels.length > 2 || labels[labels.length - 1] !== "eth") {
+        throw new Error("Invalid name for baseRegistrar");
+      }
+      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](
+        address,
+        newOwner,
+        import_ethers.ethers.utils.solidityKeccak256(["string"], [labels[0]])
+      );
     }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.safeTransferFrom(
+        address,
+        newOwner,
+        (0, import_normalise.namehash)(name),
+        1,
+        "0x"
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
 }
-exports.default = default_1;

package/dist/cjs/functions/transferSubname.js

@@ -1,28 +1,64 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, contract, address, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
+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 transferSubname_exports = {};
+__export(transferSubname_exports, {
+  default: () => transferSubname_default
+});
+module.exports = __toCommonJS(transferSubname_exports);
+var import_ethers = require("ethers");
+var import_normalise = require("../utils/normalise");
+var import_wrapper = require("../utils/wrapper");
+async function transferSubname_default({
+  contracts,
+  signer,
+  getExpiry
+}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+  const labels = name.split(".");
+  const label = labels.shift();
+  const labelhash = import_ethers.ethers.utils.solidityKeccak256(["string"], [label]);
+  const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      return registry.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        labelhash,
+        owner
+      );
     }
-    const labels = name.split('.');
-    const label = labels.shift();
-    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
-    switch (contract) {
-        case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeOwner(parentNodehash, labelhash, address);
-        }
-        case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0');
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
+    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
+      );
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        owner,
+        "0",
+        expiry
+      );
     }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
 }
-exports.default = default_1;

package/dist/cjs/functions/unwrapName.js

@@ -1,28 +1,52 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, newController, newRegistrant, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
-    const labels = name.split('.');
-    const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
-    const parentNodehash = (0, normalise_1.namehash)(labels.slice(1).join('.'));
-    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    if (labels.length === 2 && labels[1] === 'eth') {
-        if (!newRegistrant) {
-            throw new Error('newRegistrant must be specified for .eth names');
-        }
-        return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController);
-    }
-    else {
-        if (newRegistrant) {
-            throw new Error('newRegistrant can only be specified for .eth names');
-        }
-        return nameWrapper.unwrap(parentNodehash, labelhash, newController);
+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 unwrapName_exports = {};
+__export(unwrapName_exports, {
+  default: () => unwrapName_default
+});
+module.exports = __toCommonJS(unwrapName_exports);
+var import_ethers = require("ethers");
+var import_normalise = require("../utils/normalise");
+async function unwrapName_default({ contracts, signer }, name, {
+  newController,
+  newRegistrant
+}) {
+  const labels = name.split(".");
+  const labelhash = import_ethers.utils.solidityKeccak256(["string"], [labels[0]]);
+  const parentNodehash = (0, import_normalise.namehash)(labels.slice(1).join("."));
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  if (labels.length === 2 && labels[1] === "eth") {
+    if (!newRegistrant) {
+      throw new Error("newRegistrant must be specified for .eth names");
     }
+    return nameWrapper.populateTransaction.unwrapETH2LD(
+      labelhash,
+      newRegistrant,
+      newController
+    );
+  }
+  if (newRegistrant) {
+    throw new Error("newRegistrant can only be specified for .eth names");
+  }
+  return nameWrapper.populateTransaction.unwrap(
+    parentNodehash,
+    labelhash,
+    newController
+  );
 }
-exports.default = default_1;

package/dist/cjs/functions/wrapName.js

@@ -1,64 +1,129 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-const hexEncodedName_1 = require("../utils/hexEncodedName");
-async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
-    const nameWrapper = await contracts?.getNameWrapper();
-    const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
-    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]);
-    const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint96', 'address'], [labels[0], wrappedOwner, decodedFuses, resolverAddress]);
-    return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
+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 __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 wrapName_exports = {};
+__export(wrapName_exports, {
+  default: () => wrapName_default
+});
+module.exports = __toCommonJS(wrapName_exports);
+var import_ethers = require("ethers");
+var import_generateFuseInput = __toESM(require("../utils/generateFuseInput"));
+var import_hexEncodedName = require("../utils/hexEncodedName");
+var import_wrapper = require("../utils/wrapper");
+async function wrapETH({ contracts }, labels, wrappedOwner, expiry, decodedFuses, resolverAddress, signer, address) {
+  const nameWrapper = await contracts?.getNameWrapper();
+  const baseRegistrar = (await contracts.getBaseRegistrar()).connect(signer);
+  const labelhash = import_ethers.ethers.utils.solidityKeccak256(["string"], [labels[0]]);
+  const data = import_ethers.ethers.utils.defaultAbiCoder.encode(
+    ["string", "address", "uint32", "uint64", "address"],
+    [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress]
+  );
+  return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256,bytes)"](address, nameWrapper.address, labelhash, data);
 }
-async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address) {
-    const nameWrapper = await contracts?.getNameWrapper();
-    const registry = await contracts?.getRegistry();
-    const hasApproval = await registry.isApprovedForAll(address, nameWrapper.address);
-    if (!hasApproval) {
-        throw new Error('NameWrapper must have approval to wrap a name from this address.');
-    }
-    return nameWrapper.wrap((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, decodedFuses, resolverAddress);
+async function wrapOther({ contracts }, name, wrappedOwner, resolverAddress, address, signer) {
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  const registry = await contracts?.getRegistry();
+  const hasApproval = await registry.isApprovedForAll(
+    address,
+    nameWrapper.address
+  );
+  if (!hasApproval) {
+    throw new Error(
+      "NameWrapper must have approval to wrap a name from this address."
+    );
+  }
+  return nameWrapper.populateTransaction.wrap(
+    (0, import_hexEncodedName.hexEncodeName)(name),
+    wrappedOwner,
+    resolverAddress
+  );
 }
-async function default_1({ contracts, provider }, name, wrappedOwner, fuseOptions, resolverAddress, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
-    let decodedFuses;
+async function wrapName_default({
+  contracts,
+  signer,
+  getExpiry
+}, name, {
+  wrappedOwner,
+  fuseOptions,
+  expiry,
+  resolverAddress
+}) {
+  const address = await signer.getAddress();
+  let decodedFuses;
+  const publicResolver = await contracts?.getPublicResolver();
+  if (!resolverAddress)
+    resolverAddress = publicResolver.address;
+  const labels = name.split(".");
+  (0, import_wrapper.wrappedLabelLengthCheck)(labels[0]);
+  if (labels.length === 2 && labels[1] === "eth") {
     switch (typeof fuseOptions) {
-        case 'object': {
-            decodedFuses = (0, generateFuseInput_1.default)(fuseOptions);
-            break;
-        }
-        case 'number': {
-            decodedFuses = fuseOptions.toString(16);
-            break;
-        }
-        case 'string': {
-            decodedFuses = fuseOptions;
-            break;
-        }
-        case 'undefined': {
-            decodedFuses = '0';
-            break;
-        }
-        default: {
-            throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
-        }
-    }
-    const publicResolver = await contracts?.getPublicResolver();
-    if (!resolverAddress)
-        resolverAddress = publicResolver.address;
-    const labels = name.split('.');
-    if (labels.length < 3 && labels[labels.length - 1] === 'eth') {
-        return wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address);
-    }
-    else {
-        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address);
+      case "object": {
+        decodedFuses = (0, import_generateFuseInput.default)(fuseOptions);
+        break;
+      }
+      case "number": {
+        decodedFuses = fuseOptions.toString(16);
+        break;
+      }
+      case "string": {
+        decodedFuses = fuseOptions;
+        break;
+      }
+      case "undefined": {
+        decodedFuses = "0";
+        break;
+      }
+      default: {
+        throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
+      }
     }
+    const expiryToUse = await (0, import_wrapper.makeExpiry)({ getExpiry }, name, expiry);
+    return wrapETH(
+      { contracts },
+      labels,
+      wrappedOwner,
+      expiryToUse,
+      decodedFuses,
+      resolverAddress,
+      signer,
+      address
+    );
+  }
+  if (fuseOptions)
+    throw new Error(
+      "Fuses can not be initially set when wrapping a non .eth name"
+    );
+  if (expiry)
+    throw new Error(
+      "Expiry can not be initially set when wrapping a non .eth name"
+    );
+  return wrapOther(
+    { contracts },
+    name,
+    wrappedOwner,
+    resolverAddress,
+    address,
+    signer
+  );
 }
-exports.default = default_1;