@prosopo/procaptcha 0.2.29 → 0.2.32

package/dist/cjs/index.cjs

@@ -6,13 +6,11 @@ require("./types/index.cjs");
 require("./utils/index.cjs");
 const Manager = require("./modules/Manager.cjs");
 const ProsopoCaptchaApi = require("./modules/ProsopoCaptchaApi.cjs");
-const collector = require("./modules/collector.cjs");
 const manager = require("./types/manager.cjs");
 const utils = require("./utils/utils.cjs");
 exports.Manager = Manager.Manager;
 exports.defaultState = Manager.defaultState;
 exports.getNetwork = Manager.getNetwork;
 exports.ProsopoCaptchaApi = ProsopoCaptchaApi.ProsopoCaptchaApi;
-exports.startCollector = collector.startCollector;
 exports.ProcapchaEventNames = manager.ProcapchaEventNames;
 exports.sleep = utils.sleep;

package/dist/cjs/modules/Manager.cjs

@@ -5,10 +5,10 @@ const Api = require("@polkadot/api/promise/Api");
 const types = require("@prosopo/types");
 const api = require("@prosopo/api");
 const keyring = require("@polkadot/keyring");
-const common = require("@prosopo/common");
 const contract = require("@prosopo/contract");
+const common = require("@prosopo/common");
 const ws = require("@polkadot/rpc-provider/ws");
-const contractInfo = require("@prosopo/captcha-contract/contract-info");
+const captcha = require("../contracts/captcha/dist/contract-info/captcha.cjs");
 const util = require("@prosopo/util");
 const random = require("@polkadot/util-crypto/random");
 const utils = require("../utils/utils.cjs");
