@ensdomains/ensjs 3.0.0-alpha.15 → 3.0.0-alpha.18

package/dist/esm/utils/fuses.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/fuses.ts"],
+  "sourcesContent": ["const CANNOT_UNWRAP = 1\nconst CANNOT_BURN_FUSES = 2\nconst CANNOT_TRANSFER = 4\nconst CANNOT_SET_RESOLVER = 8\nconst CANNOT_SET_TTL = 16\nconst CANNOT_CREATE_SUBDOMAIN = 32\nconst PARENT_CANNOT_CONTROL = 64\nconst CAN_DO_EVERYTHING = 0\n\nexport const fuseEnum = {\n  CANNOT_UNWRAP,\n  CANNOT_BURN_FUSES,\n  CANNOT_TRANSFER,\n  CANNOT_SET_RESOLVER,\n  CANNOT_SET_TTL,\n  CANNOT_CREATE_SUBDOMAIN,\n  PARENT_CANNOT_CONTROL,\n} as const\n\nexport const unnamedFuses = [\n  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,\n  524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,\n  134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,\n] as const\n\nconst fullFuseEnum = {\n  ...fuseEnum,\n  CAN_DO_EVERYTHING,\n}\n\nexport type FuseObj = typeof fuseEnum\nexport type UnnamedFuseType = typeof unnamedFuses\nexport type Fuse = keyof FuseObj\nexport type UnnamedFuseValues = UnnamedFuseType[number]\n\n// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.\nexport type FuseArrayPossibilities =\n  | [Fuse]\n  | [Fuse, Fuse]\n  | [Fuse, Fuse, Fuse]\n  | [Fuse, Fuse, Fuse, Fuse]\n  | [Fuse, Fuse, Fuse, Fuse, Fuse]\n  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]\n  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]\n\n/**\n * This type creates a type error if there are any duplicate fuses.\n * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.\n *\n * @template A The array to check for duplicates.\n * @template B The union of all checked existing types.\n */\n// CLAUSE A: This extension unwraps the type as a fuse tuple.\ntype FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities\n  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.\n    A extends [infer Head, ...infer Tail]\n    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.\n      Head extends B\n      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.\n        []\n      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.\n        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]\n    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.\n      A\n  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.\n    []\n\nexport type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>\n\nexport default fullFuseEnum\n"],
+  "mappings": ";AAAA,IAAM,gBAAgB;AACtB,IAAM,oBAAoB;AAC1B,IAAM,kBAAkB;AACxB,IAAM,sBAAsB;AAC5B,IAAM,iBAAiB;AACvB,IAAM,0BAA0B;AAChC,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAEnB,IAAM,WAAW;AAAA,EACtB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,eAAe;AAAA,EAC1B;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAQ;AAAA,EACpE;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAS;AAAA,EAAS;AAAA,EAAS;AAAA,EAAU;AAAA,EAAU;AAAA,EAChE;AAAA,EAAW;AAAA,EAAW;AAAA,EAAW;AAAA,EAAY;AAAA,EAAY;AAC3D;AAEA,IAAM,eAAe;AAAA,EACnB,GAAG;AAAA,EACH;AACF;AAyCA,IAAO,gBAAQ;",
+  "names": []
+}

package/dist/esm/utils/generateFuseInput.mjs

@@ -0,0 +1,16 @@
+// 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
+};
+//# sourceMappingURL=generateFuseInput.mjs.map

package/dist/esm/utils/generateFuseInput.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/generateFuseInput.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { FuseOptions } from '../@types/FuseOptions'\nimport fuses from './fuses'\n\nexport default (fuseOptions: FuseOptions) => {\n  const fuseKeys = Object.keys(fuseOptions)\n    .filter((opt) => fuseOptions[opt as keyof FuseOptions] === true)\n    .map((opt) =>\n      opt\n        .split(/(?=[A-Z])/)\n        .join('_')\n        .toUpperCase(),\n    )\n  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {\n    return prev.or(fuses[curr as keyof typeof fuses])\n  }, ethers.BigNumber.from(0))\n  return bigNumberFuses.toHexString()\n}\n"],
+  "mappings": ";AAAA,SAAS,cAAc;AAEvB,OAAO,WAAW;AAElB,IAAO,4BAAQ,CAAC,gBAA6B;AAC3C,QAAM,WAAW,OAAO,KAAK,WAAW,EACrC,OAAO,CAAC,QAAQ,YAAY,SAA8B,IAAI,EAC9D;AAAA,IAAI,CAAC,QACJ,IACG,MAAM,WAAW,EACjB,KAAK,GAAG,EACR,YAAY;AAAA,EACjB;AACF,QAAM,iBAAiB,SAAS,OAAO,CAAC,MAAM,SAAS;AACrD,WAAO,KAAK,GAAG,MAAM,KAA2B;AAAA,EAClD,GAAG,OAAO,UAAU,KAAK,CAAC,CAAC;AAC3B,SAAO,eAAe,YAAY;AACpC;",
+  "names": []
+}

