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

package/dist/cjs/utils/registerHelpers.js

@@ -1,52 +1,124 @@
 "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 });
-exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0;
-const ethers_1 = require("ethers");
-const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
-const labels_1 = require("./labels");
-const normalise_1 = require("./normalise");
-const recordHelpers_1 = require("./recordHelpers");
+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 registerHelpers_exports = {};
+__export(registerHelpers_exports, {
+  MAX_INT_64: () => MAX_INT_64,
+  _makeCommitment: () => _makeCommitment,
+  makeCommitment: () => makeCommitment,
+  makeCommitmentData: () => makeCommitmentData,
+  makeRegistrationData: () => makeRegistrationData,
+  randomSecret: () => randomSecret
+});
+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_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');
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+const makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  wrapperExpiry,
+  secret
+}) => {
+  var _a;
+  const label = (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";
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: "ETH", value: owner }] };
+    } else if (!((_a = records.coinTypes) == null ? void 0 : _a.find((c) => c.key === "ETH"))) {
+      if (!records.coinTypes)
+        records.coinTypes = [];
+      records.coinTypes.push({ key: "ETH", value: owner });
+    }
+  }
+  const data = records ? (0, import_recordHelpers.generateRecordCallArray)(hash, records, resolver) : [];
+  return [
+    label,
+    owner,
+    duration,
+    resolverAddress,
+    data,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || MAX_INT_64
+  ];
+};
+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;
 };
-exports.randomSecret = randomSecret;
-const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
-    const label = (0, labels_1.labelhash)(name.split('.')[0]);
-    const hash = (0, normalise_1.namehash)(name);
-    const resolverAddress = resolver.address;
-    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
-    const secret = (0, exports.randomSecret)();
-    const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
-    const commitment = (0, exports._makeCommitment)({
-        labelhash: label,
-        owner,
-        duration,
-        secret,
-        resolver: resolverAddress,
-        data,
-        reverseRecord: !!reverseRecord,
-        fuses: fuseData,
-    });
-    return {
-        secret,
-        commitment,
-    };
+const _makeCommitment = (params) => {
+  return (0, import_keccak256.keccak256)(
+    import_abi_coder.defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "address",
+        "bytes[]",
+        "bytes32",
+        "bool",
+        "uint32",
+        "uint64"
+      ],
+      params
+    )
+  );
 };
-exports.makeCommitment = makeCommitment;
-const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
-    return ethers_1.utils.solidityKeccak256([
-        'bytes32',
-        'address',
-        'uint256',
-        'bytes32',
-        'address',
-        'bytes[]',
-        'bool',
-        'uint96',
-    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8]
+  };
 };
-exports._makeCommitment = _makeCommitment;

package/dist/cjs/utils/singleCall.js

@@ -1,7 +1,24 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = async (provider, ensData, func, ...data) => func
-    .raw(ensData, ...data)
-    .then((rawData) => provider.call(rawData))
-    .catch(() => null)
-    .then((ret) => func.decode(ensData, ret, ...data));
+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 singleCall_exports = {};
+__export(singleCall_exports, {
+  default: () => singleCall_default
+});
+module.exports = __toCommonJS(singleCall_exports);
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true })).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));

package/dist/cjs/utils/validation.js

@@ -1,73 +1,86 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInputType = exports.validateTLD = exports.validateName = void 0;
-const utils_1 = require("ethers/lib/utils");
-const labels_1 = require("./labels");
-const normalise_1 = require("./normalise");
+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 validation_exports = {};
+__export(validation_exports, {
+  parseInputType: () => parseInputType,
+  validateName: () => validateName,
+  validateTLD: () => validateTLD
+});
+module.exports = __toCommonJS(validation_exports);
+var import_address = require("@ethersproject/address");
+var import_labels = require("./labels");
+var import_normalise = require("./normalise");
 const validateName = (name) => {
-    const nameArray = name.split('.');
-    const hasEmptyLabels = nameArray.some((label) => label.length == 0);
-    if (hasEmptyLabels)
-        throw new Error('Name cannot have empty labels');
-    const normalizedArray = nameArray.map((label) => {
-        if (label === '[root]') {
-            return label;
-        }
-        else {
-            return (0, labels_1.isEncodedLabelhash)(label) ? label : (0, normalise_1.normalise)(label);
-        }
-    });
-    const normalizedName = normalizedArray.join('.');
-    (0, labels_1.saveName)(normalizedName);
-    return normalizedName;
+  const nameArray = name.split(".");
+  const hasEmptyLabels = nameArray.some((label) => label.length === 0);
+  if (hasEmptyLabels)
+    throw new Error("Name cannot have empty labels");
+  const normalizedArray = nameArray.map((label) => {
+    if (label === "[root]") {
+      return label;
+    }
+    return (0, import_labels.isEncodedLabelhash)(label) ? label : (0, import_normalise.normalise)(label);
+  });
+  const normalizedName = normalizedArray.join(".");
+  (0, import_labels.saveName)(normalizedName);
+  return normalizedName;
 };
