@prosopo/datasets 3.1.53 → 3.1.55

package/dist/cjs/captcha/captcha.cjs

@@ -1,185 +1,200 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util$2 = require("@polkadot/util");
-const common = require("@prosopo/common");
-const types = require("@prosopo/types");
-const util = require("@prosopo/util");
-const utilCrypto = require("@prosopo/util-crypto");
-const util$1 = require("./util.cjs");
-const NO_SOLUTION_VALUE = "NO_SOLUTION";
+const require_util = require("./util.cjs");
+let _polkadot_util = require("@polkadot/util");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_util = require("@prosopo/util");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+//#region src/captcha/captcha.ts
+var NO_SOLUTION_VALUE = "NO_SOLUTION";
+/**
+* Parse a dataset
+* @return {JSON} captcha dataset, stored in JSON
+* @param datasetJSON
+*/
 function parseCaptchaDataset(datasetJSON) {
-  try {
-    const result = types.DatasetWithNumericSolutionSchema.parse(datasetJSON);
-    const result2 = {
-      format: result.format,
-      captchas: result.captchas.map((captcha) => {
-        return {
-          ...captcha,
-          solution: captcha.solution ? matchItemsToSolutions(captcha.solution, captcha.items) : [],
-          unlabelled: captcha.unlabelled ? matchItemsToSolutions(captcha.unlabelled, captcha.items) : []
-        };
-      })
-    };
-    if (result.datasetId !== void 0) result2.datasetId = result.datasetId;
-    if (result.contentTree !== void 0)
-      result2.contentTree = result.contentTree;
-    if (result.datasetContentId !== void 0)
-      result2.datasetContentId = result.datasetContentId;
-    if (result.solutionTree !== void 0)
-      result2.solutionTree = result.solutionTree;
-    return result2;
-  } catch (err) {
-    throw new common.ProsopoDatasetError("DATASET.DATASET_PARSE_ERROR", {
-      context: { error: err }
-    });
-  }
+	try {
+		const result = _prosopo_types.DatasetWithNumericSolutionSchema.parse(datasetJSON);
+		const result2 = {
+			format: result.format,
+			captchas: result.captchas.map((captcha) => {
+				return {
+					...captcha,
+					solution: captcha.solution ? matchItemsToSolutions(captcha.solution, captcha.items) : [],
+					unlabelled: captcha.unlabelled ? matchItemsToSolutions(captcha.unlabelled, captcha.items) : []
+				};
+			})
+		};
+		if (result.datasetId !== void 0) result2.datasetId = result.datasetId;
+		if (result.contentTree !== void 0) result2.contentTree = result.contentTree;
+		if (result.datasetContentId !== void 0) result2.datasetContentId = result.datasetContentId;
+		if (result.solutionTree !== void 0) result2.solutionTree = result.solutionTree;
+		return result2;
+	} catch (err) {
+		throw new _prosopo_common.ProsopoDatasetError("DATASET.DATASET_PARSE_ERROR", { context: { error: err } });
+	}
 }
+/**
+* Make sure captcha solutions are in the correct format
+* @param {JSON} captchaJSON captcha solutions received from the api
+* @return {CaptchaSolution[]} an array of parsed and sorted captcha solutions
+*/
 function parseAndSortCaptchaSolutions(captchaJSON) {
-  try {
-    return types.CaptchaSolutionArraySchema.parse(captchaJSON).map((captcha) => ({
-      ...captcha,
-      solution: captcha.solution.sort()
-    }));
-  } catch (err) {
-    throw new common.ProsopoDatasetError("DATASET.SOLUTION_PARSE_ERROR", {
-      context: { error: err }
-    });
-  }
+	try {
+		return _prosopo_types.CaptchaSolutionArraySchema.parse(captchaJSON).map((captcha) => ({
+			...captcha,
+			solution: captcha.solution.sort()
+		}));
+	} catch (err) {
+		throw new _prosopo_common.ProsopoDatasetError("DATASET.SOLUTION_PARSE_ERROR", { context: { error: err } });
+	}
 }
 function captchaSort(a, b) {
-  return a.captchaId.localeCompare(b.captchaId);
+	return a.captchaId.localeCompare(b.captchaId);
 }
 function sortAndComputeHashes(received, stored) {
-  received.sort(captchaSort);
-  stored.sort(captchaSort);
-  return stored.map(
-    ({ salt, items = [], target = "", captchaId, solved }, index) => {
-      const item = util.at(received, index);
-      if (captchaId !== item.captchaId) {
-        throw new common.ProsopoEnvError("CAPTCHA.ID_MISMATCH");
-      }
-      return {
-        hash: computeCaptchaHash(
-          {
-            solution: solved ? item.solution : [],
-            salt,
-            items,
-            target
-          },
-          true,
-          true,
-          false
-        ),
-        captchaId
-      };
-    }
-  );
+	received.sort(captchaSort);
+	stored.sort(captchaSort);
+	return stored.map(({ salt, items = [], target = "", captchaId, solved }, index) => {
+		const item = (0, _prosopo_util.at)(received, index);
+		if (captchaId !== item.captchaId) throw new _prosopo_common.ProsopoEnvError("CAPTCHA.ID_MISMATCH");
+		return {
+			hash: computeCaptchaHash({
+				solution: solved ? item.solution : [],
+				salt,
+				items,
+				target
+			}, true, true, false),
+			captchaId
+		};
+	});
 }
