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

package/dist/esm/utils/fuses.mjs

@@ -0,0 +1,115 @@
+// src/utils/fuses.ts
+import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
+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
+};

package/dist/esm/utils/generateFuseInput.mjs

@@ -0,0 +1,15 @@
+// src/utils/generateFuseInput.ts
+import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
+import fuses from "./fuses.mjs";
+var generateFuseInput_default = (fuseOptions) => {
+  const fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt] === true
+  );
+  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
+    return prev.or(fuses[curr]);
+  }, 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 { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
+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,32 @@
+// src/utils/normalise.ts
+import { concat, hexlify } from "@ethersproject/bytes";
+import { keccak256 } from "@ethersproject/keccak256";
+import { toUtf8Bytes } from "@ethersproject/strings/lib.esm/utf8.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
+};

package/dist/esm/utils/recordHelpers.mjs

@@ -0,0 +1,123 @@
+// src/utils/recordHelpers.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { isBytesLike, toUtf8Bytes } from "ethers/lib/utils";
+import { encodeContenthash } from "./contentHash.mjs";
+var generateSetAddr = (namehash, coinType, address, resolver) => {
+  let coinTypeInstance;
+  if (!Number.isNaN(parseInt(coinType))) {
+    coinTypeInstance = formatsByCoinType[parseInt(coinType)];
+  } else {
+    coinTypeInstance = formatsByName[coinType.toUpperCase()];
+  }
+  const inputCoinType = coinTypeInstance.coinType;
+  const encodedAddress = coinTypeInstance.decoder(address);
+  return resolver?.interface.encodeFunctionData(
+    "setAddr(bytes32,uint256,bytes)",
+    [namehash, inputCoinType, encodedAddress]
+  );
+};
+var generateABIInput = async (encodeAs, data) => {
+  let contentType;
+  let encodedData;
+  switch (encodeAs) {
+    case "json":
+      contentType = 1;
+      encodedData = JSON.stringify(data);
+      break;
+    case "zlib": {
+      contentType = 2;
+      const { deflate } = await import("pako/dist/pako_deflate.min.js");
+      encodedData = deflate(JSON.stringify(data));
+      break;
+    }
+    case "cbor": {
+      contentType = 4;
+      const { encode } = await import("cbor");
+      encodedData = encode(data);
+      break;
+    }
+    default: {
+      contentType = 8;
+      encodedData = data;
+      break;
+    }
+  }
+  return { contentType, data: encodedData };
+};
+function generateSingleRecordCall(namehash, resolver, type) {
+  if (type === "contentHash") {
+    return (_r) => {
+      const record = _r;
+      let _contentHash = "";
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record);
+        if (encoded.error)
+          throw new Error(encoded.error);
+        _contentHash = encoded.encoded;
+      }
+      return resolver.interface.encodeFunctionData("setContenthash", [
+        namehash,
+        _contentHash
+      ]);
+    };
+  }
+  if (type === "abi") {
+    return (_r) => {
+      const record = _r;
+      const { contentType = 1, data } = record;
+      let encodedData = data;
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === "object") {
+          encodedData = JSON.stringify(encodedData);
+        }
+        encodedData = toUtf8Bytes(encodedData);
+      }
+      return resolver.interface.encodeFunctionData("setABI", [
+        namehash,
+        contentType,
+        encodedData
+      ]);
+    };
+  }
+  return (_r) => {
+    const record = _r;
+    if (type === "text") {
+      return resolver.interface.encodeFunctionData("setText", [
+        namehash,
+        record.key,
+        record.value
+      ]);
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver);
+  };
+}
+var generateRecordCallArray = (namehash, records, resolver) => {
+  const calls = [];
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData("clearRecords", [namehash])
+    );
+  }
+  if (records.contentHash) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      "contentHash"
+    )(records.contentHash);
+    if (data)
+      calls.push(data);
+  }
+  if (records.texts && records.texts.length > 0) {
+    records.texts.map(generateSingleRecordCall(namehash, resolver, "text")).forEach((call) => calls.push(call));
+  }
+  if (records.coinTypes && records.coinTypes.length > 0) {
+    records.coinTypes.map(generateSingleRecordCall(namehash, resolver, "addr")).forEach((call) => calls.push(call));
+  }
+  return calls;
+};
+export {
+  generateABIInput,
+  generateRecordCallArray,
+  generateSetAddr,
+  generateSingleRecordCall
+};

package/dist/esm/utils/registerHelpers.mjs

