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

package/dist/cjs/utils/ccip.js

@@ -0,0 +1,129 @@
+"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 ccip_exports = {};
+__export(ccip_exports, {
+  default: () => ccip_default
+});
+module.exports = __toCommonJS(ccip_exports);
+var import_bignumber = require("@ethersproject/bignumber");
+var import_bytes = require("@ethersproject/bytes");
+var import_strings = require("@ethersproject/strings");
+function bytesPad(value) {
+  if (value.length % 32 === 0) {
+    return value;
+  }
+  const result = new Uint8Array(Math.ceil(value.length / 32) * 32);
+  result.set(value);
+  return result;
+}
+function numPad(value) {
+  const result = (0, import_bytes.arrayify)(value);
+  if (result.length > 32) {
+    throw new Error("internal; should not happen");
+  }
+  const padded = new Uint8Array(32);
+  padded.set(result, 32 - result.length);
+  return padded;
+}
+function encodeBytes(datas) {
+  const result = [];
+  let byteCount = 0;
+  for (let i = 0; i < datas.length; i += 1) {
+    result.push(new Uint8Array(0));
+    byteCount += 32;
+  }
+  for (let i = 0; i < datas.length; i += 1) {
+    const data = (0, import_bytes.arrayify)(datas[i]);
+    result[i] = numPad(byteCount);
+    result.push(numPad(data.length));
+    result.push(bytesPad(data));
+    byteCount += 32 + Math.ceil(data.length / 32) * 32;
+  }
+  return (0, import_bytes.hexConcat)(result);
+}
+function _parseBytes(result, start) {
+  if (result === "0x") {
+    return null;
+  }
+  const offset = import_bignumber.BigNumber.from(
+    (0, import_bytes.hexDataSlice)(result, start, start + 32)
+  ).toNumber();
+  const length = import_bignumber.BigNumber.from(
+    (0, import_bytes.hexDataSlice)(result, offset, offset + 32)
+  ).toNumber();
+  return (0, import_bytes.hexDataSlice)(result, offset + 32, offset + 32 + length);
+}
+function _parseString(result, start) {
+  try {
+    const bytes = _parseBytes(result, start);
+    if (bytes == null)
+      return null;
+    return (0, import_strings.toUtf8String)(bytes);
+  } catch (error) {
+  }
+  return null;
+}
+const ccipLookup = async (provider, transaction, result) => {
+  const txSender = transaction.to;
+  try {
+    const data = (0, import_bytes.hexDataSlice)(result, 4);
+    const sender = (0, import_bytes.hexDataSlice)(data, 0, 32);
+    if (!import_bignumber.BigNumber.from(sender).eq(txSender)) {
+      throw new Error("CCIP Read sender did not match");
+    }
+    const urls = [];
+    const urlsOffset = import_bignumber.BigNumber.from((0, import_bytes.hexDataSlice)(data, 32, 64)).toNumber();
+    const urlsLength = import_bignumber.BigNumber.from(
+      (0, import_bytes.hexDataSlice)(data, urlsOffset, urlsOffset + 32)
+    ).toNumber();
+    const urlsData = (0, import_bytes.hexDataSlice)(data, urlsOffset + 32);
+    for (let u = 0; u < urlsLength; u += 1) {
+      const url = _parseString(urlsData, u * 32);
+      if (url == null) {
+        throw new Error("CCIP Read contained corrupt URL string");
+      }
+      urls.push(url);
+    }
+    const calldata = _parseBytes(data, 64);
+    if (!import_bignumber.BigNumber.from((0, import_bytes.hexDataSlice)(data, 100, 128)).isZero()) {
+      throw new Error("CCIP Read callback selected included junk");
+    }
+    const callbackSelector = (0, import_bytes.hexDataSlice)(data, 96, 100);
+    const extraData = _parseBytes(data, 128);
+    const ccipResult = await provider.ccipReadFetch(
+      transaction,
+      calldata,
+      urls
+    );
+    if (ccipResult == null) {
+      throw new Error("CCIP Read disabled or provided no URLs");
+    }
+    const tx = {
+      to: txSender,
+      data: (0, import_bytes.hexConcat)([
+        callbackSelector,
+        encodeBytes([ccipResult, extraData])
+      ])
+    };
+    return await provider._call(tx, "latest", 1);
+  } catch (error) {
+    console.error(error);
+  }
+};
+var ccip_default = ccipLookup;