@@ -42,9 +42,7 @@ const buildUpdateState = (state, onStateUpdate) => {
 const getNetwork = (config) => {
   const network = config.networks[config.defaultNetwork];
   if (!network) {
-    throw new common.ProsopoEnvError("DEVELOPER.NETWORK_NOT_FOUND", {
-      context: { error: `No network found for environment ${config.defaultEnvironment}` }
-    });
+    throw new Error(`No network found for environment ${config.defaultEnvironment}`);
   }
   return network;
 };
@@ -59,14 +57,12 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       onError: alertError,
       onHuman: (output) => {
         console.log("onHuman event triggered", output);
-        updateState({ sendData: !state.sendData });
       },
       onExtensionNotFound: () => {
         alert("No extension found");
       },
       onFailed: () => {
         alert("Captcha challenge failed. Please try again");
-        updateState({ sendData: !state.sendData });
       },
       onExpired: () => {
         alert("Completed challenge has expired, please try again");
@@ -76,7 +72,6 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       },
       onOpen: () => {
         console.log("onOpen event triggered");
-        updateState({ sendData: !state.sendData });
       },
       onClose: () => {
         console.log("onClose event triggered");
@@ -151,12 +146,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       if (providerUrlFromStorage) {
         providerApi = await loadProviderApi(providerUrlFromStorage);
         try {
-          const verifyDappUserResponse = await providerApi.verifyDappUser(
-            getDappAccount(),
-            account.account.address,
-            void 0,
-            configOptional.challengeValidLength
-          );
+          const verifyDappUserResponse = await providerApi.verifyDappUser(account.account.address);
           if (verifyDappUserResponse.solutionApproved) {
             updateState({ isHuman: true, loading: false });
             events.onHuman({
@@ -193,9 +183,9 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       const challenge = await captchaApi.getCaptchaChallenge();
       console.log("challenge", challenge);
       if (challenge.captchas.length <= 0) {
-        throw new common.ProsopoApiError("DEVELOPER.PROVIDER_NO_CAPTCHA");
+        throw new Error("No captchas returned from provider");
       }
-      const timeMillis = challenge.captchas.map((captcha) => captcha.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b);
+      const timeMillis = challenge.captchas.map((captcha2) => captcha2.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b);
       const timeout = setTimeout(() => {
         console.log("challenge expired after " + timeMillis + "ms");
         events.onChallengeExpired();
@@ -216,18 +206,16 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       console.log("submitting solutions");
       clearTimeout();
       if (!state.challenge) {
-        throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-          context: { error: "Cannot submit, no Captcha found in state" }
-        });
+        throw new Error("cannot submit, no challenge found");
       }
       updateState({ showModal: false });
       const challenge = state.challenge;
       const salt = random.randomAsHex();
-      const captchaSolution = state.challenge.captchas.map((captcha, index) => {
+      const captchaSolution = state.challenge.captchas.map((captcha2, index) => {
         const solution = util.at(state.solutions, index);
         return {
-          captchaId: captcha.captcha.captchaId,
-          captchaContentId: captcha.captcha.captchaContentId,
+          captchaId: captcha2.captcha.captchaId,
+          captchaContentId: captcha2.captcha.captchaContentId,
           salt,
           solution
         };
@@ -237,9 +225,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       const signer = account.extension.signer;
       const first = util.at(challenge.captchas, 0);
       if (!first.captcha.datasetId) {
-        throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_ID", {
-          context: { error: "No datasetId set for challenge" }
-        });
+        throw new Error("No datasetId set for challenge");
       }
       const captchaApi = getCaptchaApi();
       const submission = await captchaApi.submitCaptchaSolution(
@@ -280,14 +266,10 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
   };
   const select = (hash) => {
     if (!state.challenge) {
-      throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-        context: { error: "Cannot select, no Captcha found in state" }
-      });
+      throw new Error("cannot select, no challenge found");
     }
     if (state.index >= state.challenge.captchas.length || state.index < 0) {
-      throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-        context: { error: "Cannot select, index is out of range for this Captcha" }
-      });
+      throw new Error("cannot select, round index out of range");
     }
     const index = state.index;
     const solutions = state.solutions;
@@ -303,14 +285,10 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
   };
   const nextRound = () => {
     if (!state.challenge) {
-      throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-        context: { error: "Cannot select, no Captcha found in state" }
-      });
+      throw new Error("cannot proceed to next round, no challenge found");
     }
     if (state.index + 1 >= state.challenge.captchas.length) {
-      throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-        context: { error: "Cannot select, index is out of range for this Captcha" }
-      });
+      throw new Error("cannot proceed to next round, already at last round");
     }
     console.log("proceeding to next round");
     updateState({ index: state.index + 1 });
@@ -356,16 +334,14 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
   };
   const getCaptchaApi = () => {
     if (!state.captchaApi) {
-      throw new common.ProsopoApiError("API.UNKNOWN", { context: { error: "Captcha api not set", state } });
+      throw new Error("Captcha api not set");
     }
     return state.captchaApi;
   };
   const loadAccount = async () => {
     const config = getConfig();
     if (!config.web2 && !config.userAccountAddress) {
-      throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
-        context: { error: "Account address has not been set for web3 mode" }
-      });
+      throw new Error("Account address has not been set for web3 mode");
     }
     const ext = config.web2 ? new ExtensionWeb2() : new ExtensionWeb3();
     const account = await ext.getAccount(config);
@@ -376,7 +352,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
   };
   const getAccount = () => {
     if (!state.account) {
-      throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", { context: { error: "Account not loaded" } });
+      throw new Error("Account not loaded");
     }
     const account = state.account;
     return account;
@@ -390,7 +366,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
   };
   const getBlockNumber = () => {
     if (!state.blockNumber) {
-      throw new common.ProsopoContractError("CAPTCHA.INVALID_BLOCK_NO", { context: { error: "Block number not found" } });
+      throw new Error("Account not loaded");
     }
     const blockNumber = state.blockNumber;
     return blockNumber;
@@ -403,29 +379,19 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     const keyring$1 = new keyring.Keyring({ type, ss58Format: api2.registry.chainSS58 });
     return new contract.ProsopoCaptchaContract(
       api2,
-      JSON.parse(contractInfo.ContractAbi),
+      JSON.parse(captcha.ContractAbi),
       network.contract.address,
       "prosopo",
       0,
       keyring$1.addFromAddress(getAccount().account.address)
     );
   };
