@prosopo/datasets 3.1.54 → 3.1.56

package/dist/captcha/dataset.js

@@ -1,94 +1,76 @@
+import { computeCaptchaHash, computeItemHash, matchItemsToSolutions } from "./captcha.js";
+import { CaptchaMerkleTree } from "./merkle.js";
 import { ProsopoEnvError } from "@prosopo/common";
-import { getLogger } from "@prosopo/logger";
 import { at } from "@prosopo/util";
-import { computeItemHash, computeCaptchaHash, matchItemsToSolutions } from "./captcha.js";
-import { CaptchaMerkleTree } from "./merkle.js";
-const logger = getLogger("info", "datasets:captcha");
+import { getLogger } from "@prosopo/logger";
+//#region src/captcha/dataset.ts
+var logger = getLogger("info", "datasets:captcha");
 async function hashDatasetItems(datasetRaw) {
-  return datasetRaw.captchas.map(async (captcha) => {
-    const items = await Promise.all(
-      captcha.items.map(async (item) => computeItemHash(item))
-    );
-    return {
-      ...captcha,
-      items
-    };
-  });
+	return datasetRaw.captchas.map(async (captcha) => {
+		const items = await Promise.all(captcha.items.map(async (item) => computeItemHash(item)));
+		return {
+			...captcha,
+			items
+		};
+	});
 }
+/**
+* Take a dataset and hash all the items, making sure that the existing captchaIds and item hashes are correct
+* @param datasetOriginal
+*/
 async function validateDatasetContent(datasetOriginal) {
-  const captchaPromises = await hashDatasetItems(datasetOriginal);
-  const captchas = await Promise.all(captchaPromises);
-  const dataset = {
-    ...datasetOriginal,
-    captchas
-  };
-  const hashes = dataset.captchas.map((captcha) => {
-    const captchaRaw = datasetOriginal.captchas.find(
-      (captchaRaw2) => "captchaId" in captchaRaw2 ? captchaRaw2.captchaId === captcha.captchaId : false
-    );
-    if (captchaRaw) {
-      return captcha.items.every(
-        (item, index) => item.hash === at(captchaRaw.items, index).hash
-      );
-    }
-    return false;
-  });
-  return hashes.every((hash) => hash);
+	const captchaPromises = await hashDatasetItems(datasetOriginal);
+	const captchas = await Promise.all(captchaPromises);
+	return {
+		...datasetOriginal,
+		captchas
+	}.captchas.map((captcha) => {
+		const captchaRaw = datasetOriginal.captchas.find((captchaRaw) => "captchaId" in captchaRaw ? captchaRaw.captchaId === captcha.captchaId : false);
+		if (captchaRaw) return captcha.items.every((item, index) => item.hash === at(captchaRaw.items, index).hash);
+		return false;
+	}).every((hash) => hash);
 }
 async function buildDataset(datasetRaw) {
-  logger.debug(() => ({ msg: "Adding solution hashes to dataset" }));
-  const dataset = await addSolutionHashesToDataset(datasetRaw);
-  logger.debug(() => ({ msg: "Building dataset merkle trees" }));
-  const contentTree = await buildCaptchaTree(dataset, false, false, true);
-  const solutionTree = await buildCaptchaTree(dataset, true, true, false);
-  dataset.captchas = dataset.captchas.map(
-    (captcha, index) => ({
-      ...captcha,
-      captchaId: at(solutionTree.leaves, index).hash,
-      captchaContentId: at(contentTree.leaves, index).hash,
-      datasetId: solutionTree.root?.hash,
-      datasetContentId: contentTree.root?.hash
-    })
-  );
-  dataset.solutionTree = solutionTree.layers;
-  dataset.contentTree = contentTree.layers;
-  dataset.datasetId = solutionTree.root?.hash;
-  dataset.datasetContentId = contentTree.root?.hash;
-  return dataset;
+	logger.debug(() => ({ msg: "Adding solution hashes to dataset" }));
+	const dataset = await addSolutionHashesToDataset(datasetRaw);
+	logger.debug(() => ({ msg: "Building dataset merkle trees" }));
+	const contentTree = await buildCaptchaTree(dataset, false, false, true);
+	const solutionTree = await buildCaptchaTree(dataset, true, true, false);
+	dataset.captchas = dataset.captchas.map((captcha, index) => ({
+		...captcha,
+		captchaId: at(solutionTree.leaves, index).hash,
+		captchaContentId: at(contentTree.leaves, index).hash,
+		datasetId: solutionTree.root?.hash,
+		datasetContentId: contentTree.root?.hash
+	}));
+	dataset.solutionTree = solutionTree.layers;
+	dataset.contentTree = contentTree.layers;
+	dataset.datasetId = solutionTree.root?.hash;
+	dataset.datasetContentId = contentTree.root?.hash;
+	return dataset;
 }
 async function buildCaptchaTree(dataset, includeSolution, includeSalt, sortItemHashes) {
-  try {
-    const tree = new CaptchaMerkleTree();
-    const datasetWithItemHashes = { ...dataset };
-    const captchaHashes = datasetWithItemHashes.captchas.map(
-      (captcha) => computeCaptchaHash(captcha, includeSolution, includeSalt, sortItemHashes)
-    );
-    tree.build(captchaHashes);
-    return tree;
-  } catch (err) {
-    throw new ProsopoEnvError("DATASET.HASH_ERROR");
-  }
+	try {
+		const tree = new CaptchaMerkleTree();
+		const captchaHashes = { ...dataset }.captchas.map((captcha) => computeCaptchaHash(captcha, includeSolution, includeSalt, sortItemHashes));
+		tree.build(captchaHashes);
+		return tree;
+	} catch (err) {
+		throw new ProsopoEnvError("DATASET.HASH_ERROR");
+	}
 }
 function addSolutionHashesToDataset(datasetRaw) {
-  const captchas = datasetRaw.captchas.map((captcha) => {
-    return {
-      ...captcha,
-      items: captcha.items,
-      // some captcha challenges will not have a solution
-      ...captcha.solution !== void 0 && {
-        solution: matchItemsToSolutions(captcha.solution, captcha.items)
-      }
-    };
-  });
-  return {
-    ...datasetRaw,
-    captchas
-  };
+	const captchas = datasetRaw.captchas.map((captcha) => {
+		return {
+			...captcha,
+			items: captcha.items,
+			...captcha.solution !== void 0 && { solution: matchItemsToSolutions(captcha.solution, captcha.items) }
+		};
+	});
+	return {
+		...datasetRaw,
+		captchas
+	};
 }
