@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.60

package/dist/cjs/utils/normalise.js

@@ -1,28 +1,65 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.namehash = exports.normalise = void 0;
-const utils_1 = require("ethers/lib/utils");
-const uts46bundle_js_1 = __importDefault(require("idna-uts46-hx/uts46bundle.js"));
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var normalise_exports = {};
+__export(normalise_exports, {
+  beautify: () => beautify,
+  emoji: () => emoji,
+  isCombiningMark: () => isCombiningMark,
+  namehash: () => namehash,
+  normalise: () => normalise,
+  normalizeFragment: () => normalizeFragment,
+  shouldEscape: () => shouldEscape,
+  split: () => split,
+  tokenise: () => tokenise
+});
+module.exports = __toCommonJS(normalise_exports);
+var import_ens_normalize = require("@adraffy/ens-normalize");
+var import_bytes = require("@ethersproject/bytes");
+var import_keccak256 = require("@ethersproject/keccak256");
+var import_strings = require("@ethersproject/strings");
+var import_labels = require("./labels");
 const zeros = new Uint8Array(32);
 zeros.fill(0);
-const normalise = (name) => name ? uts46bundle_js_1.default.toUnicode(name, { useStd3ASCII: true }) : name;
-exports.normalise = normalise;
-const namehash = (inputName) => {
-    let result = zeros;
-    const name = (0, exports.normalise)(inputName);
-    if (name) {
-        const labels = name.split('.');
-        for (var i = labels.length - 1; i >= 0; i--) {
-            const labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(labels[i]));
-            result = (0, utils_1.keccak256)((0, utils_1.concat)([result, labelSha]));
-        }
-    }
-    else {
-        result = (0, utils_1.hexlify)(zeros);
+const normalise = (name) => name ? (0, import_ens_normalize.ens_normalize)(name) : name;
+const namehash = (name) => {
+  let result = zeros;
+  if (name) {
+    const labels = name.split(".");
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+      let labelSha;
+      if ((0, import_labels.isEncodedLabelhash)(labels[i])) {
+        labelSha = (0, import_labels.decodeLabelhash)(labels[i]);
+      } else {
+        const normalised = normalise(labels[i]);
+        labelSha = (0, import_keccak256.keccak256)((0, import_strings.toUtf8Bytes)(normalised));
+      }
+      result = (0, import_keccak256.keccak256)((0, import_bytes.concat)([result, labelSha]));
     }
-    return result;
+  } else {
+    result = (0, import_bytes.hexlify)(zeros);
+  }
+  return result;
 };
-exports.namehash = namehash;
+const beautify = import_ens_normalize.ens_beautify;
+const emoji = import_ens_normalize.ens_emoji;
+const normalizeFragment = import_ens_normalize.ens_normalize_fragment;
+const split = import_ens_normalize.ens_split;
+const tokenise = import_ens_normalize.ens_tokenize;
+const isCombiningMark = import_ens_normalize.is_combining_mark;
+const shouldEscape = import_ens_normalize.should_escape;

package/dist/cjs/utils/recordHelpers.js

