@ensdomains/ensjs 3.0.0-alpha.16 → 3.0.0-alpha.19

package/dist/esm/index.mjs

@@ -0,0 +1,303 @@
+// src/index.ts
+import { getContractAddress as _getContractAddress } from "./contracts/getContractAddress.mjs";
+import ContractManager from "./contracts/index.mjs";
+import GqlManager from "./GqlManager.mjs";
+import singleCall from "./utils/singleCall.mjs";
+import writeTx from "./utils/writeTx.mjs";
+var 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"
+};
+var ENS = class {
+  options;
+  provider;
+  graphURI;
+  initialProvider;
+  contracts;
+  getContractAddress = _getContractAddress;
+  gqlInstance = new GqlManager();
+  constructor(options) {
+    this.options = options;
+    this.getContractAddress = options?.getContractAddress || _getContractAddress;
+  }
+  checkInitialProvider = async () => {
+    if (!this.initialProvider) {
+      return;
+    }
+    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(
+            writeTx(signer, populate)
+          );
+        }
+        return func(dependenciesToForward2, ...args);
+      }
+      const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+      return singleCall(
+        thisRef.provider,
+        dependenciesToForward,
+        mod[exportName],
+        ...args
+      );
+    };
+    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 ContractManager(
+      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"]
+  );
+  getFuses = this.generateRawFunction("getFuses", [
+    "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"]
+  );
+  wrapName = this.generateWriteFunction("wrapName", [
+    "contracts",
+    "getExpiry"
+  ]);
+  unwrapName = this.generateWriteFunction(
+    "unwrapName",
+    ["contracts"]
+  );
+  burnFuses = this.generateWriteFunction("burnFuses", [
+    "contracts"
+  ]);
+  createSubname = this.generateWriteFunction(
+    "createSubname",
+    ["contracts", "getExpiry"]
+  );
+  deleteSubname = this.generateWriteFunction(
+    "deleteSubname",
+    ["transferSubname"]
+  );
+  transferSubname = this.generateWriteFunction(
+    "transferSubname",
+    ["contracts", "getExpiry"]
+  );
+  commitName = this.generateWriteFunction(
+    "commitName",
+    ["contracts"]
+  );
+  registerName = this.generateWriteFunction(
+    "registerName",
+    ["contracts"]
+  );
+  renewName = this.generateWriteFunction("renewName", [
+    "contracts"
+  ]);
+};
+export {
+  ENS
+};

package/dist/esm/utils/contentHash.mjs

