@prosopo/datasets 3.0.9 → 3.0.11

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @prosopo/datasets
 
+## 3.0.11
+### Patch Changes
+
+- Updated dependencies [625fef8]
+  - @prosopo/types-database@3.0.11
+
+## 3.0.10
+### Patch Changes
+
+- 3573f0b: fix npm scripts bundle command
+- 3573f0b: build using vite, typecheck using tsc
+- efd8102: Add tests for unwrap error helper
+- 3573f0b: standardise all vite based npm scripts for bundling
+- Updated dependencies [52dbf21]
+- Updated dependencies [93d5e50]
+- Updated dependencies [3573f0b]
+- Updated dependencies [8a64429]
+- Updated dependencies [3573f0b]
+- Updated dependencies [efd8102]
+- Updated dependencies [93d5e50]
+- Updated dependencies [63519d7]
+- Updated dependencies [f29fc7e]
+- Updated dependencies [3573f0b]
+- Updated dependencies [2d0dd8a]
+- Updated dependencies [6d604ad]
+  - @prosopo/util@3.0.3
+  - @prosopo/util-crypto@13.5.2
+  - @prosopo/types@3.0.4
+  - @prosopo/types-database@3.0.10
+  - @prosopo/common@3.1.0
+  - @prosopo/config@3.1.1
+
 ## 3.0.9
 ### Patch Changes
 

package/dist/captcha/captcha.js

@@ -1,175 +1,194 @@
 import { isHex } from "@polkadot/util";
-import { ProsopoDatasetError, ProsopoEnvError, hexHash, hexHashArray, } from "@prosopo/common";
-import { CaptchaSolutionArraySchema, DatasetWithNumericSolutionSchema, } from "@prosopo/types";
+import { ProsopoDatasetError, ProsopoEnvError, hexHashArray, hexHash } from "@prosopo/common";
+import { DatasetWithNumericSolutionSchema, CaptchaSolutionArraySchema } from "@prosopo/types";
 import { at } from "@prosopo/util";
 import { downloadImage } from "./util.js";
