@prosopo/datasets 3.0.8 → 3.0.10

package/dist/captcha/merkle.js

@@ -1,124 +1,127 @@
 import { ProsopoError, hexHashArray } from "@prosopo/common";
 import { at } from "@prosopo/util";
 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/index.js

@@ -1,3 +1,31 @@
-export * from "./captcha/index.js";
-export { datasetWithSolutionHashes, datasetWithIndexSolutions, } from "./tests/mocks/data/captchas.js";
-//# sourceMappingURL=index.js.map
+import "./captcha/index.js";
+import { datasetWithIndexSolutions, datasetWithSolutionHashes } from "./tests/mocks/data/captchas.js";
+import { NO_SOLUTION_VALUE, captchaSort, compareCaptchaSolutions, computeCaptchaHash, computeCaptchaSolutionHash, computeItemHash, computePendingRequestHash, getSolutionValueToHash, matchItemsToSolutions, parseAndSortCaptchaSolutions, parseCaptchaAssets, parseCaptchaDataset, sortAndComputeHashes } from "./captcha/captcha.js";
+import { CaptchaMerkleTree, verifyProof } from "./captcha/merkle.js";
+import { downloadImage } from "./captcha/util.js";
+import { addSolutionHashesToDataset, buildCaptchaTree, buildDataset, hashDatasetItems, validateDatasetContent } from "./captcha/dataset.js";
+export {
+  CaptchaMerkleTree,
+  NO_SOLUTION_VALUE,
+  addSolutionHashesToDataset,
+  buildCaptchaTree,
+  buildDataset,
+  captchaSort,
+  compareCaptchaSolutions,
+  computeCaptchaHash,
+  computeCaptchaSolutionHash,
+  computeItemHash,
+  computePendingRequestHash,
+  datasetWithIndexSolutions,
+  datasetWithSolutionHashes,
+  downloadImage,
+  getSolutionValueToHash,
+  hashDatasetItems,
+  matchItemsToSolutions,
+  parseAndSortCaptchaSolutions,
+  parseCaptchaAssets,
+  parseCaptchaDataset,
+  sortAndComputeHashes,
+  validateDatasetContent,
+  verifyProof
+};