package/dist/esm/utils/hexEncodedName.mjs

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

package/dist/esm/utils/hexEncodedName.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/hexEncodedName.ts"],
+  "sourcesContent": ["import packet from 'dns-packet'\n\nexport const hexEncodeName = (name: string) =>\n  `0x${packet.name.encode(name).toString('hex')}`\n"],
+  "mappings": ";AAAA,OAAO,YAAY;AAEZ,IAAM,gBAAgB,CAAC,SAC5B,KAAK,OAAO,KAAK,OAAO,IAAI,EAAE,SAAS,KAAK;",
+  "names": []
+}

package/dist/esm/utils/labels.mjs

@@ -0,0 +1,110 @@
+// src/utils/labels.ts
+import { solidityKeccak256 } from "ethers/lib/utils";
+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
+};
+//# sourceMappingURL=labels.mjs.map

package/dist/esm/utils/labels.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/labels.ts"],
+  "sourcesContent": ["import { solidityKeccak256 } from 'ethers/lib/utils'\nimport { truncateFormat } from './format'\n\nconst hasLocalStorage = typeof localStorage !== 'undefined'\n\nexport const labelhash = (input: string) =>\n  solidityKeccak256(['string'], [input])\n\nexport const keccakFromString = (input: string) => labelhash(input)\n\nexport function decodeLabelhash(hash: string) {\n  if (!(hash.startsWith('[') && hash.endsWith(']'))) {\n    throw Error(\n      'Expected encoded labelhash to start and end with square brackets',\n    )\n  }\n\n  if (hash.length !== 66) {\n    throw Error('Expected encoded labelhash to have a length of 66')\n  }\n\n  return `0x${hash.slice(1, -1)}`\n}\n\nexport function encodeLabelhash(hash: string) {\n  if (!hash.startsWith('0x')) {\n    throw new Error('Expected label hash to start with 0x')\n  }\n\n  if (hash.length !== 66) {\n    throw new Error('Expected label hash to have a length of 66')\n  }\n\n  return `[${hash.slice(2)}]`\n}\n\nexport function isEncodedLabelhash(hash: string) {\n  return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66\n}\n\nfunction getLabels() {\n  return hasLocalStorage\n    ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}\n    : {}\n}\n\nfunction _saveLabel(hash: string, label: any) {\n  if (!hasLocalStorage) return hash\n  const labels = getLabels()\n  localStorage.setItem(\n    'ensjs:labels',\n    JSON.stringify({\n      ...labels,\n      [hash]: label,\n    }),\n  )\n  return hash\n}\n\nexport function saveLabel(label: string) {\n  const hash = `${labelhash(label.toLowerCase())}`\n  return _saveLabel(hash, label)\n}\n\nexport function saveName(name: string) {\n  const nameArray = name.split('.')\n  nameArray.forEach((label: any) => {\n    saveLabel(label)\n  })\n}\n\n// eslint-disable-next-line consistent-return\nexport function checkLabel(hash: string): string | undefined {\n  const labels = getLabels()\n  if (isEncodedLabelhash(hash)) {\n    return labels[decodeLabelhash(hash)]\n  }\n\n  if (hash.startsWith('0x')) {\n    return labels[`${hash.slice(2)}`]\n  }\n}\n\nexport function encodeLabel(label: any) {\n  try {\n    return encodeLabelhash(label)\n  } catch {\n    return label\n  }\n}\n\nexport function parseName(name: string) {\n  const nameArray = name.split('.')\n  return nameArray.map((label: any) => encodeLabel(label)).join('.')\n}\n\nexport function checkIsDecrypted(string: string | string[]) {\n  return !string?.includes('[')\n}\n\nexport function decryptName(name: string) {\n  return name\n    .split('.')\n    .map((label: any) => checkLabel(label) || label)\n    .join('.')\n}\n\nexport const truncateUndecryptedName = (name: string) => truncateFormat(name)\n\nexport function checkLocalStorageSize() {\n  if (!hasLocalStorage) return 'Empty (0 KB)'\n  let allStrings = ''\n  for (const key in window.localStorage) {\n    if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {\n      allStrings += window.localStorage[key]\n    }\n  }\n  return allStrings\n    ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`\n    : 'Empty (0 KB)'\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/utils/makeHashIndexes.mjs

@@ -0,0 +1,11 @@
+// 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
+};
+//# sourceMappingURL=makeHashIndexes.mjs.map