+/**
+* Take an array of CaptchaSolutions and Captchas and check if the solutions are the same for each pair
+* @param  {CaptchaSolution[]} received
+* @param solutions
+* @param totalImages
+* @param  {number} threshold the percentage of captchas that must be correct to return true
+* @return {boolean}
+*/
 function compareCaptchaSolutions(received, solutions, totalImages, threshold) {
-  received.sort(captchaSort);
-  solutions.sort(captchaSort);
-  if (received.length !== solutions.length) {
-    return false;
-  }
-  if (received.length && solutions.length && received.length === solutions.length) {
-    const captchaIdMismatch = received.some(
-      (captcha, index) => solutions[index] && captcha.captchaId !== solutions[index].captchaId
-    );
-    if (captchaIdMismatch) {
-      return false;
-    }
-  }
-  return received.every((captcha, index) => {
-    const sortedReceivedSolution = captcha.solution.sort();
-    const targetSolution = solutions[index]?.solution.sort();
-    if (!targetSolution) {
-      return false;
-    }
-    const incorrectCount = sortedReceivedSolution.filter(
-      (solution) => !targetSolution.includes(solution)
-    ).length;
-    const missingCount = targetSolution.filter(
-      (solution) => !sortedReceivedSolution.includes(solution)
-    ).length;
-    const totalIncorrect = incorrectCount + missingCount;
-    const percentageCorrect = 1 - totalIncorrect / totalImages;
-    return percentageCorrect >= threshold;
-  });
+	received.sort(captchaSort);
+	solutions.sort(captchaSort);
+	if (received.length !== solutions.length) return false;
+	if (received.length && solutions.length && received.length === solutions.length) {
+		if (received.some((captcha, index) => solutions[index] && captcha.captchaId !== solutions[index].captchaId)) return false;
+	}
+	return received.every((captcha, index) => {
+		const sortedReceivedSolution = captcha.solution.sort();
+		const targetSolution = solutions[index]?.solution.sort();
+		if (!targetSolution) return false;
+		return 1 - (sortedReceivedSolution.filter((solution) => !targetSolution.includes(solution)).length + targetSolution.filter((solution) => !sortedReceivedSolution.includes(solution)).length) / totalImages >= threshold;
+	});
 }
+/**
+* Compute the hash of various types of captcha
+* @param  {Captcha} captcha
+* @param  {boolean} includeSolution
+* @param  {boolean} includeSalt
+* @param  {boolean} sortItemHashes
+* @return {string} the hex string hash
+*/
 function computeCaptchaHash(captcha, includeSolution, includeSalt, sortItemHashes) {
-  try {
-    const itemHashes = captcha.items.map((item, index) => {
-      if (item.hash) {
-        return item.hash;
-      }
-      throw new common.ProsopoDatasetError("CAPTCHA.MISSING_ITEM_HASH", {
-        context: {
-          computeCaptchaHashName: computeCaptchaHash.name,
-          index
-        }
-      });
-    });
-    return utilCrypto.hexHashArray([
-      captcha.target,
-      // empty array hashes as empty string, undefined solution results in the array [`NO_SOLUTION`]
-      // [undefined] also hashes as empty string, which is why we don't use it
-      ...includeSolution ? getSolutionValueToHash(captcha.solution) : [],
-      includeSalt ? captcha.salt : "",
-      sortItemHashes ? itemHashes.sort() : itemHashes
-    ]);
-  } catch (err) {
-    throw new common.ProsopoDatasetError("DATASET.HASH_ERROR", {
-      context: { error: err }
-    });
-  }
+	try {
+		const itemHashes = captcha.items.map((item, index) => {
+			if (item.hash) return item.hash;
+			throw new _prosopo_common.ProsopoDatasetError("CAPTCHA.MISSING_ITEM_HASH", { context: {
+				computeCaptchaHashName: computeCaptchaHash.name,
+				index
+			} });
+		});
+		return (0, _prosopo_util_crypto.hexHashArray)([
+			captcha.target,
+			...includeSolution ? getSolutionValueToHash(captcha.solution) : [],
+			includeSalt ? captcha.salt : "",
+			sortItemHashes ? itemHashes.sort() : itemHashes
+		]);
+	} catch (err) {
+		throw new _prosopo_common.ProsopoDatasetError("DATASET.HASH_ERROR", { context: { error: err } });
+	}
 }