@@ -0,0 +1,142 @@
+// src/utils/contentHash.ts
+import contentHash from "@ensdomains/content-hash";
+import { utils } from "ethers";
+var supportedCodecs = [
+  "ipns-ns",
+  "ipfs-ns",
+  "swarm-ns",
+  "onion",
+  "onion3",
+  "skynet-ns",
+  "arweave-ns"
+];
+function matchProtocol(text) {
+  return text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave):\/\/(.*)/) || text.match(/\/(ipfs)\/(.*)/) || text.match(/\/(ipns)\/(.*)/);
+}
+function decodeContenthash(encoded) {
+  let decoded;
+  let protocolType;
+  let error;
+  if (!encoded || encoded === "0x") {
+    return {};
+  }
+  if (encoded.error) {
+    return { protocolType: null, decoded: encoded.error };
+  }
+  if (encoded === false) {
+    return { protocolType: null, decoded: "invalid value" };
+  }
+  if (encoded) {
+    try {
+      decoded = contentHash.decode(encoded);
+      const codec = contentHash.getCodec(encoded);
+      if (codec === "ipfs-ns") {
+        protocolType = "ipfs";
+      } else if (codec === "ipns-ns") {
+        protocolType = "ipns";
+      } else if (codec === "swarm-ns") {
+        protocolType = "bzz";
+      } else if (codec === "onion") {
+        protocolType = "onion";
+      } else if (codec === "onion3") {
+        protocolType = "onion3";
+      } else if (codec === "skynet-ns") {
+        protocolType = "sia";
+      } else if (codec === "arweave-ns") {
+        protocolType = "arweave";
+      } else {
+        decoded = encoded;
+      }
+    } catch (e) {
+      error = e.message;
+    }
+  }
+  return { protocolType, decoded, error };
+}
+function validateContent(encoded) {
+  return contentHash.isHashOfType(encoded, contentHash.Types.ipfs) || contentHash.isHashOfType(encoded, contentHash.Types.swarm);
+}
+function isValidContenthash(encoded) {
+  try {
+    const codec = contentHash.getCodec(encoded);
+    return utils.isHexString(encoded) && supportedCodecs.includes(codec);
+  } catch (e) {
+    console.log(e);
+  }
+}
+function getProtocolType(encoded) {
+  let protocolType;
+  let decoded;
+  try {
+    const matched = matchProtocol(encoded);
+    if (matched) {
+      ;
+      [, protocolType, decoded] = matched;
+    }
+    return {
+      protocolType,
+      decoded
+    };
+  } catch (e) {
+    console.log(e);
+  }
+}
+function encodeContenthash(text) {
+  let content = text;
+  let contentType;
+  let encoded = false;
+  let error;
+  if (text) {
+    const matched = matchProtocol(text);
+    if (matched) {
+      ;
+      [, contentType, content] = matched;
+    }
+    try {
+      if (contentType === "ipfs") {
+        if (content.length >= 4) {
+          encoded = `0x${contentHash.encode("ipfs-ns", content)}`;
+        }
+      } else if (contentType === "ipns") {
+        encoded = `0x${contentHash.encode("ipns-ns", content)}`;
+      } else if (contentType === "bzz") {
+        if (content.length >= 4) {
+          encoded = `0x${contentHash.fromSwarm(content)}`;
+        }
+      } else if (contentType === "onion") {
+        if (content.length === 16) {
+          encoded = `0x${contentHash.encode("onion", content)}`;
+        }
+      } else if (contentType === "onion3") {
+        if (content.length === 56) {
+          encoded = `0x${contentHash.encode("onion3", content)}`;
+        }
+      } else if (contentType === "sia") {
+        if (content.length === 46) {
+          encoded = `0x${contentHash.encode("skynet-ns", content)}`;
+        }
+      } else if (contentType === "arweave") {
+        if (content.length === 43) {
+          encoded = `0x${contentHash.encode("arweave-ns", content)}`;
+        }
+      } else {
+        console.warn("Unsupported protocol or invalid value", {
+          contentType,
+          text
+        });
+      }
+    } catch (err) {
+      const errorMessage = "Error encoding content hash";
+      console.warn(errorMessage, { text, encoded });
+      error = errorMessage;
+    }
+  }
+  return { encoded, error };
+}
+export {
+  decodeContenthash,
+  encodeContenthash,
+  getProtocolType,
+  isValidContenthash,
+  validateContent
+};

package/dist/esm/utils/createReverseNode.mjs

@@ -0,0 +1,5 @@
+// src/utils/createReverseNode.ts
+var createReverseNode_default = (address) => `${address.toLowerCase().substring(2)}.addr.reverse`;
+export {
+  createReverseNode_default as default
+};

package/dist/esm/utils/format.mjs

@@ -0,0 +1,9 @@
+// src/utils/format.ts
+var formatHashed = (name) => name.replace(/(\[)(.{64})(\])/g, "0x$2");
+var truncateFormat = (name) => name.replace(/(\[.{3})(.{58})(.{3}\])/g, "$1...$3");
+var bracketFormat = (name) => name.replace(/(0x)(.{64})(?=\.)/g, "[$2]");
+export {
+  bracketFormat,
+  formatHashed,
+  truncateFormat
+};

package/dist/esm/utils/fuses.mjs