package/dist/esm/utils/makeHashIndexes.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/makeHashIndexes.ts"],
+  "sourcesContent": ["import { namehash } from './normalise'\n\nexport const makeOtherIndexes = (data: string, findStr: string) =>\n  Array.from(data.matchAll(findStr as any)).map((x: any) => x.index / 2 - 1)\n\nexport const makeNamehashIndexes = (data: string, name: string) =>\n  Array.from(data.matchAll(namehash(name).substring(2) as any)).map(\n    (x: any) => x.index / 2 - 1,\n  )\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AAElB,IAAM,mBAAmB,CAAC,MAAc,YAC7C,MAAM,KAAK,KAAK,SAAS,OAAc,CAAC,EAAE,IAAI,CAAC,MAAW,EAAE,QAAQ,IAAI,CAAC;AAEpE,IAAM,sBAAsB,CAAC,MAAc,SAChD,MAAM,KAAK,KAAK,SAAS,SAAS,IAAI,EAAE,UAAU,CAAC,CAAQ,CAAC,EAAE;AAAA,EAC5D,CAAC,MAAW,EAAE,QAAQ,IAAI;AAC5B;",
+  "names": []
+}

package/dist/esm/utils/normalise.mjs

@@ -0,0 +1,31 @@
+// src/utils/normalise.ts
+import { concat, hexlify, keccak256, toUtf8Bytes } from "ethers/lib/utils";
+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
+};
+//# sourceMappingURL=normalise.mjs.map

package/dist/esm/utils/normalise.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/normalise.ts"],
+  "sourcesContent": ["import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'\nimport uts46 from 'idna-uts46-hx/uts46bundle.js'\nimport { decodeLabelhash, isEncodedLabelhash } from './labels'\n\nconst zeros = new Uint8Array(32)\nzeros.fill(0)\n\nexport const normalise = (name: string) =>\n  name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name\n\nexport const namehash = (name: string): string => {\n  let result: string | Uint8Array = zeros\n\n  if (name) {\n    const labels = name.split('.')\n\n    for (let i = labels.length - 1; i >= 0; i -= 1) {\n      let labelSha: string\n      if (isEncodedLabelhash(labels[i])) {\n        labelSha = decodeLabelhash(labels[i])\n      } else {\n        const normalised = normalise(labels[i])\n        labelSha = keccak256(toUtf8Bytes(normalised))\n      }\n\n      result = keccak256(concat([result, labelSha]))\n    }\n  } else {\n    result = hexlify(zeros)\n  }\n\n  return result as string\n}\n"],
+  "mappings": ";AAAA,SAAS,QAAQ,SAAS,WAAW,mBAAmB;AACxD,OAAO,WAAW;AAClB,SAAS,iBAAiB,0BAA0B;AAEpD,IAAM,QAAQ,IAAI,WAAW,EAAE;AAC/B,MAAM,KAAK,CAAC;AAEL,IAAM,YAAY,CAAC,SACxB,OAAO,MAAM,UAAU,MAAM,EAAE,cAAc,KAAK,CAAC,IAAI;AAElD,IAAM,WAAW,CAAC,SAAyB;AAChD,MAAI,SAA8B;AAElC,MAAI,MAAM;AACR,UAAM,SAAS,KAAK,MAAM,GAAG;AAE7B,aAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG;AAC9C,UAAI;AACJ,UAAI,mBAAmB,OAAO,EAAE,GAAG;AACjC,mBAAW,gBAAgB,OAAO,EAAE;AAAA,MACtC,OAAO;AACL,cAAM,aAAa,UAAU,OAAO,EAAE;AACtC,mBAAW,UAAU,YAAY,UAAU,CAAC;AAAA,MAC9C;AAEA,eAAS,UAAU,OAAO,CAAC,QAAQ,QAAQ,CAAC,CAAC;AAAA,IAC/C;AAAA,EACF,OAAO;AACL,aAAS,QAAQ,KAAK;AAAA,EACxB;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/esm/utils/recordHelpers.mjs

@@ -0,0 +1,71 @@
+// src/utils/recordHelpers.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+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]
+  );
+};
+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
+      ]);
+    };
+  }
+  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.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 {
+  generateRecordCallArray,
+  generateSetAddr,
+  generateSingleRecordCall
+};
+//# sourceMappingURL=recordHelpers.mjs.map