@@ -1,44 +1,164 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRecordCallArray = exports.generateSetAddr = void 0;
-const address_encoder_1 = require("@ensdomains/address-encoder");
-const contentHash_1 = require("./contentHash");
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recordHelpers_exports = {};
+__export(recordHelpers_exports, {
+  generateABIInput: () => generateABIInput,
+  generateRecordCallArray: () => generateRecordCallArray,
+  generateSetAddr: () => generateSetAddr,
+  generateSingleRecordCall: () => generateSingleRecordCall
+});
+module.exports = __toCommonJS(recordHelpers_exports);
+var import_address_encoder = require("@ensdomains/address-encoder");
+var import_bytes = require("@ethersproject/bytes");
+var import_strings = require("@ethersproject/strings");
+var import_contentHash = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
-    let coinTypeInstance;
-    if (!isNaN(parseInt(coinType))) {
-        coinTypeInstance = address_encoder_1.formatsByCoinType[parseInt(coinType)];
-    }
-    else {
-        coinTypeInstance = address_encoder_1.formatsByName[coinType.toUpperCase()];
-    }
-    const inputCoinType = coinTypeInstance.coinType;
-    const encodedAddress = coinTypeInstance.decoder(address);
-    return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
+  let coinTypeInstance;
+  if (!Number.isNaN(parseInt(coinType))) {
+    coinTypeInstance = import_address_encoder.formatsByCoinType[parseInt(coinType)];
+  } else {
+    coinTypeInstance = import_address_encoder.formatsByName[coinType.toUpperCase()];
+  }
+  const inputCoinType = coinTypeInstance.coinType;
+  let encodedAddress = address !== "" ? coinTypeInstance.decoder(address) : "0x";
+  if (inputCoinType === 60 && encodedAddress === "0x")
+    encodedAddress = coinTypeInstance.decoder(
+      "0x0000000000000000000000000000000000000000"
+    );
+  return resolver == null ? void 0 : resolver.interface.encodeFunctionData(
+    "setAddr(bytes32,uint256,bytes)",
+    [namehash, inputCoinType, encodedAddress]
+  );
 };
-exports.generateSetAddr = generateSetAddr;
-const generateRecordCallArray = (namehash, records, resolver) => {
-    const calls = [];
-    if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : (0, contentHash_1.encodeContenthash)(records.contentHash);
-        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
-        data && calls.push(data);
+const 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;
     }
-    if (records.texts && records.texts.length > 0) {
-        records.texts.forEach(({ key, value }) => {
-            const data = resolver?.interface.encodeFunctionData('setText', [
-                namehash,
-                key,
-                value,
-            ]);
-            data && calls.push(data);
-        });
+    default: {
+      contentType = 8;
+      encodedData = data;
+      break;
     }
-    if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes.forEach(({ key, value }) => {
-            const data = (0, exports.generateSetAddr)(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+  }
+  return { contentType, data: encodedData };
+};
+function generateSingleRecordCall(namehash, resolver, type) {
+  if (type === "contentHash") {
+    return (_r) => {
+      const record = _r;
+      let _contentHash = "";
+      if (record !== _contentHash) {
+        const encoded = (0, import_contentHash.encodeContenthash)(record);
+        if (encoded.error)
+          throw new Error(encoded.error);
+        _contentHash = encoded.encoded;
+      } else {
+        _contentHash = "0x";
+      }
+      return resolver.interface.encodeFunctionData("setContenthash", [
+        namehash,
+        _contentHash
+      ]);
+    };
+  }
+  if (type === "abi") {
+    return (_r) => {
+      const record = _r;
+      const { contentType = 1, data } = record;
+      let encodedData = data;
+      if (!(0, import_bytes.isBytesLike)(encodedData)) {
+        if (typeof encodedData === "object") {
+          encodedData = JSON.stringify(encodedData);
+        }
+        encodedData = (0, import_strings.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 calls;
+    return generateSetAddr(namehash, record.key, record.value, resolver);
+  };
+}
+const generateRecordCallArray = (namehash, records, resolver) => {
+  const calls = [];
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData("clearRecords", [namehash])
+    );
+  }
+  if (typeof records.contentHash === "string") {
+    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;
 };
-exports.generateRecordCallArray = generateRecordCallArray;

package/dist/cjs/utils/registerHelpers.js

@@ -1,52 +1,110 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0;
-const ethers_1 = require("ethers");
-const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
-const labels_1 = require("./labels");
-const normalise_1 = require("./normalise");
-const recordHelpers_1 = require("./recordHelpers");
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registerHelpers_exports = {};
+__export(registerHelpers_exports, {
+  _makeCommitment: () => _makeCommitment,
+  makeCommitment: () => makeCommitment,
+  makeCommitmentData: () => makeCommitmentData,
+  makeRegistrationData: () => makeRegistrationData,
+  randomSecret: () => randomSecret
+});
+module.exports = __toCommonJS(registerHelpers_exports);
+var import_abi = require("@ethersproject/abi");
+var import_keccak256 = require("@ethersproject/keccak256");
+var import_fuses = require("./fuses");
+var import_labels = require("./labels");
+var import_normalise = require("./normalise");
+var import_recordHelpers = require("./recordHelpers");
 const randomSecret = () => {
-    const bytes = Buffer.allocUnsafe(32);
-    return '0x' + crypto.getRandomValues(bytes).toString('hex');
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+const makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  secret
+}) => {
+  var _a;
+  const labelHash = (0, import_labels.labelhash)(name.split(".")[0]);
+  const hash = (0, import_normalise.namehash)(name);
+  const resolverAddress = resolver.address;
+  const fuseData = (0, import_fuses.hasFuses)(fuses) ? (0, import_fuses.encodeFuses)(fuses, "child") : 0;
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: "ETH", value: owner }] };
+    } else if (!((_a = records.coinTypes) == null ? void 0 : _a.find((c) => c.key === "ETH"))) {
+      if (!records.coinTypes)
+        records.coinTypes = [];
+      records.coinTypes.push({ key: "ETH", value: owner });
+    }
+  }
+  const data = records ? (0, import_recordHelpers.generateRecordCallArray)(hash, records, resolver) : [];
+  return [
+    labelHash,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    data,
+    !!reverseRecord,
+    fuseData
+  ];
+};
+const makeRegistrationData = (params) => {
+  const commitmentData = makeCommitmentData(params);
+  const label = params.name.split(".")[0];
+  commitmentData[0] = label;
+  return commitmentData;
 };