-export {
-  addSolutionHashesToDataset,
-  buildCaptchaTree,
-  buildDataset,
-  hashDatasetItems,
-  validateDatasetContent
-};
+//#endregion
+export { addSolutionHashesToDataset, buildCaptchaTree, buildDataset, hashDatasetItems, validateDatasetContent };

package/dist/captcha/index.js

@@ -1,27 +1,5 @@
+import { downloadImage } from "./util.js";
 import { NO_SOLUTION_VALUE, captchaSort, compareCaptchaSolutions, computeCaptchaHash, computeCaptchaSolutionHash, computeItemHash, computePendingRequestHash, getSolutionValueToHash, matchItemsToSolutions, parseAndSortCaptchaSolutions, parseCaptchaAssets, parseCaptchaDataset, sortAndComputeHashes } from "./captcha.js";
 import { CaptchaMerkleTree, verifyProof } from "./merkle.js";
-import { downloadImage } from "./util.js";
 import { addSolutionHashesToDataset, buildCaptchaTree, buildDataset, hashDatasetItems, validateDatasetContent } from "./dataset.js";
-export {
-  CaptchaMerkleTree,
-  NO_SOLUTION_VALUE,
-  addSolutionHashesToDataset,
-  buildCaptchaTree,
-  buildDataset,
-  captchaSort,
-  compareCaptchaSolutions,
-  computeCaptchaHash,
-  computeCaptchaSolutionHash,
-  computeItemHash,
-  computePendingRequestHash,
-  downloadImage,
-  getSolutionValueToHash,
-  hashDatasetItems,
-  matchItemsToSolutions,
-  parseAndSortCaptchaSolutions,
-  parseCaptchaAssets,
-  parseCaptchaDataset,
-  sortAndComputeHashes,
-  validateDatasetContent,
-  verifyProof
-};
+export { CaptchaMerkleTree, NO_SOLUTION_VALUE, addSolutionHashesToDataset, buildCaptchaTree, buildDataset, captchaSort, compareCaptchaSolutions, computeCaptchaHash, computeCaptchaSolutionHash, computeItemHash, computePendingRequestHash, downloadImage, getSolutionValueToHash, hashDatasetItems, matchItemsToSolutions, parseAndSortCaptchaSolutions, parseCaptchaAssets, parseCaptchaDataset, sortAndComputeHashes, validateDatasetContent, verifyProof };