package/dist/esm/utils/recordHelpers.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/recordHelpers.ts"],
+  "sourcesContent": ["import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'\nimport type { PublicResolver } from '../generated'\nimport { encodeContenthash } from './contentHash'\n\ntype RecordItem = {\n  key: string\n  value: string\n}\n\nexport type RecordOptions = {\n  contentHash?: string\n  texts?: RecordItem[]\n  coinTypes?: RecordItem[]\n}\n\nexport const generateSetAddr = (\n  namehash: string,\n  coinType: string,\n  address: string,\n  resolver: PublicResolver,\n) => {\n  let coinTypeInstance\n  if (!Number.isNaN(parseInt(coinType))) {\n    coinTypeInstance = formatsByCoinType[parseInt(coinType)]\n  } else {\n    coinTypeInstance = formatsByName[coinType.toUpperCase()]\n  }\n  const inputCoinType = coinTypeInstance.coinType\n  const encodedAddress = coinTypeInstance.decoder(address)\n  return resolver?.interface.encodeFunctionData(\n    'setAddr(bytes32,uint256,bytes)',\n    [namehash, inputCoinType, encodedAddress],\n  )\n}\n\nexport type RecordTypes = 'contentHash' | 'text' | 'addr'\n\nexport type RecordInput<T extends RecordTypes> = T extends 'contentHash'\n  ? string\n  : RecordItem\n\nexport function generateSingleRecordCall<T extends RecordTypes>(\n  namehash: string,\n  resolver: PublicResolver,\n  type: T,\n): (record: RecordInput<T>) => string {\n  if (type === 'contentHash') {\n    return (_r: RecordInput<T>) => {\n      const record = _r as string\n      let _contentHash = ''\n      if (record !== _contentHash) {\n        const encoded = encodeContenthash(record)\n        if (encoded.error) throw new Error(encoded.error)\n        _contentHash = encoded.encoded as string\n      }\n      return resolver.interface.encodeFunctionData('setContenthash', [\n        namehash,\n        _contentHash,\n      ])\n    }\n  }\n  return (_r: RecordInput<T>) => {\n    const record = _r as RecordItem\n    if (type === 'text') {\n      return resolver.interface.encodeFunctionData('setText', [\n        namehash,\n        record.key,\n        record.value,\n      ])\n    }\n    return generateSetAddr(namehash, record.key, record.value, resolver)\n  }\n}\n\nexport const generateRecordCallArray = (\n  namehash: string,\n  records: RecordOptions,\n  resolver: PublicResolver,\n) => {\n  const calls: string[] = []\n\n  if (records.contentHash) {\n    const data = generateSingleRecordCall(\n      namehash,\n      resolver,\n      'contentHash',\n    )(records.contentHash)\n    if (data) calls.push(data)\n  }\n\n  if (records.texts && records.texts.length > 0) {\n    records.texts\n      .map(generateSingleRecordCall(namehash, resolver, 'text'))\n      .forEach((call) => calls.push(call))\n  }\n\n  if (records.coinTypes && records.coinTypes.length > 0) {\n    records.coinTypes\n      .map(generateSingleRecordCall(namehash, resolver, 'addr'))\n      .forEach((call) => calls.push(call))\n  }\n\n  return calls\n}\n"],
+  "mappings": ";AAAA,SAAS,mBAAmB,qBAAqB;AAEjD,SAAS,yBAAyB;AAa3B,IAAM,kBAAkB,CAC7B,UACA,UACA,SACA,aACG;AACH,MAAI;AACJ,MAAI,CAAC,OAAO,MAAM,SAAS,QAAQ,CAAC,GAAG;AACrC,uBAAmB,kBAAkB,SAAS,QAAQ;AAAA,EACxD,OAAO;AACL,uBAAmB,cAAc,SAAS,YAAY;AAAA,EACxD;AACA,QAAM,gBAAgB,iBAAiB;AACvC,QAAM,iBAAiB,iBAAiB,QAAQ,OAAO;AACvD,SAAO,UAAU,UAAU;AAAA,IACzB;AAAA,IACA,CAAC,UAAU,eAAe,cAAc;AAAA,EAC1C;AACF;AAQO,SAAS,yBACd,UACA,UACA,MACoC;AACpC,MAAI,SAAS,eAAe;AAC1B,WAAO,CAAC,OAAuB;AAC7B,YAAM,SAAS;AACf,UAAI,eAAe;AACnB,UAAI,WAAW,cAAc;AAC3B,cAAM,UAAU,kBAAkB,MAAM;AACxC,YAAI,QAAQ;AAAO,gBAAM,IAAI,MAAM,QAAQ,KAAK;AAChD,uBAAe,QAAQ;AAAA,MACzB;AACA,aAAO,SAAS,UAAU,mBAAmB,kBAAkB;AAAA,QAC7D;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO,CAAC,OAAuB;AAC7B,UAAM,SAAS;AACf,QAAI,SAAS,QAAQ;AACnB,aAAO,SAAS,UAAU,mBAAmB,WAAW;AAAA,QACtD;AAAA,QACA,OAAO;AAAA,QACP,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AACA,WAAO,gBAAgB,UAAU,OAAO,KAAK,OAAO,OAAO,QAAQ;AAAA,EACrE;AACF;AAEO,IAAM,0BAA0B,CACrC,UACA,SACA,aACG;AACH,QAAM,QAAkB,CAAC;AAEzB,MAAI,QAAQ,aAAa;AACvB,UAAM,OAAO;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,IACF,EAAE,QAAQ,WAAW;AACrB,QAAI;AAAM,YAAM,KAAK,IAAI;AAAA,EAC3B;AAEA,MAAI,QAAQ,SAAS,QAAQ,MAAM,SAAS,GAAG;AAC7C,YAAQ,MACL,IAAI,yBAAyB,UAAU,UAAU,MAAM,CAAC,EACxD,QAAQ,CAAC,SAAS,MAAM,KAAK,IAAI,CAAC;AAAA,EACvC;AAEA,MAAI,QAAQ,aAAa,QAAQ,UAAU,SAAS,GAAG;AACrD,YAAQ,UACL,IAAI,yBAAyB,UAAU,UAAU,MAAM,CAAC,EACxD,QAAQ,CAAC,SAAS,MAAM,KAAK,IAAI,CAAC;AAAA,EACvC;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/esm/utils/{registerHelpers.d.ts → registerHelpers.d.mts}

