@prosopo/datasets 3.1.54 → 3.1.55

package/dist/cjs/captcha/merkle.cjs

@@ -1,128 +1,99 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const util = require("@prosopo/util");
-const utilCrypto = require("@prosopo/util-crypto");
-class MerkleNode {
-  constructor(hash) {
-    this.hash = hash;
-    this.parent = null;
-  }
-}
-class CaptchaMerkleTree {
-  constructor() {
-    this.leaves = [];
-    this.layers = [];
-  }
-  getRoot() {
-    if (this.root === void 0) {
-      throw new common.ProsopoError("DATASET.MERKLE_ERROR", {
-        context: {
-          error: "root undefined",
-          failedFuncName: this.getRoot.name
-        }
-      });
-    }
-    return this.root;
-  }
-  build(leaves) {
-    if (this.layers.length) {
-      this.layers = [];
-    }
-    const layerZero = [];
-    for (const leaf of leaves) {
-      const node = new MerkleNode(leaf);
-      this.leaves.push(node);
-      layerZero.push(node.hash);
-    }
-    this.layers.push(layerZero);
-    this.root = this.buildMerkleTree(this.leaves)[0];
-  }
-  buildMerkleTree(leaves) {
-    const numLeaves = leaves.length;
-    if (numLeaves === 1) {
-      return leaves;
-    }
-    const parents = [];
-    let leafIndex = 0;
-    const newLayer = [];
-    while (leafIndex < numLeaves) {
-      const leftChild = leaves[leafIndex];
-      if (leftChild === void 0) {
-        throw new common.ProsopoError("DEVELOPER.GENERAL", {
-          context: { error: "leftChild undefined" }
-        });
-      }
-      const rightChild = leafIndex + 1 < numLeaves ? util.at(leaves, leafIndex + 1) : leftChild;
-      const parentNode = this.createParent(leftChild, rightChild);
-      newLayer.push(parentNode.hash);
-      parents.push(parentNode);
-      leafIndex += 2;
-    }
-    this.layers.push(newLayer);
-    return this.buildMerkleTree(parents);
-  }
-  createParent(leftChild, rightChild) {
-    const parent = new MerkleNode(
-      utilCrypto.hexHashArray([leftChild.hash, rightChild.hash])
-    );
-    leftChild.parent = parent.hash;
-    rightChild.parent = parent.hash;
-    return parent;
-  }
-  proof(leafHash) {
-    const proofTree = [];
-    let layerNum = 0;
-    while (layerNum < this.layers.length - 1) {
-      const layer = this.layers[layerNum];
-      if (layer === void 0) {
-        throw new common.ProsopoError("DATASET.MERKLE_ERROR", {
-          context: {
-            error: "layer undefined",
-            failedFuncName: this.proof.name,
-            layerNum
-          }
-        });
-      }
-      const leafIndex = layer.indexOf(leafHash);
-      let partnerIndex = leafIndex % 2 && leafIndex > 0 ? leafIndex - 1 : leafIndex + 1;
-      if (partnerIndex > layer.length - 1) {
-        partnerIndex = leafIndex;
-      }
-      const pair = [leafHash];
-      const partner = util.at(layer, partnerIndex);
-      if (partnerIndex > leafIndex) {
-        pair.push(partner);
-      } else {
-        pair.unshift(partner);
-      }
-      proofTree.push([util.at(pair, 0), util.at(pair, 1)]);
-      layerNum += 1;
-      leafHash = utilCrypto.hexHashArray(pair);
-    }
-    const last = util.at(this.layers, this.layers.length - 1);
-    return [...proofTree, [util.at(last, 0)]];
-  }
-}
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_util = require("@prosopo/util");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+//#region src/captcha/merkle.ts
+var MerkleNode = class {
+	constructor(hash) {
+		this.hash = hash;
+		this.parent = null;
+	}
+};
+var CaptchaMerkleTree = class {
+	constructor() {
+		this.leaves = [];
+		this.layers = [];
+	}
+	getRoot() {
+		if (this.root === void 0) throw new _prosopo_common.ProsopoError("DATASET.MERKLE_ERROR", { context: {
+			error: "root undefined",
+			failedFuncName: this.getRoot.name
+		} });
+		return this.root;
+	}
+	build(leaves) {
+		if (this.layers.length) this.layers = [];
+		const layerZero = [];
+		for (const leaf of leaves) {
+			const node = new MerkleNode(leaf);
+			this.leaves.push(node);
+			layerZero.push(node.hash);
+		}
+		this.layers.push(layerZero);
+		this.root = this.buildMerkleTree(this.leaves)[0];
+	}
+	buildMerkleTree(leaves) {
+		const numLeaves = leaves.length;
+		if (numLeaves === 1) return leaves;
+		const parents = [];
+		let leafIndex = 0;
+		const newLayer = [];
+		while (leafIndex < numLeaves) {
+			const leftChild = leaves[leafIndex];
+			if (leftChild === void 0) throw new _prosopo_common.ProsopoError("DEVELOPER.GENERAL", { context: { error: "leftChild undefined" } });
+			const rightChild = leafIndex + 1 < numLeaves ? (0, _prosopo_util.at)(leaves, leafIndex + 1) : leftChild;
+			const parentNode = this.createParent(leftChild, rightChild);
+			newLayer.push(parentNode.hash);
+			parents.push(parentNode);
+			leafIndex += 2;
+		}
+		this.layers.push(newLayer);
+		return this.buildMerkleTree(parents);
+	}
+	createParent(leftChild, rightChild) {
+		const parent = new MerkleNode((0, _prosopo_util_crypto.hexHashArray)([leftChild.hash, rightChild.hash]));
+		leftChild.parent = parent.hash;
+		rightChild.parent = parent.hash;
+		return parent;
+	}
+	proof(leafHash) {
+		const proofTree = [];
+		let layerNum = 0;
+		while (layerNum < this.layers.length - 1) {
+			const layer = this.layers[layerNum];
+			if (layer === void 0) throw new _prosopo_common.ProsopoError("DATASET.MERKLE_ERROR", { context: {
+				error: "layer undefined",
+				failedFuncName: this.proof.name,
+				layerNum
+			} });
+			const leafIndex = layer.indexOf(leafHash);
+			let partnerIndex = leafIndex % 2 && leafIndex > 0 ? leafIndex - 1 : leafIndex + 1;
+			if (partnerIndex > layer.length - 1) partnerIndex = leafIndex;
+			const pair = [leafHash];
+			const partner = (0, _prosopo_util.at)(layer, partnerIndex);
+			if (partnerIndex > leafIndex) pair.push(partner);
+			else pair.unshift(partner);
+			proofTree.push([(0, _prosopo_util.at)(pair, 0), (0, _prosopo_util.at)(pair, 1)]);
+			layerNum += 1;
+			leafHash = (0, _prosopo_util_crypto.hexHashArray)(pair);
+		}
+		const last = (0, _prosopo_util.at)(this.layers, this.layers.length - 1);
+		return [...proofTree, [(0, _prosopo_util.at)(last, 0)]];
+	}
+};
 function verifyProof(leaf, proof) {
-  try {
-    if (util.at(proof, 0).indexOf(leaf) === -1) {
-      return false;
-    }
-    for (const [layerIndex, layer] of proof.entries()) {
-      leaf = utilCrypto.hexHashArray(layer);
-      if (util.at(proof, layerIndex + 1).indexOf(leaf) === -1) {
-        return false;
-      }
-      const last = util.at(proof, proof.length - 1);
-      if (leaf === util.at(last, 0)) {
-        return true;
-      }
-    }
-    return false;
-  } catch (err) {
-    return false;
-  }
+	try {
+		if ((0, _prosopo_util.at)(proof, 0).indexOf(leaf) === -1) return false;
+		for (const [layerIndex, layer] of proof.entries()) {
+			leaf = (0, _prosopo_util_crypto.hexHashArray)(layer);
+			if ((0, _prosopo_util.at)(proof, layerIndex + 1).indexOf(leaf) === -1) return false;
+			const last = (0, _prosopo_util.at)(proof, proof.length - 1);
+			if (leaf === (0, _prosopo_util.at)(last, 0)) return true;
+		}
+		return false;
+	} catch (err) {
+		return false;
+	}
 }
