@prosopo/datasets 3.0.42 → 3.0.43

package/dist/cjs/captcha/merkle.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const util = require("@prosopo/util");
+const utilCrypto = require("@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 common.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 common.ProsopoError("DEVELOPER.GENERAL", {
+          context: { 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(
+      utilCrypto.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 common.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 = 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 = utilCrypto.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 = utilCrypto.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/captcha/util.cjs

@@ -0,0 +1,23 @@
+"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 common.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 common.ProsopoEnvError("DATABASE.IMAGE_GET_FAILED", {
+      context: { error: err }
+    });
+  }
+}
+exports.downloadImage = downloadImage;

package/dist/cjs/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./captcha/index.cjs");
+const captchas = require("./tests/mocks/data/captchas.cjs");
+const captcha = require("./captcha/captcha.cjs");
+const merkle = require("./captcha/merkle.cjs");
+const util = require("./captcha/util.cjs");
+const dataset = require("./captcha/dataset.cjs");
+exports.datasetWithIndexSolutions = captchas.datasetWithIndexSolutions;
+exports.datasetWithSolutionHashes = captchas.datasetWithSolutionHashes;
+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;