@@ -46,9 +46,9 @@ export declare const makeCommitmentData: ({ name, owner, duration, resolver, rec
     secret: string;
 }) => CommitmentTuple;
 export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
+export declare const _makeCommitment: (params: CommitmentTuple) => string;
 export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
     wrapperExpiry: number;
 };
-export declare const _makeCommitment: (params: CommitmentTuple) => string;

package/dist/esm/utils/registerHelpers.mjs

@@ -0,0 +1,96 @@
+// src/utils/registerHelpers.ts
+import { utils } from "ethers";
+import generateFuseInput from "./generateFuseInput.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,
+  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 || Math.floor(Date.now() / 1e3) + duration
+  ];
+};
+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 utils.keccak256(
+    utils.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 {
+  _makeCommitment,
+  makeCommitment,
+  makeCommitmentData,
+  makeRegistrationData,
+  randomSecret
+};
+//# sourceMappingURL=registerHelpers.mjs.map

package/dist/esm/utils/registerHelpers.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/registerHelpers.ts"],
+  "sourcesContent": ["import { utils } from 'ethers'\nimport type { FuseOptions } from '../@types/FuseOptions'\nimport type { PublicResolver } from '../generated'\nimport generateFuseInput from './generateFuseInput'\nimport { labelhash } from './labels'\nimport { namehash } from './normalise'\nimport { generateRecordCallArray, RecordOptions } from './recordHelpers'\n\nexport type RegistrationParams = {\n  name: string\n  owner: string\n  duration: number\n  secret: string\n  resolver: PublicResolver\n  records?: RecordOptions\n  reverseRecord?: boolean\n  fuses?: FuseOptions\n  wrapperExpiry: number\n}\n\nexport type CommitmentParams = Omit<\n  RegistrationParams,\n  'secret' | 'wrapperExpiry'\n> & {\n  secret?: string\n  wrapperExpiry?: number\n}\n\nexport type RegistrationTuple = [\n  name: string,\n  owner: string,\n  duration: number,\n  secret: string,\n  resolver: string,\n  data: string[],\n  reverseRecord: boolean,\n  fuses: string,\n  wrapperExpiry: number,\n]\n\nexport type CommitmentTuple = [\n  labelhash: string,\n  owner: string,\n  duration: number,\n  resolver: string,\n  data: string[],\n  secret: string,\n  reverseRecord: boolean,\n  fuses: string,\n  wrapperExpiry: number,\n]\n\nexport const randomSecret = () => {\n  const bytes = Buffer.allocUnsafe(32)\n  return `0x${crypto.getRandomValues(bytes).toString('hex')}`\n}\n\nexport const makeCommitmentData = ({\n  name,\n  owner,\n  duration,\n  resolver,\n  records,\n  reverseRecord,\n  fuses,\n  wrapperExpiry,\n  secret,\n}: CommitmentParams & {\n  secret: string\n}): CommitmentTuple => {\n  const label = labelhash(name.split('.')[0])\n  const hash = namehash(name)\n  const resolverAddress = resolver.address\n  const fuseData = fuses ? generateFuseInput(fuses) : '0'\n\n  if (reverseRecord) {\n    if (!records) {\n      records = { coinTypes: [{ key: 'ETH', value: owner }] }\n    } else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {\n      if (!records.coinTypes) records.coinTypes = []\n      records.coinTypes.push({ key: 'ETH', value: owner })\n    }\n  }\n\n  const data = records ? generateRecordCallArray(hash, records, resolver) : []\n\n  return [\n    label,\n    owner,\n    duration,\n    resolverAddress,\n    data,\n    secret,\n    !!reverseRecord,\n    fuseData,\n    wrapperExpiry || Math.floor(Date.now() / 1000) + duration,\n  ]\n}\n\nexport const makeRegistrationData = (\n  params: RegistrationParams,\n): RegistrationTuple => {\n  const commitmentData = makeCommitmentData(params)\n  const label = params.name.split('.')[0]\n  commitmentData[0] = label\n  const secret = commitmentData.splice(5, 1)[0]\n  commitmentData.splice(3, 0, secret)\n  return commitmentData as unknown as RegistrationTuple\n}\n\nexport const _makeCommitment = (params: CommitmentTuple) => {\n  return utils.keccak256(\n    utils.defaultAbiCoder.encode(\n      [\n        'bytes32',\n        'address',\n        'uint256',\n        'address',\n        'bytes[]',\n        'bytes32',\n        'bool',\n        'uint32',\n        'uint64',\n      ],\n      params,\n    ),\n  )\n}\n\nexport const makeCommitment = ({\n  secret = randomSecret(),\n  ...inputParams\n}: CommitmentParams) => {\n  const generatedParams = makeCommitmentData({\n    ...inputParams,\n    secret,\n  })\n\n  const commitment = _makeCommitment(generatedParams)\n\n  return {\n    secret,\n    commitment,\n    wrapperExpiry: generatedParams[8],\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,aAAa;AAGtB,OAAO,uBAAuB;AAC9B,SAAS,iBAAiB;AAC1B,SAAS,gBAAgB;AACzB,SAAS,+BAA8C;AA8ChD,IAAM,eAAe,MAAM;AAChC,QAAM,QAAQ,OAAO,YAAY,EAAE;AACnC,SAAO,KAAK,OAAO,gBAAgB,KAAK,EAAE,SAAS,KAAK;AAC1D;AAEO,IAAM,qBAAqB,CAAC;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAEuB;AACrB,QAAM,QAAQ,UAAU,KAAK,MAAM,GAAG,EAAE,EAAE;AAC1C,QAAM,OAAO,SAAS,IAAI;AAC1B,QAAM,kBAAkB,SAAS;AACjC,QAAM,WAAW,QAAQ,kBAAkB,KAAK,IAAI;AAEpD,MAAI,eAAe;AACjB,QAAI,CAAC,SAAS;AACZ,gBAAU,EAAE,WAAW,CAAC,EAAE,KAAK,OAAO,OAAO,MAAM,CAAC,EAAE;AAAA,IACxD,WAAW,CAAC,QAAQ,WAAW,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,GAAG;AAC3D,UAAI,CAAC,QAAQ;AAAW,gBAAQ,YAAY,CAAC;AAC7C,cAAQ,UAAU,KAAK,EAAE,KAAK,OAAO,OAAO,MAAM,CAAC;AAAA,IACrD;AAAA,EACF;AAEA,QAAM,OAAO,UAAU,wBAAwB,MAAM,SAAS,QAAQ,IAAI,CAAC;AAE3E,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,CAAC,CAAC;AAAA,IACF;AAAA,IACA,iBAAiB,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI,IAAI;AAAA,EACnD;AACF;AAEO,IAAM,uBAAuB,CAClC,WACsB;AACtB,QAAM,iBAAiB,mBAAmB,MAAM;AAChD,QAAM,QAAQ,OAAO,KAAK,MAAM,GAAG,EAAE;AACrC,iBAAe,KAAK;AACpB,QAAM,SAAS,eAAe,OAAO,GAAG,CAAC,EAAE;AAC3C,iBAAe,OAAO,GAAG,GAAG,MAAM;AAClC,SAAO;AACT;AAEO,IAAM,kBAAkB,CAAC,WAA4B;AAC1D,SAAO,MAAM;AAAA,IACX,MAAM,gBAAgB;AAAA,MACpB;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,iBAAiB,CAAC;AAAA,EAC7B,SAAS,aAAa;AAAA,KACnB;AACL,MAAwB;AACtB,QAAM,kBAAkB,mBAAmB;AAAA,IACzC,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AAED,QAAM,aAAa,gBAAgB,eAAe;AAElD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,eAAe,gBAAgB;AAAA,EACjC;AACF;",
+  "names": []
+}

package/dist/esm/utils/singleCall.mjs

@@ -0,0 +1,6 @@
+// src/utils/singleCall.ts
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call(rawData)).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+export {
+  singleCall_default as default
+};
+//# sourceMappingURL=singleCall.mjs.map