@@ -0,0 +1,98 @@
+// src/utils/registerHelpers.ts
+import { defaultAbiCoder } from "@ethersproject/abi/lib.esm/abi-coder.js";
+import { keccak256 } from "@ethersproject/keccak256";
+import generateFuseInput from "./generateFuseInput.mjs";
+import { labelhash } from "./labels.mjs";
+import { namehash } from "./normalise.mjs";
+import { generateRecordCallArray } from "./recordHelpers.mjs";
+var MAX_INT_64 = 2n ** 64n - 1n;
+var randomSecret = () => {
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+var makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  wrapperExpiry,
+  secret
+}) => {
+  const label = labelhash(name.split(".")[0]);
+  const hash = namehash(name);
+  const resolverAddress = resolver.address;
+  const fuseData = fuses ? generateFuseInput(fuses) : "0";
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: "ETH", value: owner }] };
+    } else if (!records.coinTypes?.find((c) => c.key === "ETH")) {
+      if (!records.coinTypes)
+        records.coinTypes = [];
+      records.coinTypes.push({ key: "ETH", value: owner });
+    }
+  }
+  const data = records ? generateRecordCallArray(hash, records, resolver) : [];
+  return [
+    label,
+    owner,
+    duration,
+    resolverAddress,
+    data,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || MAX_INT_64
+  ];
+};
+var 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;
+};
+var _makeCommitment = (params) => {
+  return keccak256(
+    defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "address",
+        "bytes[]",
+        "bytes32",
+        "bool",
+        "uint32",
+        "uint64"
+      ],
+      params
+    )
+  );
+};
+var makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8]
+  };
+};
+export {
+  MAX_INT_64,
+  _makeCommitment,
+  makeCommitment,
+  makeCommitmentData,
+  makeRegistrationData,
+  randomSecret
+};

package/dist/esm/utils/singleCall.mjs

@@ -0,0 +1,5 @@
+// src/utils/singleCall.ts
+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));
+export {
+  singleCall_default as default
+};

package/dist/esm/utils/validation.mjs

@@ -0,0 +1,67 @@
+// src/utils/validation.ts
+import { isAddress } from "@ethersproject/address";
+import { isEncodedLabelhash, saveName } from "./labels.mjs";
+import { normalise } from "./normalise.mjs";
+var 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;
+    }
+    return isEncodedLabelhash(label) ? label : normalise(label);
+  });
+  const normalizedName = normalizedArray.join(".");
+  saveName(normalizedName);
+  return normalizedName;
+};
+var validateTLD = (name) => {
+  const labels = name.split(".");
+  return validateName(labels[labels.length - 1]);
+};
+var parseInputType = (input) => {
+  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: "name",
+          info: "short"
+        };
+      }
+      return {
+        type: "name",
+        info: "supported"
+      };
+    }
+    return {
+      type: "name",
+      info: "unsupported"
+    };
+  }
+  if (isAddress(input)) {
+    return {
+      type: "address"
+    };
+  }
+  return {
+    type: "label"
+  };
+};
+export {
+  parseInputType,
+  validateName,
+  validateTLD
+};

package/dist/esm/utils/wrapper.mjs

@@ -0,0 +1,32 @@
+// src/utils/wrapper.ts
+import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
+import { toUtf8Bytes } from "@ethersproject/strings/lib.esm/utf8.js";
+var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
+var makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1e3);
+    }
+    if (expiry instanceof BigNumber) {
+      return expiry;
+    }
+    return BigNumber.from(expiry);
+  }
+  if (name.endsWith(".eth")) {
+    const expResponse = await getExpiry(name);
+    if (!expResponse?.expiry)
+      throw new Error("Couldn't get expiry for name, please provide one.");
+    return BigNumber.from(expResponse.expiry.getTime() / 1e3);
+  }
+  return MAX_EXPIRY;
+};
+var wrappedLabelLengthCheck = (label) => {
+  const bytes = toUtf8Bytes(label);
+  if (bytes.byteLength > 255)
+    throw new Error("Label can't be longer than 255 bytes");
+};
+export {
+  MAX_EXPIRY,
+  makeExpiry,
+  wrappedLabelLengthCheck
+};

package/dist/esm/utils/writeTx.mjs

@@ -0,0 +1,6 @@
+// src/utils/writeTx.ts
+var 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));
+export {
+  writeTx_default as default
+};

package/dist/types/GqlManager.d.ts

@@ -0,0 +1,13 @@
+import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
+import type { gql, GraphQLClient } from 'graphql-request';
+import type Traverse from 'traverse';
+export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
+export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
+export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
+export default class GqlManager {
+    gql: typeof gql | ((query: TemplateStringsArray) => string);
+    client: GraphQLClient | {
+        request: () => Promise<null>;
+    };
+    setUrl: (url: string | null) => Promise<void>;
+}

package/dist/types/contracts/baseRegistrar.d.ts

@@ -0,0 +1,3 @@
+import type { JsonRpcProvider } from '@ethersproject/providers';
+declare const _default: (provider: JsonRpcProvider, address: string) => import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation;
+export default _default;

package/dist/types/contracts/bulkRenewal.d.ts

@@ -0,0 +1,3 @@
+import type { JsonRpcProvider } from '@ethersproject/providers';
+declare const _default: (provider: JsonRpcProvider, address: string) => import("../generated/BulkRenewal").BulkRenewal;
+export default _default;

package/dist/types/contracts/dnsRegistrar.d.ts

@@ -0,0 +1,3 @@
+import type { JsonRpcProvider } from '@ethersproject/providers';
+declare const _default: (provider: JsonRpcProvider, address: string) => import("../generated/DNSRegistrar").DNSRegistrar;
+export default _default;

package/dist/types/contracts/ethRegistrarController.d.ts

@@ -0,0 +1,3 @@
+import type { JsonRpcProvider } from '@ethersproject/providers';
+declare const _default: (provider: JsonRpcProvider, address: string) => import("../generated/ETHRegistrarController").ETHRegistrarController;
+export default _default;