package/dist/cjs/utils/consts.js

@@ -0,0 +1,30 @@
+"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 consts_exports = {};
+__export(consts_exports, {
+  EMPTY_ADDRESS: () => EMPTY_ADDRESS,
+  MAX_DATE_INT: () => MAX_DATE_INT,
+  MAX_INT_64: () => MAX_INT_64,
+  MINIMUM_DOT_ETH_CHARS: () => MINIMUM_DOT_ETH_CHARS
+});
+module.exports = __toCommonJS(consts_exports);
+const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
+const MAX_INT_64 = BigInt("18446744073709551615");
+const MAX_DATE_INT = 864e13;
+const MINIMUM_DOT_ETH_CHARS = 3;

package/dist/cjs/utils/contentHash.js

@@ -1,164 +1,167 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeContenthash = exports.getProtocolType = exports.isValidContenthash = exports.validateContent = exports.decodeContenthash = void 0;
-const content_hash_1 = __importDefault(require("@ensdomains/content-hash"));
-const ethers_1 = require("ethers");
+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 contentHash_exports = {};
+__export(contentHash_exports, {
+  decodeContenthash: () => decodeContenthash,
+  encodeContenthash: () => encodeContenthash,
+  getProtocolType: () => getProtocolType,
+  isValidContenthash: () => isValidContenthash,
+  validateContent: () => validateContent
+});
+module.exports = __toCommonJS(contentHash_exports);
+var import_content_hash = __toESM(require("@ensdomains/content-hash"));
+var import_bytes = require("@ethersproject/bytes");
 const supportedCodecs = [
-    'ipns-ns',
-    'ipfs-ns',
-    'swarm-ns',
-    'onion',
-    'onion3',
-    'skynet-ns',
-    'arweave-ns',
+  "ipns-ns",
+  "ipfs-ns",
+  "swarm-ns",
+  "onion",
+  "onion3",
+  "skynet-ns",
+  "arweave-ns"
 ];
 function matchProtocol(text) {
-    return (text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave):\/\/(.*)/) ||
-        text.match(/\/(ipfs)\/(.*)/) ||
-        text.match(/\/(ipns)\/(.*)/));
+  return text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave|ar):\/\/(.*)/) || text.match(/\/(ipfs)\/(.*)/) || text.match(/\/(ipns)\/(.*)/);
 }
 function decodeContenthash(encoded) {
-    let decoded, protocolType, error;
-    if (!encoded || encoded === '0x') {
-        return {};
-    }
-    if (encoded.error) {
-        return { protocolType: null, decoded: encoded.error };
-    }
-    else if (encoded === false) {
-        return { protocolType: null, decoded: 'invalid value' };
-    }
-    if (encoded) {
-        try {
-            decoded = content_hash_1.default.decode(encoded);
-            const codec = content_hash_1.default.getCodec(encoded);
-            if (codec === 'ipfs-ns') {
-                protocolType = 'ipfs';
-            }
-            else if (codec === 'ipns-ns') {
-                protocolType = 'ipns';
-            }
-            else if (codec === 'swarm-ns') {
-                protocolType = 'bzz';
-            }
-            else if (codec === 'onion') {
-                protocolType = 'onion';
-            }
-            else if (codec === 'onion3') {
-                protocolType = 'onion3';
-            }
-            else if (codec === 'skynet-ns') {
-                protocolType = 'sia';
-            }
-            else if (codec === 'arweave-ns') {
-                protocolType = 'arweave';
-            }
-            else {
-                decoded = encoded;
-            }
-        }
-        catch (e) {
-            error = e.message;
-        }
+  let decoded;
+  let protocolType;
+  let error;
+  if (!encoded || encoded === "0x") {
+    return {};
+  }
+  if (encoded.error) {
+    return { protocolType: null, decoded: encoded.error };
+  }
+  if (encoded === false) {
+    return { protocolType: null, decoded: "invalid value" };
+  }
+  if (encoded) {
+    try {
+      decoded = import_content_hash.default.decode(encoded);
+      const codec = import_content_hash.default.getCodec(encoded);
+      if (codec === "ipfs-ns") {
+        protocolType = "ipfs";
+      } else if (codec === "ipns-ns") {
+        protocolType = "ipns";
+      } else if (codec === "swarm-ns") {
+        protocolType = "bzz";
+      } else if (codec === "onion") {
+        protocolType = "onion";
+      } else if (codec === "onion3") {
+        protocolType = "onion3";
+      } else if (codec === "skynet-ns") {
+        protocolType = "sia";
+      } else if (codec === "arweave-ns") {
+        protocolType = "ar";
+      } else {
+        decoded = encoded;
+      }
+    } catch (e) {
+      error = e.message;
     }
-    return { protocolType, decoded, error };
+  }
+  return { protocolType, decoded, error };
 }
-exports.decodeContenthash = decodeContenthash;
 function validateContent(encoded) {
-    return (content_hash_1.default.isHashOfType(encoded, content_hash_1.default.Types.ipfs) ||
-        content_hash_1.default.isHashOfType(encoded, content_hash_1.default.Types.swarm));
+  return import_content_hash.default.isHashOfType(encoded, import_content_hash.default.Types.ipfs) || import_content_hash.default.isHashOfType(encoded, import_content_hash.default.Types.swarm);
 }
-exports.validateContent = validateContent;
 function isValidContenthash(encoded) {
-    try {
-        const codec = content_hash_1.default.getCodec(encoded);
-        return ethers_1.utils.isHexString(encoded) && supportedCodecs.includes(codec);
-    }
-    catch (e) {
-        console.log(e);
-    }
+  try {
+    const codec = import_content_hash.default.getCodec(encoded);
+    return (0, import_bytes.isHexString)(encoded) && supportedCodecs.includes(codec);
+  } catch (e) {
+    console.log(e);
+  }
 }
-exports.isValidContenthash = isValidContenthash;
 function getProtocolType(encoded) {
-    let protocolType, decoded;
-    try {
-        let matched = matchProtocol(encoded);
-        if (matched) {
-            protocolType = matched[1];
-            decoded = matched[2];
-        }
-        return {
-            protocolType,
-            decoded,
-        };
-    }
-    catch (e) {
-        console.log(e);
+  let protocolType;
+  let decoded;
+  try {
+    const matched = matchProtocol(encoded);
+    if (matched) {
+      ;
+      [, protocolType, decoded] = matched;
     }
+    return {
+      protocolType,
+      decoded
+    };
+  } catch (e) {
+    console.log(e);
+  }
 }
-exports.getProtocolType = getProtocolType;
 function encodeContenthash(text) {
-    let content = text;
-    let contentType;
-    let encoded = false;
-    let error;
-    if (!!text) {
-        let matched = matchProtocol(text);
-        if (matched) {
-            contentType = matched[1];
-            content = matched[2];
+  let content = text;
+  let contentType;
+  let encoded = false;
+  let error;
+  if (text) {
+    const matched = matchProtocol(text);
+    if (matched) {
+      ;
+      [, contentType, content] = matched;
+    }
+    try {
+      if (contentType === "ipfs") {
+        if (content.length >= 4) {
+          encoded = `0x${import_content_hash.default.encode("ipfs-ns", content)}`;
+        }
+      } else if (contentType === "ipns") {
+        encoded = `0x${import_content_hash.default.encode("ipns-ns", content)}`;
+      } else if (contentType === "bzz") {
+        if (content.length >= 4) {
+          encoded = `0x${import_content_hash.default.fromSwarm(content)}`;
+        }
+      } else if (contentType === "onion") {
+        if (content.length === 16) {
+          encoded = `0x${import_content_hash.default.encode("onion", content)}`;
+        }
+      } else if (contentType === "onion3") {
+        if (content.length === 56) {
+          encoded = `0x${import_content_hash.default.encode("onion3", content)}`;
         }
-        try {
-            if (contentType === 'ipfs') {
-                if (content.length >= 4) {
-                    encoded = '0x' + content_hash_1.default.encode('ipfs-ns', content);
-                }
-            }
-            else if (contentType === 'ipns') {
-                encoded = '0x' + content_hash_1.default.encode('ipns-ns', content);
-            }
-            else if (contentType === 'bzz') {
-                if (content.length >= 4) {
-                    encoded = '0x' + content_hash_1.default.fromSwarm(content);
-                }
-            }
-            else if (contentType === 'onion') {
-                if (content.length == 16) {
-                    encoded = '0x' + content_hash_1.default.encode('onion', content);
-                }
-            }
-            else if (contentType === 'onion3') {
-                if (content.length == 56) {
-                    encoded = '0x' + content_hash_1.default.encode('onion3', content);
-                }
-            }
-            else if (contentType === 'sia') {
-                if (content.length == 46) {
-                    encoded = '0x' + content_hash_1.default.encode('skynet-ns', content);
-                }
-            }
-            else if (contentType === 'arweave') {
-                if (content.length == 43) {
-                    encoded = '0x' + content_hash_1.default.encode('arweave-ns', content);
-                }
-            }
-            else {
-                console.warn('Unsupported protocol or invalid value', {
-                    contentType,
-                    text,
-                });
-            }
+      } else if (contentType === "sia") {
+        if (content.length === 46) {
+          encoded = `0x${import_content_hash.default.encode("skynet-ns", content)}`;
         }
-        catch (err) {
-            const errorMessage = 'Error encoding content hash';
-            console.warn(errorMessage, { text, encoded });
-            error = errorMessage;
-            //throw 'Error encoding content hash'
+      } else if (contentType === "arweave" || contentType === "ar") {
+        if (content.length === 43) {
+          encoded = `0x${import_content_hash.default.encode("arweave-ns", content)}`;
         }
+      } else {
+        console.warn("Unsupported protocol or invalid value", {
+          contentType,
+          text
+        });
+      }
+    } catch (err) {
+      const errorMessage = "Error encoding content hash";
+      console.warn(errorMessage, { text, encoded });
+      error = errorMessage;
     }
-    return { encoded, error };
+  }
+  return { encoded, error };
 }
-exports.encodeContenthash = encodeContenthash;

package/dist/cjs/utils/createReverseNode.js

@@ -1,3 +1,24 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (address) => address.toLowerCase().substring(2) + '.addr.reverse';
+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 createReverseNode_exports = {};
+__export(createReverseNode_exports, {
+  default: () => createReverseNode_default
+});
+module.exports = __toCommonJS(createReverseNode_exports);
+var createReverseNode_default = (address) => `${address.toLowerCase().substring(2)}.addr.reverse`;

package/dist/cjs/utils/format.js

@@ -1,9 +1,28 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bracketFormat = exports.truncateFormat = exports.formatHashed = void 0;
-const formatHashed = (name) => name.replace(/(\[)(.{64})(\])/g, '0x$2');
-exports.formatHashed = formatHashed;
-const truncateFormat = (name) => name.replace(/(\[.{3})(.{58})(.{3}\])/g, '$1...$3');
-exports.truncateFormat = truncateFormat;
-const bracketFormat = (name) => name.replace(/(0x)(.{64})(?=\.)/g, '[$2]');
-exports.bracketFormat = bracketFormat;
+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 format_exports = {};
+__export(format_exports, {
+  bracketFormat: () => bracketFormat,
+  formatHashed: () => formatHashed,
+  truncateFormat: () => truncateFormat
+});
+module.exports = __toCommonJS(format_exports);
+const formatHashed = (name) => name.replace(/(\[)(.{64})(\])/g, "0x$2");
+const truncateFormat = (name) => name.replace(/(\[.{3})(.{58})(.{3}\])/g, "$1...$3");
+const bracketFormat = (name) => name.replace(/(0x)(.{64})(?=\.)/g, "[$2]");