package/dist/esm/utils/singleCall.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/singleCall.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\n\nexport default async (\n  provider: ethers.providers.Provider,\n  ensData: any,\n  func: {\n    raw: (...args: any[]) => Promise<{ to: string; data: string }>\n    decode: (...args: any[]) => Promise<any>\n  },\n  ...data: any[]\n) =>\n  func\n    .raw(ensData, ...data)\n    .then((rawData) => provider.call(rawData))\n    .catch(() => null)\n    .then((ret) => func.decode(ensData, ret, ...data))\n"],
+  "mappings": ";AAEA,IAAO,qBAAQ,OACb,UACA,SACA,SAIG,SAEH,KACG,IAAI,SAAS,GAAG,IAAI,EACpB,KAAK,CAAC,YAAY,SAAS,KAAK,OAAO,CAAC,EACxC,MAAM,MAAM,IAAI,EAChB,KAAK,CAAC,QAAQ,KAAK,OAAO,SAAS,KAAK,GAAG,IAAI,CAAC;",
+  "names": []
+}

package/dist/esm/utils/validation.mjs

@@ -0,0 +1,68 @@
+// src/utils/validation.ts
+import { isAddress } from "ethers/lib/utils";
+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
+};
+//# sourceMappingURL=validation.mjs.map

package/dist/esm/utils/validation.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/validation.ts"],
+  "sourcesContent": ["import { isAddress } from 'ethers/lib/utils'\nimport { isEncodedLabelhash, saveName } from './labels'\nimport { normalise } from './normalise'\n\nexport const validateName = (name: string) => {\n  const nameArray = name.split('.')\n  const hasEmptyLabels = nameArray.some((label) => label.length === 0)\n  if (hasEmptyLabels) throw new Error('Name cannot have empty labels')\n  const normalizedArray = nameArray.map((label) => {\n    if (label === '[root]') {\n      return label\n    }\n    return isEncodedLabelhash(label) ? label : normalise(label)\n  })\n  const normalizedName = normalizedArray.join('.')\n  saveName(normalizedName)\n  return normalizedName\n}\n\nexport const validateTLD = (name: string) => {\n  const labels = name.split('.')\n  return validateName(labels[labels.length - 1])\n}\n\ntype InputType = {\n  type: 'name' | 'label' | 'address' | 'unknown'\n  info?: 'short' | 'supported' | 'unsupported'\n}\n\nexport const parseInputType = (input: string): InputType => {\n  const validTLD = validateTLD(input)\n  const regex = /[^.]+$/\n\n  try {\n    validateName(input)\n  } catch (e) {\n    return {\n      type: 'unknown',\n    }\n  }\n\n  if (input.indexOf('.') !== -1) {\n    const termArray = input.split('.')\n    const tld = input.match(regex) ? input.match(regex)![0] : ''\n    if (validTLD) {\n      if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {\n        // code-point length\n        return {\n          type: 'name',\n          info: 'short',\n        }\n      }\n      return {\n        type: 'name',\n        info: 'supported',\n      }\n    }\n\n    return {\n      type: 'name',\n      info: 'unsupported',\n    }\n  }\n  if (isAddress(input)) {\n    return {\n      type: 'address',\n    }\n  }\n  return {\n    type: 'label',\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,iBAAiB;AAC1B,SAAS,oBAAoB,gBAAgB;AAC7C,SAAS,iBAAiB;AAEnB,IAAM,eAAe,CAAC,SAAiB;AAC5C,QAAM,YAAY,KAAK,MAAM,GAAG;AAChC,QAAM,iBAAiB,UAAU,KAAK,CAAC,UAAU,MAAM,WAAW,CAAC;AACnE,MAAI;AAAgB,UAAM,IAAI,MAAM,+BAA+B;AACnE,QAAM,kBAAkB,UAAU,IAAI,CAAC,UAAU;AAC/C,QAAI,UAAU,UAAU;AACtB,aAAO;AAAA,IACT;AACA,WAAO,mBAAmB,KAAK,IAAI,QAAQ,UAAU,KAAK;AAAA,EAC5D,CAAC;AACD,QAAM,iBAAiB,gBAAgB,KAAK,GAAG;AAC/C,WAAS,cAAc;AACvB,SAAO;AACT;AAEO,IAAM,cAAc,CAAC,SAAiB;AAC3C,QAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,SAAO,aAAa,OAAO,OAAO,SAAS,EAAE;AAC/C;AAOO,IAAM,iBAAiB,CAAC,UAA6B;AAC1D,QAAM,WAAW,YAAY,KAAK;AAClC,QAAM,QAAQ;AAEd,MAAI;AACF,iBAAa,KAAK;AAAA,EACpB,SAAS,GAAP;AACA,WAAO;AAAA,MACL,MAAM;AAAA,IACR;AAAA,EACF;AAEA,MAAI,MAAM,QAAQ,GAAG,MAAM,IAAI;AAC7B,UAAM,YAAY,MAAM,MAAM,GAAG;AACjC,UAAM,MAAM,MAAM,MAAM,KAAK,IAAI,MAAM,MAAM,KAAK,EAAG,KAAK;AAC1D,QAAI,UAAU;AACZ,UAAI,QAAQ,SAAS,CAAC,GAAG,UAAU,UAAU,SAAS,EAAE,EAAE,SAAS,GAAG;AAEpE,eAAO;AAAA,UACL,MAAM;AAAA,UACN,MAAM;AAAA,QACR;AAAA,MACF;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,MAAM;AAAA,MACR;AAAA,IACF;AAEA,WAAO;AAAA,MACL,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF;AACA,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO;AAAA,MACL,MAAM;AAAA,IACR;AAAA,EACF;AACA,SAAO;AAAA,IACL,MAAM;AAAA,EACR;AACF;",
+  "names": []
+}