+/** Return the sorted solution value or ['NO_SOLUTION'] if there is no solution. Ensures that an empty array is a valid
+* solution
+* @param solution
+*/
 function getSolutionValueToHash(solution) {
-  return solution !== void 0 ? solution.sort() : [NO_SOLUTION_VALUE];
+	return solution !== void 0 ? solution.sort() : [NO_SOLUTION_VALUE];
 }
+/** Compute the hash of a captcha item, downloading the image if necessary
+* @param  {Item} item
+* @return {Promise<HashedItem>} the hex string hash of the item
+*/
 async function computeItemHash(item) {
-  if (item.type === "text") {
-    return { ...item, hash: utilCrypto.hexHash(item.data) };
-  }
-  if (item.type === "image") {
-    return { ...item, hash: utilCrypto.hexHash(await util$1.downloadImage(item.data)) };
-  }
-  throw new common.ProsopoDatasetError("CAPTCHA.INVALID_ITEM_FORMAT");
+	if (item.type === "text") return {
+		...item,
+		hash: (0, _prosopo_util_crypto.hexHash)(item.data)
+	};
+	if (item.type === "image") return {
+		...item,
+		hash: (0, _prosopo_util_crypto.hexHash)(await require_util.downloadImage(item.data))
+	};
+	throw new _prosopo_common.ProsopoDatasetError("CAPTCHA.INVALID_ITEM_FORMAT");
 }
+/**
+* Converts an indexed captcha solution to a hashed captcha solution or simply returns the hash if it is already hashed
+* @return {HashedSolution[]}
+* @param {RawSolution[] | HashedSolution[]} solutions
+* @param {Item[]} items
+*/
 function matchItemsToSolutions(solutions, items) {
-  if (!items) {
-    return [];
-  }
-  return solutions.map((solution) => {
-    if (typeof solution === "string" && util$2.isHex(solution)) {
-      if (!items?.some((item) => item.hash === solution)) {
-        throw new common.ProsopoDatasetError("CAPTCHA.INVALID_ITEM_HASH");
-      }
-      return solution;
-    }
-    if (typeof solution === "number") {
-      const item = util.at(items, solution);
-      return item.hash;
-    }
-    throw new common.ProsopoDatasetError("CAPTCHA.INVALID_SOLUTION_TYPE");
-  });
+	if (!items) return [];
+	return solutions.map((solution) => {
+		if (typeof solution === "string" && (0, _polkadot_util.isHex)(solution)) {
+			if (!items?.some((item) => item.hash === solution)) throw new _prosopo_common.ProsopoDatasetError("CAPTCHA.INVALID_ITEM_HASH");
+			return solution;
+		}
+		if (typeof solution === "number") return (0, _prosopo_util.at)(items, solution).hash;
+		throw new _prosopo_common.ProsopoDatasetError("CAPTCHA.INVALID_SOLUTION_TYPE");
+	});
 }
+/**
+* Create a unique solution commitment
+* @param  {CaptchaSolution} captcha
+* @return {string} the hex string hash
+*/
 function computeCaptchaSolutionHash(captcha) {
-  return utilCrypto.hexHashArray([
-    captcha.captchaId,
-    captcha.captchaContentId,
-    [...captcha.solution].sort(),
-    captcha.salt
-  ]);
+	return (0, _prosopo_util_crypto.hexHashArray)([
+		captcha.captchaId,
+		captcha.captchaContentId,
+		[...captcha.solution].sort(),
+		captcha.salt
+	]);
 }
+/**
+* Compute hash for an array of captcha ids, userAccount, and salt, which serves as the identifier for a pending request
+* @param  {string[]} captchaIds
+* @param  {string} userAccount
+* @param  {string} salt
+* @return {string}
+*/
 function computePendingRequestHash(captchaIds, userAccount, salt) {
-  return utilCrypto.hexHashArray([...captchaIds.sort(), userAccount, salt]);
+	return (0, _prosopo_util_crypto.hexHashArray)([
+		...captchaIds.sort(),
+		userAccount,
+		salt
+	]);
 }
