@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.40

package/dist/cjs/functions/setRecords.js

@@ -1,22 +1,52 @@
 "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
+}) {
+  var _a;
+  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 = (_a = await (contracts == null ? void 0 : contracts.getPublicResolver(provider, resolverToUse))) == null ? void 0 : _a.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 == null ? void 0 : 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 == null ? void 0 : 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/supportsTLD.js

@@ -0,0 +1,48 @@
+"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 supportsTLD_exports = {};
+__export(supportsTLD_exports, {
+  default: () => supportsTLD_default
+});
+module.exports = __toCommonJS(supportsTLD_exports);
+var import_DNSRegistrar_factory = require("../generated/factories/DNSRegistrar__factory");
+const DNSSEC_CLAIM_INTERFACE_IDS = ["0x2f435428", "0x17d8f49b", "0x1aa2e641"];
+async function supportsTLD_default({ getOwner, provider }, name) {
+  try {
+    const labels = name.split(".");
+    const tld = labels[labels.length - 1];
+    if (tld === "eth")
+      return true;
+    const tldOwner = await getOwner(tld, "registry");
+    if (!(tldOwner == null ? void 0 : tldOwner.owner))
+      return false;
+    const dnsRegistrar = import_DNSRegistrar_factory.DNSRegistrar__factory.connect(
+      tldOwner.owner,
+      provider
+    );
+    const supports = await Promise.all(
+      DNSSEC_CLAIM_INTERFACE_IDS.map(
+        (interfaceId) => dnsRegistrar.supportsInterface(interfaceId)
+      )
+    );
+    return supports.some((s) => !!s);
+  } catch {
+    return false;
+  }
+}

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_solidity = require("@ethersproject/solidity");
+async function transferController_default({ contracts, signer }, name, {
+  newOwner,
+  isOwner
+}) {
+  const baseRegistrar = (await (contracts == null ? void 0 : contracts.getBaseRegistrar())).connect(signer);
+  const registry = (await (contracts == null ? void 0 : contracts.getRegistry())).connect(signer);
+  const labels = name.split(".");
+  if (isOwner) {
+    return registry.populateTransaction.setOwner(
+      (0, import_solidity.keccak256)(["string"], [labels[0]]),
+      newOwner
+    );
+  }
+  return baseRegistrar.populateTransaction.reclaim(
+    (0, import_solidity.keccak256)(["string"], [labels[0]]),
+    newOwner
+  );
+}

package/dist/cjs/functions/transferName.js

@@ -1,34 +1,65 @@
 "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_solidity = require("@ethersproject/solidity");
+var import_normalise = require("../utils/normalise");
+async function transferName_default({ contracts, signer }, name, {
+  newOwner,
+  contract,
+  reclaim
+}) {
+  const address = await signer.getAddress();
+  switch (contract) {
+    case "registry": {
+      const registry = (await (contracts == null ? void 0 : 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 == null ? void 0 : contracts.getBaseRegistrar())).connect(
+        signer
+      );
+      const labels = name.split(".");
+      if (labels.length > 2 || labels[labels.length - 1] !== "eth") {
+        throw new Error("Invalid name for baseRegistrar");
+      }
+      const tokenId = (0, import_solidity.keccak256)(["string"], [labels[0]]);
+      if (reclaim) {
+        return baseRegistrar.populateTransaction.reclaim(tokenId, newOwner);
+      }
+      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](address, newOwner, tokenId);
     }
+    case "nameWrapper": {
+      const nameWrapper = (await (contracts == null ? void 0 : 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_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 }) {
+  const labels = name.split(".");
+  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);
+      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/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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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_solidity = require("@ethersproject/solidity");
+var import_normalise = require("../utils/normalise");
+async function unwrapName_default({ contracts, signer }, name, {
+  newController,
+  newRegistrant
+}) {
+  const labels = name.split(".");
+  const labelhash = (0, import_solidity.keccak256)(["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;