@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.51

package/dist/esm/utils/fuses.mjs

@@ -0,0 +1,283 @@
+// 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 = 65536;
+var IS_DOT_ETH = 131072;
+var CAN_EXTEND_EXPIRY = 262144;
+var CHILD_CONTROLLED_FUSES = 65535;
+var PARENT_CONTROLLED_FUSES = 4294901760;
+var USER_SETTABLE_FUSES = 4294836223;
+var CAN_DO_EVERYTHING = 0;
+var childFuseEnum = {
+  CANNOT_UNWRAP,
+  CANNOT_BURN_FUSES,
+  CANNOT_TRANSFER,
+  CANNOT_SET_RESOLVER,
+  CANNOT_SET_TTL,
+  CANNOT_CREATE_SUBDOMAIN
+};
+var parentFuseEnum = {
+  PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY
+};
+var fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH
+};
+var userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum
+};
+var fullFuseEnum = {
+  ...userSettableFuseEnum,
+  ...fullParentFuseEnum,
+  CAN_DO_EVERYTHING
+};
+var unnamedChildFuses = [
+  64,
+  128,
+  256,
+  512,
+  1024,
+  2048,
+  4096,
+  8192,
+  16384,
+  32768
+];
+var unnamedParentFuses = [
+  524288,
+  1048576,
+  2097152,
+  4194304,
+  8388608,
+  16777216,
+  33554432,
+  67108864,
+  134217728,
+  268435456,
+  536870912,
+  1073741824,
+  2147483648
+];
+var unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses
+];
+var childFuseKeys = Object.keys(
+  childFuseEnum
+);
+var parentFuseKeys = Object.keys(
+  parentFuseEnum
+);
+var fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum
+);
+var userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum
+);
+var checkNumber = (fuses) => {
+  if (fuses > 2 ** 32 || fuses < 1) {
+    throw new Error(
+      `Fuse number must be limited to uint32, ${fuses} was too ${fuses < 1 ? "low" : "high"}.`
+    );
+  } else if (fuses % 1 !== 0) {
+    throw new Error(`Fuse number must be an integer, ${fuses} was not.`);
+  } else if ((fuses & USER_SETTABLE_FUSES) !== fuses) {
+    throw new Error(
+      `Fuse number must be limited to user settable fuses, ${fuses} was not.`
+    );
+  }
+};
+var testFuses = (fuses) => {
+  if ("named" in fuses && fuses.named.length > 0) {
+    return true;
+  }
+  if ("unnamed" in fuses && fuses.unnamed.length > 0) {
+    return true;
+  }
+  if ("number" in fuses && fuses.number !== 0) {
+    return true;
+  }
+  return false;
+};
+var hasFuses = (fuses) => {
+  if (typeof fuses === "number") {
+    return fuses !== 0;
+  }
+  if (typeof fuses === "object") {
+    if ("child" in fuses && testFuses(fuses.child)) {
+      return true;
+    }
+    if ("parent" in fuses && testFuses(fuses.parent)) {
+      return true;
+    }
+    if (testFuses(fuses)) {
+      return true;
+    }
+  }
+  return false;
+};
+function encodeFuses(fuses, restrictTo) {
+  let encodedFuses = 0;
+  if (typeof fuses === "number") {
+    if (restrictTo) {
+      throw new Error("Cannot specify an exact fuse value when restricted.");
+    }
+    checkNumber(fuses);
+    encodedFuses = fuses;
+  } else {
+    let fusesRef = fuses;
+    let allowedNamed = [];
+    let allowedUnnamed = [];
+    let namedArray = [];
+    let unnamedArray = [];
+    if (restrictTo) {
+      if ("parent" in fuses || "child" in fuses) {
+        throw new Error("Can't specify fuse category when restricted.");
+      }
+      allowedNamed = restrictTo === "child" ? childFuseKeys : parentFuseKeys;
+      allowedUnnamed = restrictTo === "child" ? unnamedChildFuses : unnamedParentFuses;
+      fusesRef = { [restrictTo]: fuses };
+    } else {
+      allowedNamed = userSettableFuseKeys;
+      allowedUnnamed = unnamedUserSettableFuses;
+    }
+    if ("parent" in fusesRef) {
+      if ("named" in fusesRef.parent)
+        namedArray = fusesRef.parent.named;
+      if ("unnamed" in fusesRef.parent)
+        unnamedArray = fusesRef.parent.unnamed;
+      if ("number" in fusesRef.parent) {
+        if ("named" in fusesRef.parent || "unnamed" in fusesRef.parent) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.parent.number);
+        if ((fusesRef.parent.number & PARENT_CONTROLLED_FUSES) !== fusesRef.parent.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the parent's control."
+          );
+        }
+        encodedFuses |= fusesRef.parent.number;
+      }
+    }
+    if ("child" in fusesRef) {
+      if ("named" in fusesRef.child)
+        namedArray = [...namedArray, ...fusesRef.child.named];
+      if ("unnamed" in fusesRef.child)
+        unnamedArray = [...unnamedArray, ...fusesRef.child.unnamed];
+      if ("number" in fusesRef.child) {
+        if ("named" in fusesRef.child || "unnamed" in fusesRef.child) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.child.number);
+        if ((fusesRef.child.number & CHILD_CONTROLLED_FUSES) !== fusesRef.child.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the owner's control."
+          );
+        }
+        encodedFuses |= fusesRef.child.number;
+      }
+    }
+    if (!namedArray.length && !unnamedArray.length && !encodedFuses) {
+      throw new Error("Must specify at least one fuse.");
+    }
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse)) {
+          throw new Error(`${fuse} is not a valid named fuse.`);
+        }
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
+      }
+      encodedFuses |= userSettableFuseEnum[fuse];
+    }
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.`
+          );
+        }
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
+      }
+      encodedFuses |= fuse;
+    }
+  }
+  return encodedFuses;
+}
+var decodeNamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [
+      fuse,
+      (fuses & fullFuseEnum[fuse]) === fullFuseEnum[fuse]
+    ])
+  );
+  return fuseObj;
+};
+var decodeUnnamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) === fuse])
+  );
+  return fuseObj;
+};
+var decodeFuses = (fuses) => {
+  const parentNamedFuses = decodeNamedFuses(
+    fuses,
+    fullParentFuseKeys
+  );
+  const parentUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedParentFuses
+  );
+  const childNamedFuses = decodeNamedFuses(
+    fuses,
+    childFuseKeys
+  );
+  const childUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedChildFuses
+  );
+  return {
+    parent: {
+      ...parentNamedFuses,
+      unnamed: parentUnnamedFuses
+    },
+    child: {
+      ...childNamedFuses,
+      CAN_DO_EVERYTHING: (fuses & CHILD_CONTROLLED_FUSES) === 0,
+      unnamed: childUnnamedFuses
+    }
+  };
+};
+var checkPCCBurned = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
+var fuses_default = fullFuseEnum;
+export {
+  CHILD_CONTROLLED_FUSES,
+  PARENT_CONTROLLED_FUSES,
+  USER_SETTABLE_FUSES,
+  checkPCCBurned,
+  childFuseEnum,
+  childFuseKeys,
+  decodeFuses,
+  fuses_default as default,
+  encodeFuses,
+  fullFuseEnum,
+  fullParentFuseEnum,
+  fullParentFuseKeys,
+  hasFuses,
+  parentFuseEnum,
+  parentFuseKeys,
+  unnamedChildFuses,
+  unnamedParentFuses,
+  unnamedUserSettableFuses,
+  userSettableFuseEnum,
+  userSettableFuseKeys
+};

package/dist/esm/utils/hexEncodedName.mjs

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

package/dist/esm/utils/labels.mjs

@@ -0,0 +1,112 @@
+// 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(".");
+  for (const label of nameArray) {
+    if (!isEncodedLabelhash(label)) {
+      saveLabel(label);
+    }
+  }
+}
+function checkLabel(hash) {
+  const labels = getLabels();
+  if (isEncodedLabelhash(hash)) {
+    return labels[decodeLabelhash(hash)] || hash;
+  }
+  return hash;
+}
+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)).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)";
+}
+var encodedLabelRegex = /\[[a-fA-F0-9]{64}\]/g;
+var getEncryptedLabelAmount = (name) => name.match(encodedLabelRegex)?.length || 0;
+export {
+  checkIsDecrypted,
+  checkLabel,
+  checkLocalStorageSize,
+  decodeLabelhash,
+  decryptName,
+  encodeLabel,
+  encodeLabelhash,
+  getEncryptedLabelAmount,
+  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";
+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,133 @@
+// src/utils/recordHelpers.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { isBytesLike } from "@ethersproject/bytes";
+import { toUtf8Bytes } from "@ethersproject/strings";
+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.abi) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      "abi"
+    )(records.abi);
+    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,90 @@
+// src/utils/registerHelpers.ts
+import { defaultAbiCoder } from "@ethersproject/abi";
+import { keccak256 } from "@ethersproject/keccak256";
+import { encodeFuses, hasFuses } from "./fuses.mjs";
+import { labelhash } from "./labels.mjs";
+import { namehash } from "./normalise.mjs";
+import { generateRecordCallArray } from "./recordHelpers.mjs";
+var randomSecret = () => {
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+var makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  secret
+}) => {
+  const labelHash = labelhash(name.split(".")[0]);
+  const hash = namehash(name);
+  const resolverAddress = resolver.address;
+  const fuseData = hasFuses(fuses) ? encodeFuses(fuses, "child") : 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 [
+    labelHash,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    data,
+    !!reverseRecord,
+    fuseData
+  ];
+};
+var makeRegistrationData = (params) => {
+  const commitmentData = makeCommitmentData(params);
+  const label = params.name.split(".")[0];
+  commitmentData[0] = label;
+  return commitmentData;
+};
+var _makeCommitment = (params) => {
+  return keccak256(
+    defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "bytes32",
+        "address",
+        "bytes[]",
+        "bool",
+        "uint16"
+      ],
+      params
+    )
+  );
+};
+var makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment
+  };
+};
+export {
+  _makeCommitment,
+  makeCommitment,
+  makeCommitmentData,
+  makeRegistrationData,
+  randomSecret
+};

package/dist/esm/utils/registry.mjs

@@ -0,0 +1,13 @@
+// src/utils/registry.ts
+import { namehash } from "./normalise.mjs";
+var makeResolver = async ({ contracts }, name, resolver) => {
+  if (resolver)
+    return resolver;
+  const registry = await contracts.getRegistry();
+  const node = namehash(name);
+  const _resolver = await registry.resolver(node);
+  return _resolver;
+};
+export {
+  makeResolver
+};

package/dist/esm/utils/singleCall.mjs

@@ -0,0 +1,13 @@
+// src/utils/singleCall.ts
+var singleCall_default = async (provider, ensData, func, ...data) => {
+  const { passthrough, ...rawData } = await func.raw(ensData, ...data);
+  const result = await provider.call({ ...rawData, ccipReadEnabled: true }).catch(() => null);
+  if (!result)
+    return;
+  if (passthrough)
+    return func.decode(ensData, result, passthrough, ...data);
+  return func.decode(ensData, result, ...data);
+};
+export {
+  singleCall_default as default
+};