package/dist/captcha/merkle.js

@@ -1,128 +1,98 @@
 import { ProsopoError } from "@prosopo/common";
 import { at } from "@prosopo/util";
 import { hexHashArray } from "@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 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 ProsopoError("DEVELOPER.GENERAL", {
-          context: { error: "leftChild undefined" }
-        });
-      }
-      const rightChild = leafIndex + 1 < numLeaves ? 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(
-      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 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 = at(layer, partnerIndex);
-      if (partnerIndex > leafIndex) {
-        pair.push(partner);
-      } else {
-        pair.unshift(partner);
-      }
-      proofTree.push([at(pair, 0), at(pair, 1)]);
-      layerNum += 1;
-      leafHash = hexHashArray(pair);
-    }
-    const last = at(this.layers, this.layers.length - 1);
-    return [...proofTree, [at(last, 0)]];
-  }
-}
+//#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 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 ProsopoError("DEVELOPER.GENERAL", { context: { error: "leftChild undefined" } });
+			const rightChild = leafIndex + 1 < numLeaves ? 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(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 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 = at(layer, partnerIndex);
+			if (partnerIndex > leafIndex) pair.push(partner);
+			else pair.unshift(partner);
+			proofTree.push([at(pair, 0), at(pair, 1)]);
+			layerNum += 1;
+			leafHash = hexHashArray(pair);
+		}
+		const last = at(this.layers, this.layers.length - 1);
+		return [...proofTree, [at(last, 0)]];
+	}
+};
 function verifyProof(leaf, proof) {
-  try {
-    if (at(proof, 0).indexOf(leaf) === -1) {
-      return false;
-    }
-    for (const [layerIndex, layer] of proof.entries()) {
-      leaf = hexHashArray(layer);
-      if (at(proof, layerIndex + 1).indexOf(leaf) === -1) {
-        return false;
-      }
-      const last = at(proof, proof.length - 1);
-      if (leaf === at(last, 0)) {
-        return true;
-      }
-    }
-    return false;
-  } catch (err) {
-    return false;
-  }
+	try {
+		if (at(proof, 0).indexOf(leaf) === -1) return false;
+		for (const [layerIndex, layer] of proof.entries()) {
+			leaf = hexHashArray(layer);
+			if (at(proof, layerIndex + 1).indexOf(leaf) === -1) return false;
+			const last = at(proof, proof.length - 1);
+			if (leaf === at(last, 0)) return true;
+		}
+		return false;
+	} catch (err) {
+		return false;
+	}
 }
-export {
-  CaptchaMerkleTree,
-  verifyProof
-};
+//#endregion
+export { CaptchaMerkleTree, verifyProof };

package/dist/captcha/util.js

@@ -1,23 +1,17 @@
 import { ProsopoDatasetError, ProsopoEnvError } from "@prosopo/common";
+//#region src/captcha/util.ts
 async function downloadImage(url) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new 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 ProsopoEnvError("DATABASE.IMAGE_GET_FAILED", {
-      context: { error: err }
-    });
-  }
+	try {
+		const response = await fetch(url);
+		if (!response.ok) throw new 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 ProsopoEnvError("DATABASE.IMAGE_GET_FAILED", { context: { error: err } });
+	}
 }
-export {
-  downloadImage
-};
+//#endregion
+export { downloadImage };