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

package/dist/esm/index.mjs

@@ -0,0 +1,311 @@
+// 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"]
+  );
+  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");
+};
+export {
+  ENS
+};

package/dist/esm/utils/ccip.mjs

@@ -0,0 +1,114 @@
+// src/utils/ccip.ts
+import { BigNumber } from "ethers";
+import {
+  arrayify,
+  hexConcat,
+  hexDataSlice,
+  toUtf8String
+} from "ethers/lib/utils.js";
+function bytesPad(value) {
+  if (value.length % 32 === 0) {
+    return value;
+  }
+  const result = new Uint8Array(Math.ceil(value.length / 32) * 32);
+  result.set(value);
+  return result;
+}
+function numPad(value) {
+  const result = arrayify(value);
+  if (result.length > 32) {
+    throw new Error("internal; should not happen");
+  }
+  const padded = new Uint8Array(32);
+  padded.set(result, 32 - result.length);
+  return padded;
+}
+function encodeBytes(datas) {
+  const result = [];
+  let byteCount = 0;
+  for (let i = 0; i < datas.length; i += 1) {
+    result.push(new Uint8Array(0));
+    byteCount += 32;
+  }
+  for (let i = 0; i < datas.length; i += 1) {
+    const data = arrayify(datas[i]);
+    result[i] = numPad(byteCount);
+    result.push(numPad(data.length));
+    result.push(bytesPad(data));
+    byteCount += 32 + Math.ceil(data.length / 32) * 32;
+  }
+  return hexConcat(result);
+}
+function _parseBytes(result, start) {
+  if (result === "0x") {
+    return null;
+  }
+  const offset = BigNumber.from(
+    hexDataSlice(result, start, start + 32)
+  ).toNumber();
+  const length = BigNumber.from(
+    hexDataSlice(result, offset, offset + 32)
+  ).toNumber();
+  return hexDataSlice(result, offset + 32, offset + 32 + length);
+}
+function _parseString(result, start) {
+  try {
+    const bytes = _parseBytes(result, start);
+    if (bytes == null)
+      return null;
+    return toUtf8String(bytes);
+  } catch (error) {
+  }
+  return null;
+}
+var ccipLookup = async (provider, transaction, result) => {
+  const txSender = transaction.to;
+  try {
+    const data = hexDataSlice(result, 4);
+    const sender = hexDataSlice(data, 0, 32);
+    if (!BigNumber.from(sender).eq(txSender)) {
+      throw new Error("CCIP Read sender did not match");
+    }
+    const urls = [];
+    const urlsOffset = BigNumber.from(hexDataSlice(data, 32, 64)).toNumber();
+    const urlsLength = BigNumber.from(
+      hexDataSlice(data, urlsOffset, urlsOffset + 32)
+    ).toNumber();
+    const urlsData = hexDataSlice(data, urlsOffset + 32);
+    for (let u = 0; u < urlsLength; u += 1) {
+      const url = _parseString(urlsData, u * 32);
+      if (url == null) {
+        throw new Error("CCIP Read contained corrupt URL string");
+      }
+      urls.push(url);
+    }
+    const calldata = _parseBytes(data, 64);
+    if (!BigNumber.from(hexDataSlice(data, 100, 128)).isZero()) {
+      throw new Error("CCIP Read callback selected included junk");
+    }
+    const callbackSelector = hexDataSlice(data, 96, 100);
+    const extraData = _parseBytes(data, 128);
+    const ccipResult = await provider.ccipReadFetch(
+      transaction,
+      calldata,
+      urls
+    );
+    if (ccipResult == null) {
+      throw new Error("CCIP Read disabled or provided no URLs");
+    }
+    const tx = {
+      to: sender,
+      data: hexConcat([
+        callbackSelector,
+        encodeBytes([ccipResult, extraData])
+      ])
+    };
+    return await provider._call(tx, "latest", 1);
+  } catch (error) {
+    console.error(error);
+  }
+};
+var ccip_default = ccipLookup;
+export {
+  ccip_default as default
+};

package/dist/esm/utils/consts.mjs

@@ -0,0 +1,5 @@
+// src/utils/consts.ts
+var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
+export {
+  EMPTY_ADDRESS
+};

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,115 @@
+// src/utils/fuses.ts
+import { BigNumber } from "ethers";
+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 validateFuses = (fuses) => {
+  const isNumber = "fuseNumberToBurn" in fuses;
+  const hasNamedArray = "namedFusesToBurn" in fuses;
+  const hasUnnamedArray = "unnamedFusesToBurn" in fuses;
+  let encodedFuses = 0;
+  if (isNumber) {
+    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${fuses.fuseNumberToBurn} was too ${fuses.fuseNumberToBurn < 1 ? "low" : "high"}.`
+      );
+    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`
+      );
+    }
+    encodedFuses = fuses.fuseNumberToBurn;
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error("Please provide fuses to burn");
+    }
+    if (hasNamedArray) {
+      for (const fuse of fuses.namedFusesToBurn) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`);
+        }
+        encodedFuses |= fuseEnum[fuse];
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of fuses.unnamedFusesToBurn) {
+        if (!unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`
+          );
+        }
+        encodedFuses |= fuse;
+      }
+    }
+  }
+  return encodedFuses;
+};
+var decodeFuses = (fuses) => {
+  const bnFuses = BigNumber.from(fuses);
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse]).gt(0)
+    ])
+  );
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true;
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false;
+  }
+  return fuseObj;
+};
+var fuses_default = fullFuseEnum;
+export {
+  decodeFuses,
+  fuses_default as default,
+  fuseEnum,
+  unnamedFuses,
+  validateFuses
+};