-exports.validateName = validateName;
 const validateTLD = (name) => {
-    const labels = name.split('.');
-    return (0, exports.validateName)(labels[labels.length - 1]);
+  const labels = name.split(".");
+  return validateName(labels[labels.length - 1]);
 };
-exports.validateTLD = validateTLD;
 const parseInputType = (input) => {
-    const validTLD = (0, exports.validateTLD)(input);
-    let regex = /[^.]+$/;
-    try {
-        (0, exports.validateName)(input);
-    }
-    catch (e) {
-        return {
-            type: 'unknown',
-        };
-    }
-    if (input.indexOf('.') !== -1) {
-        const termArray = input.split('.');
-        const tld = input.match(regex) ? input.match(regex)[0] : '';
-        if (validTLD) {
-            if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {
-                // code-point length
-                return {
-                    type: 'name',
-                    info: 'short',
-                };
-            }
-            return {
-                type: 'name',
-                info: 'supported',
-            };
-        }
-        return {
-            type: 'name',
-            info: 'unsupported',
-        };
-    }
-    else if ((0, utils_1.isAddress)(input)) {
-        return {
-            type: 'address',
-        };
-    }
-    else {
+  const validTLD = validateTLD(input);
+  const regex = /[^.]+$/;
+  try {
+    validateName(input);
+  } catch (e) {
+    return {
+      type: "unknown"
+    };
+  }
+  if (input.indexOf(".") !== -1) {
+    const termArray = input.split(".");
+    const tld = input.match(regex) ? input.match(regex)[0] : "";
+    if (validTLD) {
+      if (tld === "eth" && [...termArray[termArray.length - 2]].length < 3) {
         return {
-            type: 'label',
+          type: "name",
+          info: "short"
         };
+      }
+      return {
+        type: "name",
+        info: "supported"
+      };
     }
+    return {
+      type: "name",
+      info: "unsupported"
+    };
+  }
+  if ((0, import_address.isAddress)(input)) {
+    return {
+      type: "address"
+    };
+  }
+  return {
+    type: "label"
+  };
 };
-exports.parseInputType = parseInputType;

package/dist/cjs/utils/wrapper.js

@@ -0,0 +1,51 @@
+"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 wrapper_exports = {};
+__export(wrapper_exports, {
+  MAX_EXPIRY: () => MAX_EXPIRY,
+  makeExpiry: () => makeExpiry,
+  wrappedLabelLengthCheck: () => wrappedLabelLengthCheck
+});
+module.exports = __toCommonJS(wrapper_exports);
+var import_bignumber = require("@ethersproject/bignumber/lib/bignumber");
+var import_utf8 = require("@ethersproject/strings/lib/utf8");
+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);
+  }
+  if (name.endsWith(".eth")) {
+    const expResponse = await getExpiry(name);
+    if (!(expResponse == null ? void 0 : expResponse.expiry))
+      throw new Error("Couldn't get expiry for name, please provide one.");
+    return import_bignumber.BigNumber.from(expResponse.expiry.getTime() / 1e3);
+  }
+  return MAX_EXPIRY;
+};
+const wrappedLabelLengthCheck = (label) => {
+  const bytes = (0, import_utf8.toUtf8Bytes)(label);
+  if (bytes.byteLength > 255)
+    throw new Error("Label can't be longer than 255 bytes");
+};

package/dist/cjs/utils/writeTx.js