-exports.randomSecret = randomSecret;
-const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
-    const label = (0, labels_1.labelhash)(name.split('.')[0]);
-    const hash = (0, normalise_1.namehash)(name);
-    const resolverAddress = resolver.address;
-    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
-    const secret = (0, exports.randomSecret)();
-    const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
-    const commitment = (0, exports._makeCommitment)({
-        labelhash: label,
-        owner,
-        duration,
-        secret,
-        resolver: resolverAddress,
-        data,
-        reverseRecord: !!reverseRecord,
-        fuses: fuseData,
-    });
-    return {
-        secret,
-        commitment,
-    };
+const _makeCommitment = (params) => {
+  return (0, import_keccak256.keccak256)(
+    import_abi.defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "bytes32",
+        "address",
+        "bytes[]",
+        "bool",
+        "uint16"
+      ],
+      params
+    )
+  );
 };
-exports.makeCommitment = makeCommitment;
-const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
-    return ethers_1.utils.solidityKeccak256([
-        'bytes32',
-        'address',
-        'uint256',
-        'bytes32',
-        'address',
-        'bytes[]',
-        'bool',
-        'uint96',
-    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment
+  };
 };
-exports._makeCommitment = _makeCommitment;

package/dist/cjs/utils/registry.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  makeResolver: () => makeResolver
+});
+module.exports = __toCommonJS(registry_exports);
+var import_normalise = require("./normalise");
+const makeResolver = async ({ contracts }, name, resolver) => {
+  if (resolver)
+    return resolver;
+  const registry = await contracts.getRegistry();
+  const node = (0, import_normalise.namehash)(name);
+  const _resolver = await registry.resolver(node);
+  return _resolver;
+};

package/dist/cjs/utils/singleCall.js

@@ -1,7 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = async (provider, ensData, func, ...data) => func
-    .raw(ensData, ...data)
-    .then((rawData) => provider.call(rawData))
-    .catch(() => null)
-    .then((ret) => func.decode(ensData, ret, ...data));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var singleCall_exports = {};
+__export(singleCall_exports, {
+  default: () => singleCall_default
+});
+module.exports = __toCommonJS(singleCall_exports);
+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);
+};

package/dist/cjs/utils/subgraph-types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subgraph_types_exports = {};
+module.exports = __toCommonJS(subgraph_types_exports);