@@ -0,0 +1,56 @@
+// src/utils/fuses.ts
+var CANNOT_UNWRAP = 1;
+var CANNOT_BURN_FUSES = 2;
+var CANNOT_TRANSFER = 4;
+var CANNOT_SET_RESOLVER = 8;
+var CANNOT_SET_TTL = 16;
+var CANNOT_CREATE_SUBDOMAIN = 32;
+var PARENT_CANNOT_CONTROL = 64;
+var CAN_DO_EVERYTHING = 0;
+var fuseEnum = {
+  CANNOT_UNWRAP,
+  CANNOT_BURN_FUSES,
+  CANNOT_TRANSFER,
+  CANNOT_SET_RESOLVER,
+  CANNOT_SET_TTL,
+  CANNOT_CREATE_SUBDOMAIN,
+  PARENT_CANNOT_CONTROL
+};
+var unnamedFuses = [
+  128,
+  256,
+  512,
+  1024,
+  2048,
+  4096,
+  8192,
+  16384,
+  32768,
+  65536,
+  131072,
+  262144,
+  524288,
+  1048576,
+  2097152,
+  4194304,
+  8388608,
+  16777216,
+  33554432,
+  67108864,
+  134217728,
+  268435456,
+  536870912,
+  1073741824,
+  2147483648,
+  4294967296
+];
+var fullFuseEnum = {
+  ...fuseEnum,
+  CAN_DO_EVERYTHING
+};
+var fuses_default = fullFuseEnum;
+export {
+  fuses_default as default,
+  fuseEnum,
+  unnamedFuses
+};

package/dist/esm/utils/generateFuseInput.mjs

@@ -0,0 +1,15 @@
+// src/utils/generateFuseInput.ts
+import { ethers } from "ethers";
+import fuses from "./fuses.mjs";
+var generateFuseInput_default = (fuseOptions) => {
+  const fuseKeys = Object.keys(fuseOptions).filter((opt) => fuseOptions[opt] === true).map(
+    (opt) => opt.split(/(?=[A-Z])/).join("_").toUpperCase()
+  );
+  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
+    return prev.or(fuses[curr]);
+  }, ethers.BigNumber.from(0));
+  return bigNumberFuses.toHexString();
+};
+export {
+  generateFuseInput_default as default
+};

package/dist/esm/utils/hexEncodedName.mjs

@@ -0,0 +1,6 @@
+// src/utils/hexEncodedName.ts
+import packet from "dns-packet";
+var hexEncodeName = (name) => `0x${packet.name.encode(name).toString("hex")}`;
+export {
+  hexEncodeName
+};

package/dist/esm/utils/labels.mjs