+/**
+* Parse the image items in a captcha and pass back a URI if they exist
+* @param  {Item} item
+* @param  {AssetsResolver} assetsResolver
+*/
 function parseCaptchaAssets(item, assetsResolver) {
-  return {
-    ...item,
-    data: assetsResolver?.resolveAsset(item.data).getURL() || item.data
-  };
+	return {
+		...item,
+		data: assetsResolver?.resolveAsset(item.data).getURL() || item.data
+	};
 }
+//#endregion
 exports.NO_SOLUTION_VALUE = NO_SOLUTION_VALUE;
 exports.captchaSort = captchaSort;
 exports.compareCaptchaSolutions = compareCaptchaSolutions;

package/dist/cjs/captcha/dataset.cjs

@@ -1,92 +1,77 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const logger$1 = require("@prosopo/logger");
-const util = require("@prosopo/util");
-const captcha = require("./captcha.cjs");
-const merkle = require("./merkle.cjs");
-const logger = logger$1.getLogger("info", "datasets:captcha");
+const require_captcha = require("./captcha.cjs");
+const require_merkle = require("./merkle.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_util = require("@prosopo/util");
+//#region src/captcha/dataset.ts
+var logger = (0, require("@prosopo/logger").getLogger)("info", "datasets:captcha");
 async function hashDatasetItems(datasetRaw) {
-  return datasetRaw.captchas.map(async (captcha$1) => {
-    const items = await Promise.all(
-      captcha$1.items.map(async (item) => captcha.computeItemHash(item))
-    );
-    return {
-      ...captcha$1,
-      items
-    };
-  });
+	return datasetRaw.captchas.map(async (captcha) => {
+		const items = await Promise.all(captcha.items.map(async (item) => require_captcha.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((captcha2) => {
-    const captchaRaw = datasetOriginal.captchas.find(
-      (captchaRaw2) => "captchaId" in captchaRaw2 ? captchaRaw2.captchaId === captcha2.captchaId : false
-    );
-    if (captchaRaw) {
-      return captcha2.items.every(
-        (item, index) => item.hash === util.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 === (0, _prosopo_util.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(
-    (captcha2, index) => ({
-      ...captcha2,
-      captchaId: util.at(solutionTree.leaves, index).hash,
-      captchaContentId: util.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: (0, _prosopo_util.at)(solutionTree.leaves, index).hash,
+		captchaContentId: (0, _prosopo_util.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 merkle.CaptchaMerkleTree();
-    const datasetWithItemHashes = { ...dataset };
-    const captchaHashes = datasetWithItemHashes.captchas.map(
-      (captcha$1) => captcha.computeCaptchaHash(captcha$1, includeSolution, includeSalt, sortItemHashes)
-    );
-    tree.build(captchaHashes);
-    return tree;
-  } catch (err) {
-    throw new common.ProsopoEnvError("DATASET.HASH_ERROR");
-  }
+	try {
+		const tree = new require_merkle.CaptchaMerkleTree();
+		const captchaHashes = { ...dataset }.captchas.map((captcha) => require_captcha.computeCaptchaHash(captcha, includeSolution, includeSalt, sortItemHashes));
+		tree.build(captchaHashes);
+		return tree;
+	} catch (err) {
+		throw new _prosopo_common.ProsopoEnvError("DATASET.HASH_ERROR");
+	}
 }
 function addSolutionHashesToDataset(datasetRaw) {
-  const captchas = datasetRaw.captchas.map((captcha$1) => {
-    return {
-      ...captcha$1,
-      items: captcha$1.items,
-      // some captcha challenges will not have a solution
-      ...captcha$1.solution !== void 0 && {
-        solution: captcha.matchItemsToSolutions(captcha$1.solution, captcha$1.items)
-      }
-    };
-  });
-  return {
-    ...datasetRaw,
-    captchas
-  };
+	const captchas = datasetRaw.captchas.map((captcha) => {
+		return {
+			...captcha,
+			items: captcha.items,
+			...captcha.solution !== void 0 && { solution: require_captcha.matchItemsToSolutions(captcha.solution, captcha.items) }
+		};
+	});
+	return {
+		...datasetRaw,
+		captchas
+	};
 }
+//#endregion
 exports.addSolutionHashesToDataset = addSolutionHashesToDataset;
 exports.buildCaptchaTree = buildCaptchaTree;
 exports.buildDataset = buildDataset;

package/dist/cjs/captcha/index.cjs

@@ -1,27 +1,25 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const captcha = require("./captcha.cjs");
-const merkle = require("./merkle.cjs");
-const util = require("./util.cjs");
-const dataset = require("./dataset.cjs");
-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("./util.cjs");
+const require_captcha = require("./captcha.cjs");
+const require_merkle = require("./merkle.cjs");
+const require_dataset = require("./dataset.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.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;