+//#endregion
 exports.CaptchaMerkleTree = CaptchaMerkleTree;
 exports.verifyProof = verifyProof;

package/dist/cjs/captcha/util.cjs

@@ -1,23 +1,17 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
+let _prosopo_common = require("@prosopo/common");
+//#region src/captcha/util.ts
 async function downloadImage(url) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new common.ProsopoDatasetError("API.BAD_REQUEST", {
-        context: {
-          error: `Network response was not ok, status: ${response.status}`,
-          url
-        }
-      });
-    }
-    const buffer = await response.arrayBuffer();
-    return new Uint8Array(buffer);
-  } catch (err) {
-    throw new common.ProsopoEnvError("DATABASE.IMAGE_GET_FAILED", {
-      context: { error: err }
-    });
-  }
+	try {
+		const response = await fetch(url);
+		if (!response.ok) throw new _prosopo_common.ProsopoDatasetError("API.BAD_REQUEST", { context: {
+			error: `Network response was not ok, status: ${response.status}`,
+			url
+		} });
+		const buffer = await response.arrayBuffer();
+		return new Uint8Array(buffer);
+	} catch (err) {
+		throw new _prosopo_common.ProsopoEnvError("DATABASE.IMAGE_GET_FAILED", { context: { error: err } });
+	}
 }