-  const exportData = async (events2) => {
-    var _a;
-    const providerUrl = storage.getProviderUrl() || ((_a = state.captchaApi) == null ? void 0 : _a.provider.provider.url.toString());
-    if (!providerUrl) {
-      return;
-    }
-    const providerApi = await loadProviderApi(providerUrl);
-    await providerApi.submitUserEvents(events2, getAccount().account.address);
-  };
   return {
     start,
     cancel,
     submit,
     select,
-    nextRound,
-    exportData
+    nextRound
   };
 }
 exports.Manager = Manager;

package/dist/cjs/modules/ProsopoCaptchaApi.cjs

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const datasets = require("@prosopo/datasets");
+require("../packages/datasets/dist/index.cjs");
+const handlers = require("../api/handlers.cjs");
 const common = require("@prosopo/common");
 const util = require("@prosopo/util");
 const string = require("@polkadot/util/string");
+const merkle = require("../packages/datasets/dist/captcha/merkle.cjs");
+const captcha = require("../packages/datasets/dist/captcha/captcha.cjs");
 class ProsopoCaptchaApi {
   constructor(userAccount, contract, provider, providerApi, web2, dappAccount) {
     this.userAccount = userAccount;
@@ -18,8 +21,8 @@ class ProsopoCaptchaApi {
       const captchaChallenge = await this.providerApi.getCaptchaChallenge(this.userAccount, this.provider);
       this.verifyCaptchaChallengeContent(this.provider, captchaChallenge);
       return captchaChallenge;
-    } catch (error) {
-      throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", { context: { error } });
+    } catch (e) {
+      throw new common.ProsopoEnvError(e);
     }
   }
   verifyCaptchaChallengeContent(provider, captchaChallenge) {
@@ -34,7 +37,7 @@ class ProsopoCaptchaApi {
       if (!verifyCaptchaData(captchaWithProof)) {
         throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
       }
-      if (!datasets.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
+      if (!merkle.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
         throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
       }
     }
@@ -42,8 +45,8 @@ class ProsopoCaptchaApi {
     return;
   }
   async submitCaptchaSolution(signer, requestHash, datasetId, solutions, salt) {
-    const tree = new datasets.CaptchaMerkleTree();
-    const captchasHashed = solutions.map((captcha) => datasets.computeCaptchaSolutionHash(captcha));
+    const tree = new merkle.CaptchaMerkleTree();
+    const captchasHashed = solutions.map((captcha$1) => captcha.computeCaptchaSolutionHash(captcha$1));
     tree.build(captchasHashed);
     const commitmentId = tree.root.hash;
     console.log("solveCaptchaChallenge commitmentId", commitmentId);
@@ -51,9 +54,7 @@ class ProsopoCaptchaApi {
     let signature = void 0;
     if (this.web2) {
       if (!signer || !signer.signRaw) {
-        throw new common.ProsopoEnvError("GENERAL.CANT_FIND_KEYRINGPAIR", {
-          context: { error: "Signer is not defined, cannot sign message to prove account ownership" }
-        });
+        throw new Error("Signer is not defined, cannot sign message to prove account ownership");
       }
       const signed = await signer.signRaw({
         address: this.userAccount,
@@ -71,22 +72,22 @@ class ProsopoCaptchaApi {
         salt,
         signature
       );
-    } catch (error) {
-      throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", { context: { error } });
+    } catch (err) {
+      throw new handlers.ProsopoApiError(err);
     }
     return [result, commitmentId, tx];
   }
 }
 async function verifyCaptchaData(captchaWithProof) {
-  const captcha = captchaWithProof.captcha;
+  const captcha$1 = captchaWithProof.captcha;
   const proof = captchaWithProof.proof;
-  if (!(await Promise.all(captcha.items.map(async (item) => (await datasets.computeItemHash(item)).hash === item.hash))).every(
+  if (!(await Promise.all(captcha$1.items.map(async (item) => (await captcha.computeItemHash(item)).hash === item.hash))).every(
     (hash) => hash === true
   )) {
     return false;
   }
-  const captchaHash = datasets.computeCaptchaHash(captcha, false, false, false);
-  if (captchaHash !== captcha.captchaContentId) {
+  const captchaHash = captcha.computeCaptchaHash(captcha$1, false, false, false);
+  if (captchaHash !== captcha$1.captchaContentId) {
     return false;
   }
   return util.at(proof, 0).indexOf(captchaHash) !== -1;

package/dist/cjs/modules/canvas.cjs

@@ -366,8 +366,9 @@ function picassoCanvas(roundNumber, seed, params) {
       }
     }
     return x64hash128(canvasElt.toDataURL(), seed);
-  } catch (error) {
-    throw new common.ProsopoError("WIDGET.CANVAS", { context: { error } });
+  } catch (e) {
+    console.log(e);
+    throw new common.ProsopoEnvError(e);
   }
 }
 exports.picassoCanvas = picassoCanvas;

package/dist/cjs/modules/index.cjs

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const Manager = require("./Manager.cjs");
 const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
-const collector = require("./collector.cjs");
 exports.Manager = Manager.Manager;
 exports.defaultState = Manager.defaultState;
 exports.getNetwork = Manager.getNetwork;
 exports.ProsopoCaptchaApi = ProsopoCaptchaApi.ProsopoCaptchaApi;
-exports.startCollector = collector.startCollector;

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const common = require("@prosopo/common");
+const util = require("@prosopo/util");
+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.ProsopoEnvError(err);
+  }
+}
+function parseAndSortCaptchaSolutions(captchaJSON) {
+  try {
+    return types.CaptchaSolutionArraySchema.parse(captchaJSON).map((captcha) => ({
+      ...captcha,
+      solution: captcha.solution.sort()
+    }));
+  } catch (err) {
+    throw new common.ProsopoEnvError(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, stored) {
+  if (received.length && stored.length && received.length === stored.length) {
+    const hashes = sortAndComputeHashes(received, stored);
+    return hashes.every(({ hash, captchaId }) => hash === captchaId);
+  }
+  return false;
+}
+function computeCaptchaHash(captcha, includeSolution = false, includeSalt = false, sortItemHashes) {
+  try {
+    const itemHashes = captcha.items.map((item, index) => {
+      if (item.hash) {
+        return item.hash;
+      } else {
+        throw new common.ProsopoEnvError("CAPTCHA.MISSING_ITEM_HASH", computeCaptchaHash.name, void 0, index);
+      }
+    });
+    return common.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.ProsopoEnvError(err);
+  }
+}
+function getSolutionValueToHash(solution) {
+  return solution !== void 0 ? solution.sort() : [NO_SOLUTION_VALUE];
+}
+async function computeItemHash(item) {
+  if (item.type === "text") {
+    return { ...item, hash: common.hexHash(item.data) };
+  } else if (item.type === "image") {
+    return { ...item, hash: common.hexHash(await util$1.downloadImage(item.data)) };
+  } else {
+    throw new common.ProsopoEnvError("CAPTCHA.INVALID_ITEM_FORMAT");
+  }
+}
+function matchItemsToSolutions(solutions, items) {
+  if (!items) {
+    return [];
+  }
+  return solutions.map((solution) => {
+    if (typeof solution === "string") {
+      if (!(items == null ? void 0 : items.some((item2) => item2.hash === solution))) {
+        throw new common.ProsopoEnvError("CAPTCHA.INVALID_ITEM_HASH");
+      }
+      return solution;
+    }
+    const item = util.at(items, solution);
+    const hash = item.hash;
+    return hash;
+  });
+}
+function computeCaptchaSolutionHash(captcha) {
+  return common.hexHashArray([captcha.captchaId, captcha.captchaContentId, [...captcha.solution].sort(), captcha.salt]);
+}
+function computePendingRequestHash(captchaIds, userAccount, salt) {
+  return common.hexHashArray([...captchaIds.sort(), userAccount, salt]);
+}
+function parseCaptchaAssets(item, assetsResolver) {
+  return { ...item, path: (assetsResolver == null ? void 0 : 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/packages/datasets/dist/captcha/dataset.cjs

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

@@ -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;