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

package/dist/cjs/index.js

@@ -1,228 +1,336 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+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 });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENS = void 0;
-const contracts_1 = __importDefault(require("./contracts"));
-const getContractAddress_1 = require("./contracts/getContractAddress");
-const GqlManager_1 = __importDefault(require("./GqlManager"));
-const singleCall_1 = __importDefault(require("./utils/singleCall"));
+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 src_exports = {};
+__export(src_exports, {
+  ENS: () => ENS
+});
+module.exports = __toCommonJS(src_exports);
+var import_getContractAddress = require("./contracts/getContractAddress");
+var import_contracts = __toESM(require("./contracts/index"));
+var import_GqlManager = __toESM(require("./GqlManager"));
+var import_singleCall = __toESM(require("./utils/singleCall"));
+var import_writeTx = __toESM(require("./utils/writeTx"));
 const graphURIEndpoints = {
-    1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
-    3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
-    4: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensrinkeby',
-    5: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensgoerli',
+  1: "https://api.thegraph.com/subgraphs/name/ensdomains/ens",
+  3: "https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten",
+  4: "https://api.thegraph.com/subgraphs/name/ensdomains/ensrinkeby",
+  5: "https://api.thegraph.com/subgraphs/name/ensdomains/ensgoerli"
 };
 class ENS {
-    options;
-    provider;
-    graphURI;
-    initialProvider;
-    contracts;
-    getContractAddress = getContractAddress_1.getContractAddress;
-    gqlInstance = new GqlManager_1.default();
-    constructor(options) {
-        this.options = options;
-        this.getContractAddress = options?.getContractAddress || getContractAddress_1.getContractAddress;
+  options;
+  provider;
+  graphURI;
+  initialProvider;
+  contracts;
+  getContractAddress = import_getContractAddress.getContractAddress;
+  gqlInstance = new import_GqlManager.default();
+  constructor(options) {
+    this.options = options;
+    this.getContractAddress = options?.getContractAddress || import_getContractAddress.getContractAddress;
+  }
+  checkInitialProvider = async () => {
+    if (!this.initialProvider) {
+      return;
     }
-    /**
-     * Checks for an initial provider and if it exists, sets it as the provider
-     * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed
-     */
-    checkInitialProvider = async () => {
-        if (!this.initialProvider) {
-            return;
-        }
-        await this.setProvider(this.initialProvider);
-        return;
-    };
-    /**
-     * Creates an object of ENS properties from an array
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @returns {Object} - An object of ENS properties
-     */
-    forwardDependenciesFromArray = (dependencies) => 
-    // Creates an object from entries of the array
-    Object.fromEntries(
-    // Maps over dependencies and create arrays for each, e.g. ['contracts', contractObj]
-    dependencies.map((dep) => [dep, this[dep]]));
-    /**
-     * Creates a wrapper for a function to be dynamically imported, with the correct dependencies passed in
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @param {string} subFunc - The type of function being imported
-     * @returns {Function} - The generated wrapped function
-     */
-    importGenerator = (path, dependencies, exportName = 'default', subFunc, passthrough) => {
-        // if batch is specified, create batch func
-        if (subFunc === 'batch') {
-            return (...args) => ({ args, ...passthrough });
-        }
-        const thisRef = this;
-        const mainFunc = async function (...args) {
-            // check the initial provider and set if it exists
-            await thisRef.checkInitialProvider();
-            // import the module dynamically
-            const mod = await Promise.resolve().then(() => __importStar(require(
-            /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
-            `./functions/${path}`)));
-            // if combine isn't specified, run normally
-            // otherwise, create a function from the raw and decode functions
-            if (subFunc !== 'combine') {
-                // get the function to call
-                const func = subFunc ? mod[exportName][subFunc] : mod[exportName];
-                if (dependencies.length === 0) {
-                    return func(...args);
-                }
-                // get the dependencies to forward to the function as the first arg
-                const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
-                // return the function with the dependencies forwarded
-                return func(dependenciesToForward, ...args);
-            }
-            else {
-                // get the dependencies to forward from raw and decode functions
-                const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
-                // return singleCall function with dependencies forwarded
-                return (0, singleCall_1.default)(thisRef.provider, dependenciesToForward, mod[exportName], ...args);
-            }
-        };
-        // if subfunc is combine, add raw and decode property methods to the function
-        if (subFunc === 'combine') {
-            mainFunc.raw = this.importGenerator(path, dependencies, exportName, 'raw');
-            mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
-            mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
-        }
-        return mainFunc;
-    };
-    /**
-     * Generates a normal wrapped function
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @returns {OmitFirstArg} - The generated wrapped function
-     */
-    generateFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName);
-    /**
-     * Generates a wrapped function from raw and decode exports
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @returns {GeneratedRawFunction} - The generated wrapped function
-     */
-    generateRawFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'combine');
-    /**
-     * Sets the provider for the ENS class
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to set
-     * @returns {Promise<void>} - A promise that resolves when the provider is set
-     */
-    setProvider = async (provider) => {
-        this.provider = provider;
-        const network = (await this.provider.getNetwork()).chainId;
-        if (this.options && this.options.graphURI) {
-            this.graphURI = this.options.graphURI;
-        }
-        else {
-            this.graphURI = graphURIEndpoints[network];
+    await this.setProvider(this.initialProvider);
+  };
+  forwardDependenciesFromArray = (dependencies) => Object.fromEntries(
+    dependencies.map((dep) => [dep, this[dep]])
+  );
+  importGenerator = (path, dependencies, exportName = "default", subFunc, passthrough) => {
+    if (subFunc === "batch") {
+      return (...args) => ({ args, ...passthrough });
+    }
+    const thisRef = this;
+    const mainFunc = async function(...args) {
+      await thisRef.checkInitialProvider();
+      const mod = await import(
+        /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
+        `./functions/${path}`
+      );
+      if (subFunc !== "combine") {
+        const writeable = subFunc === "write" || subFunc === "populateTransaction";
+        const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
+        let dependenciesToForward2 = thisRef.forwardDependenciesFromArray(dependencies);
+        if (writeable) {
+          const options = args[1] || {};
+          const signer = options.signer || thisRef.provider?.getSigner(options.addressOrIndex);
+          const populate = subFunc === "populateTransaction";
+          if (!signer) {
+            throw new Error("No signer specified");
+          }
+          delete options.addressOrIndex;
+          delete options.signer;
+          dependenciesToForward2 = { ...dependenciesToForward2, signer };
+          return func(dependenciesToForward2, args[0], options).then(
+            (0, import_writeTx.default)(signer, populate)
+          );
         }
-        await this.gqlInstance.setUrl(this.graphURI);
-        this.contracts = new contracts_1.default(this.provider, this.getContractAddress(String(network)));
-        return;
+        return func(dependenciesToForward2, ...args);
+      }
+      const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+      return (0, import_singleCall.default)(
+        thisRef.provider,
+        dependenciesToForward,
+        mod[exportName],
+        ...args
+      );
     };
-    /**
-     * Creates a new ENS instance with a different provider, ideally should be used individually with any given function
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to use
-     * @returns {ENS} - A new ENS instance with the given provider
-     */
-    withProvider = (provider) => {
-        const newENS = new ENS(this.options);
-        newENS.initialProvider = provider;
-        return newENS;
-    };
-    batch = this.generateRawFunction('initialGetters', ['multicallWrapper'], 'batch');
-    getProfile = this.generateFunction('initialGetters', [
-        'contracts',
-        'gqlInstance',
-        'getName',
-        'resolverMulticallWrapper',
-        'multicallWrapper',
-        '_getAddr',
-        '_getContentHash',
-        '_getText',
-    ], 'getProfile');
-    getRecords = this.generateFunction('initialGetters', ['getProfile'], 'getRecords');
-    getName = this.generateRawFunction('initialGetters', ['contracts'], 'getName');
-    getResolver = this.generateRawFunction('getResolver', ['contracts']);
-    getFuses = this.generateRawFunction('getFuses', [
-        'contracts',
-    ]);
-    getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
-    getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
-    getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
-    getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
-    _getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
-    getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
-    _getAddr = this.generateRawFunction('initialGetters', ['contracts'], '_getAddr');
-    getText = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getText');
-    _getText = this.generateRawFunction('initialGetters', ['contracts'], '_getText');
-    getOwner = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getOwner');
-    getExpiry = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getExpiry');
-    getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
-    getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
-    getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
-    universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
-    resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
-    multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-    setName = this.generateFunction('setName', [
-        'contracts',
-        'provider',
-    ]);
-    setRecords = this.generateFunction('setRecords', [
-        'contracts',
-        'provider',
-        'getResolver',
-    ]);
-    setResolver = this.generateFunction('setResolver', ['contracts', 'provider']);
-    transferName = this.generateFunction('transferName', ['contracts', 'provider']);
-    wrapName = this.generateFunction('wrapName', [
-        'contracts',
-        'provider',
-    ]);
-    unwrapName = this.generateFunction('unwrapName', [
-        'contracts',
-        'provider',
-    ]);
-    burnFuses = this.generateFunction('burnFuses', [
-        'contracts',
-        'provider',
-    ]);
-    createSubname = this.generateFunction('createSubname', ['contracts', 'provider']);
-    deleteSubname = this.generateFunction('deleteSubname', ['contracts', 'provider', 'transferSubname']);
-    transferSubname = this.generateFunction('transferSubname', ['contracts', 'provider']);
-    getDNSOwner = this.generateFunction('getDNSOwner', []);
+    if (subFunc === "combine") {
+      mainFunc.raw = this.importGenerator(
+        path,
+        dependencies,
+        exportName,
+        "raw"
+      );
+      mainFunc.decode = this.importGenerator(
+        path,
+        dependencies,
+        exportName,
+        "decode"
+      );
+      mainFunc.batch = this.importGenerator(
+        path,
+        dependencies,
+        exportName,
+        "batch",
+        { raw: mainFunc.raw, decode: mainFunc.decode }
+      );
+    } else if (subFunc === "write") {
+      mainFunc.populateTransaction = this.importGenerator(
+        path,
+        dependencies,
+        exportName,
+        "populateTransaction"
+      );
+    }
+    return mainFunc;
+  };
+  generateFunction = (path, dependencies, exportName = "default") => this.importGenerator(path, dependencies, exportName);
+  generateWriteFunction = (path, dependencies, exportName = "default") => this.importGenerator(
+    path,
+    dependencies,
+    exportName,
+    "write"
+  );
+  generateRawFunction = (path, dependencies, exportName = "default") => this.importGenerator(
+    path,
+    dependencies,
+    exportName,
+    "combine"
+  );
+  setProvider = async (provider) => {
+    this.provider = provider;
+    const network = (await this.provider.getNetwork()).chainId;
+    if (this.options && this.options.graphURI) {
+      this.graphURI = this.options.graphURI;
+    } else {
+      this.graphURI = graphURIEndpoints[network];
+    }
+    await this.gqlInstance.setUrl(this.graphURI);
+    this.contracts = new import_contracts.default(
+      this.provider,
+      this.getContractAddress(String(network))
+    );
+  };
+  withProvider = (provider) => {
+    const newENS = new ENS(this.options);
+    newENS.initialProvider = provider;
+    return newENS;
+  };
+  batch = this.generateRawFunction(
+    "initialGetters",
+    ["multicallWrapper"],
+    "batch"
+  );
+  getProfile = this.generateFunction(
+    "initialGetters",
+    [
+      "contracts",
+      "gqlInstance",
+      "getName",
+      "resolverMulticallWrapper",
+      "multicallWrapper",
+      "_getAddr",
+      "_getContentHash",
+      "_getText"
+    ],
+    "getProfile"
+  );
+  getRecords = this.generateFunction(
+    "initialGetters",
+    ["getProfile"],
+    "getRecords"
+  );
+  getName = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "getName"
+  );
+  getResolver = this.generateRawFunction(
+    "getResolver",
+    ["contracts"]
+  );
+  getWrapperData = this.generateRawFunction(
+    "getWrapperData",
+    ["contracts"]
+  );
+  getHistory = this.generateFunction(
+    "getHistory",
+    ["gqlInstance"],
+    "getHistory"
+  );
+  getContentHash = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "universalWrapper"],
+    "getContentHash"
+  );
+  _getContentHash = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "_getContentHash"
+  );
+  getAddr = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "universalWrapper"],
+    "getAddr"
+  );
+  _getAddr = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "_getAddr"
+  );
+  getText = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "universalWrapper"],
+    "getText"
+  );
+  _getText = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "_getText"
+  );
+  getOwner = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "multicallWrapper"],
+    "getOwner"
+  );
+  getExpiry = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "multicallWrapper"],
+    "getExpiry"
+  );
+  getSubnames = this.generateFunction(
+    "initialGetters",
+    ["gqlInstance"],
+    "getSubnames"
+  );
+  getNames = this.generateFunction(
+    "initialGetters",
+    ["gqlInstance"],
+    "getNames"
+  );
+  getPrice = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "multicallWrapper"],
+    "getPrice"
+  );
+  getDNSOwner = this.generateFunction(
+    "getDNSOwner",
+    []
+  );
+  universalWrapper = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "universalWrapper"
+  );
+  resolverMulticallWrapper = this.generateRawFunction("initialGetters", ["contracts"], "resolverMulticallWrapper");
+  multicallWrapper = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "multicallWrapper"
+  );
+  setName = this.generateWriteFunction("setName", [
+    "contracts"
+  ]);
+  setRecords = this.generateWriteFunction(
+    "setRecords",
+    ["contracts", "provider", "getResolver"]
+  );
+  setRecord = this.generateWriteFunction("setRecord", [
+    "contracts",
+    "provider",
+    "getResolver"
+  ]);
+  setResolver = this.generateWriteFunction(
+    "setResolver",
+    ["contracts"]
+  );
+  transferName = this.generateWriteFunction(
+    "transferName",
+    ["contracts"]
+  );
+  transferController = this.generateWriteFunction("transferController", ["contracts"]);
+  wrapName = this.generateWriteFunction("wrapName", [
+    "contracts",
+    "getExpiry"
+  ]);
+  unwrapName = this.generateWriteFunction(
+    "unwrapName",
+    ["contracts"]
+  );
+  burnFuses = this.generateWriteFunction("burnFuses", [
+    "contracts"
+  ]);
+  importDNSSECName = this.generateWriteFunction(
+    "importDNSSECName",
+    ["contracts", "provider", "signer"]
+  );
+  createSubname = this.generateWriteFunction(
+    "createSubname",
+    ["contracts", "getExpiry"]
+  );
+  deleteSubname = this.generateWriteFunction(
+    "deleteSubname",
+    ["contracts"]
+  );
+  transferSubname = this.generateWriteFunction(
+    "transferSubname",
+    ["contracts", "getExpiry"]
+  );
+  commitName = this.generateWriteFunction(
+    "commitName",
+    ["contracts"]
+  );
+  registerName = this.generateWriteFunction(
+    "registerName",
+    ["contracts"]
+  );
+  renewNames = this.generateWriteFunction(
+    "renewNames",
+    ["contracts"]
+  );
+  renewNameWithData = this.generateWriteFunction("renewNames", ["contracts"], "renewNameWithData");
 }
-exports.ENS = ENS;