@prosopo/procaptcha 0.2.13 → 0.2.14

package/dist/cjs/packages/datasets/dist/captcha/dataset.cjs

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const merkle = require("./merkle.cjs");
-const common = require("@prosopo/common");
-const util = require("@prosopo/util");
-const captcha = require("./captcha.cjs");
-const logger = common.getLogger(`Info`, `dataset.ts`);
-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);
-    } else {
-      return false;
-    }
-  });
-  return hashes.every((hash) => hash);
-}
-async function buildDataset(datasetRaw) {
-  var _a, _b;
-  logger.info(`Adding solution hashes to dataset`);
-  const dataset = await addSolutionHashesToDataset(datasetRaw);
-  logger.info(`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) => {
-    var _a2, _b2;
-    return {
-      ...captcha2,
-      captchaId: util.at(solutionTree.leaves, index).hash,
-      captchaContentId: util.at(contentTree.leaves, index).hash,
-      datasetId: (_a2 = solutionTree.root) == null ? void 0 : _a2.hash,
-      datasetContentId: (_b2 = contentTree.root) == null ? void 0 : _b2.hash
-    };
-  });
-  dataset.solutionTree = solutionTree.layers;
-  dataset.contentTree = contentTree.layers;
-  dataset.datasetId = (_a = solutionTree.root) == null ? void 0 : _a.hash;
-  dataset.datasetContentId = (_b = contentTree.root) == null ? void 0 : _b.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");
-  }
-}
-async function addSolutionHashesToDataset(datasetRaw) {
-  const captchaPromises = datasetRaw.captchas.map(async (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) }
-    };
-  });
-  const captchas = await Promise.all(captchaPromises);
-  return {
-    ...datasetRaw,
-    captchas
-  };
-}
-exports.addSolutionHashesToDataset = addSolutionHashesToDataset;
-exports.buildCaptchaTree = buildCaptchaTree;
-exports.buildDataset = buildDataset;
-exports.hashDatasetItems = hashDatasetItems;
-exports.validateDatasetContent = validateDatasetContent;

package/dist/cjs/packages/datasets/dist/captcha/index.cjs

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

package/dist/cjs/packages/datasets/dist/captcha/merkle.cjs

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@prosopo/util");
-const common = require("@prosopo/common");
-class MerkleNode {
-  constructor(hash) {
-    this.hash = hash;
-    this.parent = null;
-  }
-}
-class CaptchaMerkleTree {
-  constructor() {
-    this.leaves = [];
-    this.layers = [];
-  }
-  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 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(common.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 Error("layer undefined");
-      }
-      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 = common.hexHashArray(pair);
-    }
-    const last = util.at(this.layers, this.layers.length - 1);
-    return [...proofTree, [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 = common.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;
-  }
-}
-exports.CaptchaMerkleTree = CaptchaMerkleTree;
-exports.verifyProof = verifyProof;

package/dist/cjs/packages/datasets/dist/captcha/util.cjs

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-async function downloadImage(url) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Network response was not ok, status: ${response.status}`);
-    }
-    const buffer = await response.arrayBuffer();
-    return new Uint8Array(buffer);
-  } catch (error) {
-    throw new common.ProsopoEnvError(error);
-  }
-}
-exports.downloadImage = downloadImage;

package/dist/cjs/packages/datasets/dist/index.cjs

@@ -1,2 +0,0 @@
-"use strict";
-require("./captcha/index.cjs");