-export const NO_SOLUTION_VALUE = "NO_SOLUTION";
-export function parseCaptchaDataset(datasetJSON) {
-    try {
-        const result = 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 !== undefined)
-            result2.datasetId = result.datasetId;
-        if (result.contentTree !== undefined)
-            result2.contentTree = result.contentTree;
-        if (result.datasetContentId !== undefined)
-            result2.datasetContentId = result.datasetContentId;
-        if (result.solutionTree !== undefined)
-            result2.solutionTree = result.solutionTree;
-        return result2;
-    }
-    catch (err) {
-        throw new ProsopoDatasetError("DATASET.DATASET_PARSE_ERROR", {
-            context: { error: err },
-        });
-    }
-}
-export function parseAndSortCaptchaSolutions(captchaJSON) {
-    try {
-        return CaptchaSolutionArraySchema.parse(captchaJSON).map((captcha) => ({
-            ...captcha,
-            solution: captcha.solution.sort(),
-        }));
-    }
-    catch (err) {
-        throw new ProsopoDatasetError("DATASET.SOLUTION_PARSE_ERROR", {
-            context: { error: err },
-        });
-    }
-}
-export function captchaSort(a, b) {
-    return a.captchaId.localeCompare(b.captchaId);
-}
-export function sortAndComputeHashes(received, stored) {
-    received.sort(captchaSort);
-    stored.sort(captchaSort);
-    return stored.map(({ salt, items = [], target = "", captchaId, solved }, index) => {
-        const item = at(received, index);
-        if (captchaId !== item.captchaId) {
-            throw new ProsopoEnvError("CAPTCHA.ID_MISMATCH");
-        }
+const NO_SOLUTION_VALUE = "NO_SOLUTION";
+function parseCaptchaDataset(datasetJSON) {
+  try {
+    const result = DatasetWithNumericSolutionSchema.parse(datasetJSON);
+    const result2 = {
+      format: result.format,
+      captchas: result.captchas.map((captcha) => {
         return {
-            hash: computeCaptchaHash({
-                solution: solved ? item.solution : [],
-                salt,
-                items,
-                target,
-            }, true, true, false),
-            captchaId,
+          ...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 ProsopoDatasetError("DATASET.DATASET_PARSE_ERROR", {
+      context: { error: err }
     });
+  }
 }
-export 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;
+function parseAndSortCaptchaSolutions(captchaJSON) {
+  try {
+    return CaptchaSolutionArraySchema.parse(captchaJSON).map((captcha) => ({
+      ...captcha,
+      solution: captcha.solution.sort()
+    }));
+  } catch (err) {
+    throw new ProsopoDatasetError("DATASET.SOLUTION_PARSE_ERROR", {
+      context: { error: err }
     });
+  }
 }
-export function computeCaptchaHash(captcha, includeSolution, includeSalt, sortItemHashes) {
-    try {
-        const itemHashes = captcha.items.map((item, index) => {
-            if (item.hash) {
-                return item.hash;
-            }
-            throw new ProsopoDatasetError("CAPTCHA.MISSING_ITEM_HASH", {
-                context: {
-                    computeCaptchaHashName: computeCaptchaHash.name,
-                    index,
-                },
-            });
-        });
-        return hexHashArray([
-            captcha.target,
-            ...(includeSolution ? getSolutionValueToHash(captcha.solution) : []),
-            includeSalt ? captcha.salt : "",
-            sortItemHashes ? itemHashes.sort() : itemHashes,
-        ]);
-    }
-    catch (err) {
-        throw new ProsopoDatasetError("DATASET.HASH_ERROR", {
-            context: { error: err },
-        });
-    }
+function captchaSort(a, b) {
+  return a.captchaId.localeCompare(b.captchaId);
 }
-export function getSolutionValueToHash(solution) {
-    return solution !== undefined ? solution.sort() : [NO_SOLUTION_VALUE];
+function sortAndComputeHashes(received, stored) {
+  received.sort(captchaSort);
+  stored.sort(captchaSort);
+  return stored.map(
+    ({ salt, items = [], target = "", captchaId, solved }, index) => {
+      const item = at(received, index);
+      if (captchaId !== item.captchaId) {
+        throw new ProsopoEnvError("CAPTCHA.ID_MISMATCH");
+      }
+      return {
+        hash: computeCaptchaHash(
+          {
+            solution: solved ? item.solution : [],
+            salt,
+            items,
+            target
+          },
+          true,
+          true,
+          false
+        ),
+        captchaId
+      };
+    }
+  );
 }
-export async function computeItemHash(item) {
-    if (item.type === "text") {
-        return { ...item, hash: hexHash(item.data) };
+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;
     }
-    if (item.type === "image") {
-        return { ...item, hash: hexHash(await downloadImage(item.data)) };
+  }
+  return received.every((captcha, index) => {
+    const sortedReceivedSolution = captcha.solution.sort();
+    const targetSolution = solutions[index]?.solution.sort();
+    if (!targetSolution) {
+      return false;
     }
-    throw new ProsopoDatasetError("CAPTCHA.INVALID_ITEM_FORMAT");
+    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;
+  });
 }
-export function matchItemsToSolutions(solutions, items) {
-    if (!items) {
-        return [];
-    }
-    return solutions.map((solution) => {
-        if (typeof solution === "string" && isHex(solution)) {
-            if (!items?.some((item) => item.hash === solution)) {
-                throw new ProsopoDatasetError("CAPTCHA.INVALID_ITEM_HASH");
-            }
-            return solution;
+function computeCaptchaHash(captcha, includeSolution, includeSalt, sortItemHashes) {
+  try {
+    const itemHashes = captcha.items.map((item, index) => {
+      if (item.hash) {
+        return item.hash;
+      }
+      throw new ProsopoDatasetError("CAPTCHA.MISSING_ITEM_HASH", {
+        context: {
+          computeCaptchaHashName: computeCaptchaHash.name,
+          index
         }
-        if (typeof solution === "number") {
-            const item = at(items, solution);
-            return item.hash;
-        }
-        throw new ProsopoDatasetError("CAPTCHA.INVALID_SOLUTION_TYPE");
+      });
     });
-}
-export function computeCaptchaSolutionHash(captcha) {
     return hexHashArray([
-        captcha.captchaId,
-        captcha.captchaContentId,
-        [...captcha.solution].sort(),
-        captcha.salt,
+      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 ProsopoDatasetError("DATASET.HASH_ERROR", {
+      context: { error: err }
+    });
+  }
 }
-export function computePendingRequestHash(captchaIds, userAccount, salt) {
-    return hexHashArray([...captchaIds.sort(), userAccount, salt]);
+function getSolutionValueToHash(solution) {
+  return solution !== void 0 ? solution.sort() : [NO_SOLUTION_VALUE];
 }
-export function parseCaptchaAssets(item, assetsResolver) {
-    return {
-        ...item,
-        data: assetsResolver?.resolveAsset(item.data).getURL() || item.data,
-    };
+async function computeItemHash(item) {
+  if (item.type === "text") {
+    return { ...item, hash: hexHash(item.data) };
+  }
+  if (item.type === "image") {
+    return { ...item, hash: hexHash(await downloadImage(item.data)) };
+  }
+  throw new ProsopoDatasetError("CAPTCHA.INVALID_ITEM_FORMAT");
+}
+function matchItemsToSolutions(solutions, items) {
+  if (!items) {
+    return [];
+  }
+  return solutions.map((solution) => {
+    if (typeof solution === "string" && isHex(solution)) {
+      if (!items?.some((item) => item.hash === solution)) {
+        throw new ProsopoDatasetError("CAPTCHA.INVALID_ITEM_HASH");
+      }
+      return solution;
+    }
+    if (typeof solution === "number") {
+      const item = at(items, solution);
+      return item.hash;
+    }
+    throw new ProsopoDatasetError("CAPTCHA.INVALID_SOLUTION_TYPE");
+  });
+}
+function computeCaptchaSolutionHash(captcha) {
+  return hexHashArray([
+    captcha.captchaId,
+    captcha.captchaContentId,
+    [...captcha.solution].sort(),
+    captcha.salt
+  ]);
+}
+function computePendingRequestHash(captchaIds, userAccount, salt) {
+  return hexHashArray([...captchaIds.sort(), userAccount, salt]);
+}
+function parseCaptchaAssets(item, assetsResolver) {
+  return {
+    ...item,
+    data: assetsResolver?.resolveAsset(item.data).getURL() || item.data
+  };
 }
-//# sourceMappingURL=captcha.js.map
+export {
+  NO_SOLUTION_VALUE,
+  captchaSort,
+  compareCaptchaSolutions,
+  computeCaptchaHash,
+  computeCaptchaSolutionHash,
+  computeItemHash,
+  computePendingRequestHash,
+  getSolutionValueToHash,
+  matchItemsToSolutions,
+  parseAndSortCaptchaSolutions,
+  parseCaptchaAssets,
+  parseCaptchaDataset,
+  sortAndComputeHashes
+};

package/dist/captcha/dataset.js

@@ -1,79 +1,93 @@
-import { ProsopoEnvError, getLogger } from "@prosopo/common";
+import { getLogger, ProsopoEnvError } from "@prosopo/common";
 import { at } from "@prosopo/util";
-import { computeCaptchaHash, computeItemHash, matchItemsToSolutions, } from "./captcha.js";
+import { computeItemHash, computeCaptchaHash, matchItemsToSolutions } from "./captcha.js";
 import { CaptchaMerkleTree } from "./merkle.js";
 const logger = getLogger("info", import.meta.url);
-export 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,
-        };
-    });
-}
-export async function validateDatasetContent(datasetOriginal) {
-    const captchaPromises = await hashDatasetItems(datasetOriginal);
-    const captchas = await Promise.all(captchaPromises);
-    const dataset = {
-        ...datasetOriginal,
-        captchas,
+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
     };
-    const hashes = dataset.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;
-    });
-    return hashes.every((hash) => hash);
-}
-export 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;
+  });
 }
-export 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");
+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);
+}
+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;
+}
+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");
+  }
 }
-export function addSolutionHashesToDataset(datasetRaw) {
-    const captchas = datasetRaw.captchas.map((captcha) => {
-        return {
-            ...captcha,
-            items: captcha.items,
-            ...(captcha.solution !== undefined && {
-                solution: matchItemsToSolutions(captcha.solution, captcha.items),
-            }),
-        };
-    });
+function addSolutionHashesToDataset(datasetRaw) {
+  const captchas = datasetRaw.captchas.map((captcha) => {
     return {
-        ...datasetRaw,
-        captchas,
+      ...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
+  };
 }
-//# sourceMappingURL=dataset.js.map
+export {
+  addSolutionHashesToDataset,
+  buildCaptchaTree,
+  buildDataset,
+  hashDatasetItems,
+  validateDatasetContent
+};

package/dist/captcha/index.js

@@ -1,5 +1,27 @@
-export * from "./captcha.js";
-export * from "./merkle.js";
-export * from "./util.js";
-export * from "./dataset.js";
-//# sourceMappingURL=index.js.map
+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
+};