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

package/dist/esm/index.mjs

@@ -0,0 +1,309 @@
+// 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]])
+  );
+  getModule = async (path, exportName) => {
+    let mod = await import(
+      /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
+      `./functions/${path}`
+    );
+    if (mod.default?.[exportName]) {
+      mod = mod.default;
+    }
+    return mod;
+  };
+  getFunction = (subFunc, writeable, exportName, mod, _path) => subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
+  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 thisRef.getModule(path, exportName);
+      if (subFunc !== "combine") {
+        const writeable = subFunc === "write" || subFunc === "populateTransaction";
+        const func = thisRef.getFunction(
+          subFunc,
+          writeable,
+          exportName,
+          mod,
+          path
+        );
+        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,
+        thisRef.getFunction(void 0, void 0, exportName, mod, path),
+        ...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 = this.staticNetwork ? this.provider._network.chainId : (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"
+  );
+  getABI = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "universalWrapper"],
+    "getABI"
+  );
+  _getABI = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "_getABI"
+  );
+  getOwner = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "multicallWrapper", "gqlInstance"],
+    "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",
+    []
+  );
+  supportsTLD = this.generateFunction(
+    "initialGetters",
+    ["getOwner", "provider"],
+    "supportsTLD"
+  );
+  getAvailable = this.generateRawFunction(
+    "getAvailable",
+    ["contracts"]
+  );
+  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,
+  graphURIEndpoints
+};

package/dist/esm/static.mjs

@@ -0,0 +1,62 @@
+// src/static.ts
+import { gql, GraphQLClient } from "graphql-request";
+import { parse, print, visit } from "graphql/language";
+import traverse from "traverse";
+import ContractManager from "./contracts/index.mjs";
+import { ENS, graphURIEndpoints } from "./index.mjs";
+import { requestMiddleware, responseMiddleware } from "./GqlManager.mjs";
+var StaticENS = class extends ENS {
+  functions;
+  contractsObject;
+  gqlInstance = {
+    client: { request: () => Promise.resolve(null) },
+    setUrl: () => Promise.resolve(),
+    gql: (query) => query.join()
+  };
+  constructor(provider, { functions, contracts, ...options }) {
+    super(options);
+    this.functions = functions;
+    this.contractsObject = contracts;
+    this.setStaticProvider(provider);
+  }
+  setStaticProvider = (provider) => {
+    this.provider = provider;
+    const network = provider.network.chainId;
+    if (this.options && this.options.graphURI) {
+      this.graphURI = this.options.graphURI;
+    } else {
+      this.graphURI = graphURIEndpoints[network];
+    }
+    if (this.graphURI) {
+      const client = new GraphQLClient(this.graphURI, {
+        requestMiddleware: requestMiddleware(visit, parse, print),
+        responseMiddleware: responseMiddleware(traverse)
+      });
+      this.gqlInstance = {
+        client,
+        setUrl: () => Promise.resolve(),
+        gql
+      };
+    }
+    this.contracts = new ContractManager(
+      provider,
+      this.getContractAddress(String(network)),
+      (name) => Promise.resolve(this.contractsObject[name])
+    );
+  };
+  setProvider = async (provider) => {
+    this.setStaticProvider(provider);
+  };
+  getModule = async () => this.functions;
+  getFunction = (subFunc, _writeable, exportName, mod, path) => {
+    const base = mod[exportName === "default" ? path : exportName];
+    if (subFunc === "raw" || subFunc === "decode") {
+      return base[subFunc];
+    }
+    return base;
+  };
+};
+var static_default = StaticENS;
+export {
+  static_default as default
+};

package/dist/esm/utils/ccip.mjs

@@ -0,0 +1,114 @@
+// src/utils/ccip.ts
+import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
+import {
+  arrayify,
+  hexConcat,
+  hexDataSlice
+} from "@ethersproject/bytes";
+import { toUtf8String } from "@ethersproject/strings/lib.esm/utf8.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 { isHexString } from "@ethersproject/bytes";
+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|ar):\/\/(.*)/) || 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 = "ar";
+      } 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 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" || contentType === "ar") {
+        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
+};