@@ -0,0 +1,25 @@
+"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 writeTx_exports = {};
+__export(writeTx_exports, {
+  default: () => writeTx_default
+});
+module.exports = __toCommonJS(writeTx_exports);
+const withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+var writeTx_default = (signer, populate) => ({ customData, ...tx }) => populate ? withCustomData(tx, customData) : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));

package/dist/esm/GqlManager.mjs

@@ -0,0 +1,88 @@
+// src/GqlManager.ts
+import { namehash } from "./utils/normalise.mjs";
+var generateSelection = (selection) => ({
+  kind: "Field",
+  name: {
+    kind: "Name",
+    value: selection
+  },
+  arguments: [],
+  directives: [],
+  alias: void 0,
+  selectionSet: void 0
+});
+var enter = (node) => {
+  let hasName = false;
+  let hasId = false;
+  for (const selection of node.selections) {
+    if ("name" in selection) {
+      if (selection.name.value === "name")
+        hasName = true;
+      else if (selection.name.value === "id")
+        hasId = true;
+    }
+  }
+  if (hasName && !hasId) {
+    node.selections = [...node.selections, generateSelection("id")];
+    return node;
+  }
+};
+var requestMiddleware = (visit, parse, print) => (request) => {
+  const requestBody = JSON.parse(request.body);
+  const rawQuery = requestBody.query;
+  const parsedQuery = parse(rawQuery);
+  const updatedQuery = visit(parsedQuery, {
+    SelectionSet: {
+      enter
+    }
+  });
+  return {
+    ...request,
+    body: JSON.stringify({ ...requestBody, query: print(updatedQuery) })
+  };
+};
+var responseMiddleware = (traverse) => (response) => {
+  traverse(response).forEach(function(responseItem) {
+    if (responseItem instanceof Object && responseItem.name) {
+      if (responseItem.name && responseItem.name.includes("[")) {
+        return;
+      }
+      const hashedName = namehash(responseItem.name);
+      if (responseItem.id !== hashedName) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true });
+      }
+    }
+  });
+  return response;
+};
+var GqlManager = class {
+  gql = (query) => query.join();
+  client = {
+    request: () => Promise.resolve(null)
+  };
+  setUrl = async (url) => {
+    if (url) {
+      const [imported, traverse, { visit, parse, print }] = await Promise.all([
+        import("graphql-request"),
+        import("traverse"),
+        import("graphql/language")
+      ]);
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse, print),
+        responseMiddleware: responseMiddleware(traverse.default)
+      });
+      this.gql = imported.gql;
+    } else {
+      this.client = {
+        request: () => Promise.resolve(null)
+      };
+      this.gql = (query) => query.join();
+    }
+  };
+};
+export {
+  GqlManager as default,
+  enter,
+  requestMiddleware,
+  responseMiddleware
+};

package/dist/esm/contracts/baseRegistrar.mjs

@@ -0,0 +1,6 @@
+// src/contracts/baseRegistrar.ts
+import { BaseRegistrarImplementation__factory } from "../generated/factories/BaseRegistrarImplementation__factory.mjs";
+var baseRegistrar_default = (provider, address) => BaseRegistrarImplementation__factory.connect(address, provider);
+export {
+  baseRegistrar_default as default
+};

package/dist/esm/contracts/bulkRenewal.mjs

@@ -0,0 +1,6 @@
+// src/contracts/bulkRenewal.ts
+import { BulkRenewal__factory } from "../generated/factories/BulkRenewal__factory.mjs";
+var bulkRenewal_default = (provider, address) => BulkRenewal__factory.connect(address, provider);
+export {
+  bulkRenewal_default as default
+};

package/dist/esm/contracts/dnsRegistrar.mjs

@@ -0,0 +1,6 @@
+// src/contracts/dnsRegistrar.ts
+import { DNSRegistrar__factory } from "../generated/factories/DNSRegistrar__factory.mjs";
+var dnsRegistrar_default = (provider, address) => DNSRegistrar__factory.connect(address, provider);
+export {
+  dnsRegistrar_default as default
+};

package/dist/esm/contracts/ethRegistrarController.mjs

@@ -0,0 +1,6 @@
+// src/contracts/ethRegistrarController.ts
+import { ETHRegistrarController__factory } from "../generated/factories/ETHRegistrarController__factory.mjs";
+var ethRegistrarController_default = (provider, address) => ETHRegistrarController__factory.connect(address, provider);
+export {
+  ethRegistrarController_default as default
+};