package/dist/esm/utils/wrapperExpiry.mjs

@@ -0,0 +1,26 @@
+// src/utils/wrapperExpiry.ts
+import { BigNumber } from "ethers";
+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;
+};
+export {
+  MAX_EXPIRY,
+  makeExpiry
+};
+//# sourceMappingURL=wrapperExpiry.mjs.map

package/dist/esm/utils/wrapperExpiry.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/wrapperExpiry.ts"],
+  "sourcesContent": ["import { BigNumber } from 'ethers'\nimport { ENSArgs } from '..'\n\nexport type Expiry = string | number | Date | BigNumber\n\nexport const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1)\n\nexport const makeExpiry = async (\n  { getExpiry }: ENSArgs<'getExpiry'>,\n  name: string,\n  expiry?: Expiry,\n) => {\n  if (expiry) {\n    if (expiry instanceof Date) {\n      return BigNumber.from(expiry.getTime() / 1000)\n    }\n    if (expiry instanceof BigNumber) {\n      return expiry\n    }\n    return BigNumber.from(expiry)\n  }\n  if (name.endsWith('.eth')) {\n    const expResponse = await getExpiry(name)\n    if (!expResponse?.expiry)\n      throw new Error(\"Couldn't get expiry for name, please provide one.\")\n    return BigNumber.from(expResponse.expiry.getTime() / 1000)\n  }\n  return MAX_EXPIRY\n}\n"],
+  "mappings": ";AAAA,SAAS,iBAAiB;AAKnB,IAAM,aAAa,UAAU,KAAK,CAAC,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC;AAElD,IAAM,aAAa,OACxB,EAAE,UAAU,GACZ,MACA,WACG;AACH,MAAI,QAAQ;AACV,QAAI,kBAAkB,MAAM;AAC1B,aAAO,UAAU,KAAK,OAAO,QAAQ,IAAI,GAAI;AAAA,IAC/C;AACA,QAAI,kBAAkB,WAAW;AAC/B,aAAO;AAAA,IACT;AACA,WAAO,UAAU,KAAK,MAAM;AAAA,EAC9B;AACA,MAAI,KAAK,SAAS,MAAM,GAAG;AACzB,UAAM,cAAc,MAAM,UAAU,IAAI;AACxC,QAAI,CAAC,aAAa;AAChB,YAAM,IAAI,MAAM,mDAAmD;AACrE,WAAO,UAAU,KAAK,YAAY,OAAO,QAAQ,IAAI,GAAI;AAAA,EAC3D;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/esm/utils/{writeTx.d.ts → writeTx.d.mts}

@@ -1,4 +1,4 @@
-import { JsonRpcSigner } from '@ethersproject/providers';
+import type { JsonRpcSigner } from '@ethersproject/providers';
 import type { PopulatedTransaction } from 'ethers';
 declare type CustomData = Record<string, any>;
 declare const _default: (signer: JsonRpcSigner, populate: boolean) => ({ customData, ...tx }: PopulatedTransaction) => {

package/dist/esm/utils/writeTx.mjs

@@ -0,0 +1,7 @@
+// 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
+};
+//# sourceMappingURL=writeTx.mjs.map