@prosopo/datasets 3.0.42 → 3.0.48

package/dist/captcha/merkle.js

@@ -2,124 +2,127 @@ 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;
-    }
+  constructor(hash) {
+    this.hash = hash;
+    this.parent = null;
+  }
 }
-export class CaptchaMerkleTree {
-    constructor() {
-        this.leaves = [];
-        this.layers = [];
-    }
-    getRoot() {
-        if (this.root === undefined) {
-            throw new ProsopoError("DATASET.MERKLE_ERROR", {
-                context: {
-                    error: "root undefined",
-                    failedFuncName: this.getRoot.name,
-                },
-            });
+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];
+    return this.root;
+  }
+  build(leaves) {
+    if (this.layers.length) {
+      this.layers = [];
     }
-    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 === undefined) {
-                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);
+    const layerZero = [];
+    for (const leaf of leaves) {
+      const node = new MerkleNode(leaf);
+      this.leaves.push(node);
+      layerZero.push(node.hash);
     }
-    createParent(leftChild, rightChild) {
-        const parent = new MerkleNode(hexHashArray([leftChild.hash, rightChild.hash]));
-        leftChild.parent = parent.hash;
-        rightChild.parent = parent.hash;
-        return parent;
+    this.layers.push(layerZero);
+    this.root = this.buildMerkleTree(this.leaves)[0];
+  }
+  buildMerkleTree(leaves) {
+    const numLeaves = leaves.length;
+    if (numLeaves === 1) {
+      return leaves;
     }
-    proof(leafHash) {
-        const proofTree = [];
-        let layerNum = 0;
-        while (layerNum < this.layers.length - 1) {
-            const layer = this.layers[layerNum];
-            if (layer === undefined) {
-                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)]];
+    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)]];
+  }
 }
-export 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;
+function verifyProof(leaf, proof) {
+  try {
+    if (at(proof, 0).indexOf(leaf) === -1) {
+      return false;
     }
-    catch (err) {
+    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;
+  }
 }
-//# sourceMappingURL=merkle.js.map
+export {
+  CaptchaMerkleTree,
+  verifyProof
+};

package/dist/captcha/util.js

@@ -1,22 +1,23 @@
 import { ProsopoDatasetError, ProsopoEnvError } from "@prosopo/common";
-export 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,
-                },
-            });
+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 },
-        });
+      });
     }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+  } catch (err) {
+    throw new ProsopoEnvError("DATABASE.IMAGE_GET_FAILED", {
+      context: { error: err }
+    });
+  }
 }
-//# sourceMappingURL=util.js.map
+export {
+  downloadImage
+};

package/dist/cjs/captcha/captcha.cjs

@@ -0,0 +1,195 @@
+"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";
+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 }
+    });
+  }
+}
+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 }
+    });
+  }
+}
+function captchaSort(a, b) {
+  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
+      };
+    }
+  );
+}
+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 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 }
+    });
+  }
+}
+function getSolutionValueToHash(solution) {
+  return solution !== void 0 ? solution.sort() : [NO_SOLUTION_VALUE];
+}
+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");
+}
+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");
+  });
+}
+function computeCaptchaSolutionHash(captcha) {
+  return utilCrypto.hexHashArray([
+    captcha.captchaId,
+    captcha.captchaContentId,
+    [...captcha.solution].sort(),
+    captcha.salt
+  ]);
+}
+function computePendingRequestHash(captchaIds, userAccount, salt) {
+  return utilCrypto.hexHashArray([...captchaIds.sort(), userAccount, salt]);
+}
+function parseCaptchaAssets(item, assetsResolver) {
+  return {
+    ...item,
+    data: assetsResolver?.resolveAsset(item.data).getURL() || item.data
+  };
+}
+exports.NO_SOLUTION_VALUE = NO_SOLUTION_VALUE;
+exports.captchaSort = captchaSort;
+exports.compareCaptchaSolutions = compareCaptchaSolutions;
+exports.computeCaptchaHash = computeCaptchaHash;
+exports.computeCaptchaSolutionHash = computeCaptchaSolutionHash;
+exports.computeItemHash = computeItemHash;
+exports.computePendingRequestHash = computePendingRequestHash;
+exports.getSolutionValueToHash = getSolutionValueToHash;
+exports.matchItemsToSolutions = matchItemsToSolutions;
+exports.parseAndSortCaptchaSolutions = parseAndSortCaptchaSolutions;
+exports.parseCaptchaAssets = parseCaptchaAssets;
+exports.parseCaptchaDataset = parseCaptchaDataset;
+exports.sortAndComputeHashes = sortAndComputeHashes;

package/dist/cjs/captcha/dataset.cjs

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const util = require("@prosopo/util");
+const captcha = require("./captcha.cjs");
+const merkle = require("./merkle.cjs");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const logger = common.getLogger("info", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("captcha/dataset.cjs", document.baseURI).href);
+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
+    };
+  });
+}
+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);
+}
+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;
+}
+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");
+  }
+}
+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
+  };
+}
+exports.addSolutionHashesToDataset = addSolutionHashesToDataset;
+exports.buildCaptchaTree = buildCaptchaTree;
+exports.buildDataset = buildDataset;
+exports.hashDatasetItems = hashDatasetItems;
+exports.validateDatasetContent = validateDatasetContent;

package/dist/cjs/captcha/index.cjs

@@ -0,0 +1,27 @@
+"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;