@@ -0,0 +1,109 @@
+// src/utils/labels.ts
+import { solidityKeccak256 } from "ethers/lib/utils.js";
+import { truncateFormat } from "./format.mjs";
+var hasLocalStorage = typeof localStorage !== "undefined";
+var labelhash = (input) => solidityKeccak256(["string"], [input]);
+var keccakFromString = (input) => labelhash(input);
+function decodeLabelhash(hash) {
+  if (!(hash.startsWith("[") && hash.endsWith("]"))) {
+    throw Error(
+      "Expected encoded labelhash to start and end with square brackets"
+    );
+  }
+  if (hash.length !== 66) {
+    throw Error("Expected encoded labelhash to have a length of 66");
+  }
+  return `0x${hash.slice(1, -1)}`;
+}
+function encodeLabelhash(hash) {
+  if (!hash.startsWith("0x")) {
+    throw new Error("Expected label hash to start with 0x");
+  }
+  if (hash.length !== 66) {
+    throw new Error("Expected label hash to have a length of 66");
+  }
+  return `[${hash.slice(2)}]`;
+}
+function isEncodedLabelhash(hash) {
+  return hash.startsWith("[") && hash.endsWith("]") && hash.length === 66;
+}
+function getLabels() {
+  return hasLocalStorage ? JSON.parse(localStorage.getItem("ensjs:labels")) || {} : {};
+}
+function _saveLabel(hash, label) {
+  if (!hasLocalStorage)
+    return hash;
+  const labels = getLabels();
+  localStorage.setItem(
+    "ensjs:labels",
+    JSON.stringify({
+      ...labels,
+      [hash]: label
+    })
+  );
+  return hash;
+}
+function saveLabel(label) {
+  const hash = `${labelhash(label.toLowerCase())}`;
+  return _saveLabel(hash, label);
+}
+function saveName(name) {
+  const nameArray = name.split(".");
+  nameArray.forEach((label) => {
+    saveLabel(label);
+  });
+}
+function checkLabel(hash) {
+  const labels = getLabels();
+  if (isEncodedLabelhash(hash)) {
+    return labels[decodeLabelhash(hash)];
+  }
+  if (hash.startsWith("0x")) {
+    return labels[`${hash.slice(2)}`];
+  }
+}
+function encodeLabel(label) {
+  try {
+    return encodeLabelhash(label);
+  } catch {
+    return label;
+  }
+}
+function parseName(name) {
+  const nameArray = name.split(".");
+  return nameArray.map((label) => encodeLabel(label)).join(".");
+}
+function checkIsDecrypted(string) {
+  return !string?.includes("[");
+}
+function decryptName(name) {
+  return name.split(".").map((label) => checkLabel(label) || label).join(".");
+}
+var truncateUndecryptedName = (name) => truncateFormat(name);
+function checkLocalStorageSize() {
+  if (!hasLocalStorage)
+    return "Empty (0 KB)";
+  let allStrings = "";
+  for (const key in window.localStorage) {
+    if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
+      allStrings += window.localStorage[key];
+    }
+  }
+  return allStrings ? `${3 + allStrings.length * 16 / (8 * 1024)} KB` : "Empty (0 KB)";
+}
+export {
+  checkIsDecrypted,
+  checkLabel,
+  checkLocalStorageSize,
+  decodeLabelhash,
+  decryptName,
+  encodeLabel,
+  encodeLabelhash,
+  isEncodedLabelhash,
+  keccakFromString,
+  labelhash,
+  parseName,
+  saveLabel,
+  saveName,
+  truncateUndecryptedName
+};

package/dist/esm/utils/makeHashIndexes.mjs

@@ -0,0 +1,10 @@
+// src/utils/makeHashIndexes.ts
+import { namehash } from "./normalise.mjs";
+var makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
+var makeNamehashIndexes = (data, name) => Array.from(data.matchAll(namehash(name).substring(2))).map(
+  (x) => x.index / 2 - 1
+);
+export {
+  makeNamehashIndexes,
+  makeOtherIndexes
+};

package/dist/esm/utils/normalise.mjs

@@ -0,0 +1,30 @@
+// src/utils/normalise.ts
+import { concat, hexlify, keccak256, toUtf8Bytes } from "ethers/lib/utils.js";
+import uts46 from "idna-uts46-hx/uts46bundle.js";
+import { decodeLabelhash, isEncodedLabelhash } from "./labels.mjs";
+var zeros = new Uint8Array(32);
+zeros.fill(0);
+var normalise = (name) => name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name;
+var namehash = (name) => {
+  let result = zeros;
+  if (name) {
+    const labels = name.split(".");
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+      let labelSha;
+      if (isEncodedLabelhash(labels[i])) {
+        labelSha = decodeLabelhash(labels[i]);
+      } else {
+        const normalised = normalise(labels[i]);
+        labelSha = keccak256(toUtf8Bytes(normalised));
+      }
+      result = keccak256(concat([result, labelSha]));
+    }
+  } else {
+    result = hexlify(zeros);
+  }
+  return result;
+};
+export {
+  namehash,
+  normalise
+};