+//#endregion
 exports.downloadImage = downloadImage;

package/dist/cjs/index.cjs

@@ -1,31 +1,29 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./captcha/index.cjs");
-const captchas = require("./tests/mocks/data/captchas.cjs");
-const captcha = require("./captcha/captcha.cjs");
-const merkle = require("./captcha/merkle.cjs");
-const util = require("./captcha/util.cjs");
-const dataset = require("./captcha/dataset.cjs");
-exports.datasetWithIndexSolutions = captchas.datasetWithIndexSolutions;
-exports.datasetWithSolutionHashes = captchas.datasetWithSolutionHashes;
-exports.NO_SOLUTION_VALUE = captcha.NO_SOLUTION_VALUE;
-exports.captchaSort = captcha.captchaSort;
-exports.compareCaptchaSolutions = captcha.compareCaptchaSolutions;
-exports.computeCaptchaHash = captcha.computeCaptchaHash;
-exports.computeCaptchaSolutionHash = captcha.computeCaptchaSolutionHash;
-exports.computeItemHash = captcha.computeItemHash;
-exports.computePendingRequestHash = captcha.computePendingRequestHash;
-exports.getSolutionValueToHash = captcha.getSolutionValueToHash;
-exports.matchItemsToSolutions = captcha.matchItemsToSolutions;
-exports.parseAndSortCaptchaSolutions = captcha.parseAndSortCaptchaSolutions;
-exports.parseCaptchaAssets = captcha.parseCaptchaAssets;
-exports.parseCaptchaDataset = captcha.parseCaptchaDataset;
-exports.sortAndComputeHashes = captcha.sortAndComputeHashes;
-exports.CaptchaMerkleTree = merkle.CaptchaMerkleTree;
-exports.verifyProof = merkle.verifyProof;
-exports.downloadImage = util.downloadImage;
-exports.addSolutionHashesToDataset = dataset.addSolutionHashesToDataset;
-exports.buildCaptchaTree = dataset.buildCaptchaTree;
-exports.buildDataset = dataset.buildDataset;
-exports.hashDatasetItems = dataset.hashDatasetItems;
-exports.validateDatasetContent = dataset.validateDatasetContent;
+const require_util = require("./captcha/util.cjs");
+const require_captcha = require("./captcha/captcha.cjs");
+const require_merkle = require("./captcha/merkle.cjs");
+const require_dataset = require("./captcha/dataset.cjs");
+const require_captchas = require("./tests/mocks/data/captchas.cjs");
+exports.CaptchaMerkleTree = require_merkle.CaptchaMerkleTree;
+exports.NO_SOLUTION_VALUE = require_captcha.NO_SOLUTION_VALUE;
+exports.addSolutionHashesToDataset = require_dataset.addSolutionHashesToDataset;
+exports.buildCaptchaTree = require_dataset.buildCaptchaTree;
+exports.buildDataset = require_dataset.buildDataset;
+exports.captchaSort = require_captcha.captchaSort;
+exports.compareCaptchaSolutions = require_captcha.compareCaptchaSolutions;
+exports.computeCaptchaHash = require_captcha.computeCaptchaHash;
+exports.computeCaptchaSolutionHash = require_captcha.computeCaptchaSolutionHash;
+exports.computeItemHash = require_captcha.computeItemHash;
+exports.computePendingRequestHash = require_captcha.computePendingRequestHash;
+exports.datasetWithIndexSolutions = require_captchas.datasetWithIndexSolutions;
+exports.datasetWithSolutionHashes = require_captchas.datasetWithSolutionHashes;
+exports.downloadImage = require_util.downloadImage;
+exports.getSolutionValueToHash = require_captcha.getSolutionValueToHash;
+exports.hashDatasetItems = require_dataset.hashDatasetItems;
+exports.matchItemsToSolutions = require_captcha.matchItemsToSolutions;
+exports.parseAndSortCaptchaSolutions = require_captcha.parseAndSortCaptchaSolutions;
+exports.parseCaptchaAssets = require_captcha.parseCaptchaAssets;
+exports.parseCaptchaDataset = require_captcha.parseCaptchaDataset;
+exports.sortAndComputeHashes = require_captcha.sortAndComputeHashes;
+exports.validateDatasetContent = require_dataset.validateDatasetContent;
+exports.verifyProof = require_merkle.verifyProof;