package/dist/esm/contracts/getContractAddress.mjs

@@ -0,0 +1,66 @@
+// src/contracts/getContractAddress.ts
+var addresses = {
+  BaseRegistrarImplementation: {
+    "1": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
+    "3": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
+    "4": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
+    "5": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85"
+  },
+  DNSRegistrar: {
+    "1": "0x58774Bb8acD458A640aF0B88238369A167546ef2",
+    "3": "0xdB328BA5FEcb432AF325Ca59E3778441eF5aa14F",
+    "5": "0x8edc487D26F6c8Fa76e032066A3D4F87E273515d"
+  },
+  ETHRegistrarController: {
+    "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
+    "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",
+    "4": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
+    "5": "0x9C51161bA2FB02Cc0a403332B607117685f34831"
+  },
+  Multicall: "0xcA11bde05977b3631167028862bE2a173976CA11",
+  NameWrapper: {
+    "1": "0x0000000000000000000000000000000000000000",
+    "3": "0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C",
+    "4": "0x0000000000000000000000000000000000000000",
+    "5": "0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8"
+  },
+  PublicResolver: {
+    "1": "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41",
+    "3": "0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837",
+    "5": "0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852"
+  },
+  ENSRegistry: {
+    "1": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",
+    "3": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",
+    "4": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",
+    "5": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e"
+  },
+  ReverseRegistrar: {
+    "1": "0x084b1c3C81545d370f3634392De611CaaBFf8148",
+    "3": "0x806246b52f8cB61655d3038c58D2f63Aa55d4edE",
+    "5": "0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48"
+  },
+  UniversalResolver: {
+    "1": "0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376",
+    "3": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376",
+    "4": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376",
+    "5": "0x687c30Cc44bFA39A1449e86E172BF002E7b3f0b0"
+  },
+  BulkRenewal: {
+    "1": "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035",
+    "3": "0x051b02245D826757EfaF5C6209D4D79FB39FBC45",
+    "5": "0xa9e1df95a79C768aA435805b28E1B54Bb5ead063"
+  }
+};
+var getContractAddress = (networkId) => (contractName) => {
+  try {
+    return typeof addresses[contractName] === "string" ? addresses[contractName] : addresses[contractName][networkId];
+  } catch {
+    throw new Error(
+      `No address for contract ${contractName} on network ${networkId}`
+    );
+  }
+};
+export {
+  getContractAddress
+};

package/dist/esm/contracts/index.mjs

@@ -0,0 +1,44 @@
+// src/contracts/index.ts
+var ContractManager = class {
+  provider;
+  fetchAddress;
+  getModule = async (name) => {
+    const mod = await import(
+      /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
+      `../generated/factories/${name}__factory`
+    );
+    return mod[`${name}__factory`];
+  };
+  constructor(provider, fetchAddress, getModule) {
+    this.provider = provider;
+    this.fetchAddress = fetchAddress;
+    if (getModule) {
+      this.getModule = getModule;
+    }
+  }
+  generateContractGetter = (name) => {
+    return async (passedProvider, address) => {
+      const mod = await this.getModule(name);
+      const inputAddress = address || this.fetchAddress(name);
+      const provider = passedProvider || this.provider;
+      return mod.connect(inputAddress, provider);
+    };
+  };
+  getPublicResolver = this.generateContractGetter("PublicResolver");
+  getUniversalResolver = this.generateContractGetter("UniversalResolver");
+  getRegistry = this.generateContractGetter("ENSRegistry");
+  getReverseRegistrar = this.generateContractGetter("ReverseRegistrar");
+  getNameWrapper = this.generateContractGetter("NameWrapper");
+  getDNSRegistrar = this.generateContractGetter("DNSRegistrar");
+  getBaseRegistrar = this.generateContractGetter(
+    "BaseRegistrarImplementation"
+  );
+  getEthRegistrarController = this.generateContractGetter(
+    "ETHRegistrarController"
+  );
+  getMulticall = this.generateContractGetter("Multicall");
+  getBulkRenewal = this.generateContractGetter("BulkRenewal");
+};
+export {
+  ContractManager as default
+};