@prosopo/procaptcha 1.0.2 → 2.0.1

package/dist/cjs/modules/Manager.cjs

@@ -1,17 +1,14 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const Api = require("@polkadot/api/promise/Api");
+const utilCrypto = require("@polkadot/util-crypto");
+const random = require("@polkadot/util-crypto/random");
 require("../account/dist/index.cjs");
-const keyring = require("@polkadot/keyring");
-const contract = require("@prosopo/contract");
-const common = require("@prosopo/common");
 const api = require("@prosopo/api");
-const ws = require("@polkadot/rpc-provider/ws");
-const contractInfo = require("@prosopo/captcha-contract/contract-info");
-const util = require("@prosopo/util");
+const common = require("@prosopo/common");
+const loadBalancer = require("@prosopo/load-balancer");
 const procaptchaCommon = require("@prosopo/procaptcha-common");
-const random = require("@polkadot/util-crypto/random");
+const types = require("@prosopo/types");
+const util = require("@prosopo/util");
 const utils = require("../utils/utils.cjs");
 const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
 const storage = require("./storage.cjs");
@@ -35,11 +32,30 @@ 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}` }
+      context: {
+        error: `No network found for environment ${config.defaultEnvironment}`
+      }
     });
   }
   return network;
 };
+const getRandomActiveProvider = (config) => {
+  const randomIntBetween = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
+  const PROVIDERS = loadBalancer.loadBalancer(config.defaultEnvironment);
+  const randomProvderObj = util.at(
+    PROVIDERS,
+    randomIntBetween(0, PROVIDERS.length - 1)
+  );
+  return {
+    providerAccount: randomProvderObj.address,
+    provider: {
+      url: randomProvderObj.url,
+      datasetId: randomProvderObj.datasetId,
+      datasetIdContent: randomProvderObj.datasetIdContent
+    },
+    blockNumber: 0
+  };
+};
 function Manager(configOptional, state, onStateUpdate, callbacks) {
   const events = procaptchaCommon.getDefaultEvents(onStateUpdate, state, callbacks);
   const dispatchErrorEvent = (err) => {
@@ -75,87 +91,33 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       if (state.isHuman) {
         return;
       }
+      await utilCrypto.cryptoWaitReady();
       resetState();
       updateState({ loading: true });
       const config = getConfig();
       updateState({ dappAccount: config.account.address });
       await utils.sleep(100);
       const account = await loadAccount();
-      const contract$1 = await loadContract();
-      let contractIsHuman = false;
-      try {
-        contractIsHuman = (await contract$1.query.dappOperatorIsHumanUser(account.account.address, config.solutionThreshold)).value.unwrap().unwrap();
-      } catch (error) {
-        console.warn(error);
-      }
-      if (contractIsHuman) {
-        updateState({ isHuman: true, loading: false });
-        events.onHuman(
-          types.encodeProcaptchaOutput({
-            [types.ApiParams.user]: account.account.address,
-            [types.ApiParams.dapp]: getDappAccount(),
-            [types.ApiParams.blockNumber]: getBlockNumber()
-          })
-        );
-        setValidChallengeTimeout();
-        return;
-      }
-      const procaptchaStorage = storage.getProcaptchaStorage();
-      let providerApi;
-      if (procaptchaStorage.providerUrl && procaptchaStorage.blockNumber) {
-        providerApi = await loadProviderApi(procaptchaStorage.providerUrl);
-        try {
-          const extension = getExtension(account);
-          if (!extension || !extension.signer || !extension.signer.signRaw) {
-            throw new common.ProsopoEnvError("ACCOUNT.NO_POLKADOT_EXTENSION");
-          }
-          const signRaw = extension.signer.signRaw;
-          const { signature } = await signRaw({
-            address: account.account.address,
-            data: procaptchaStorage.blockNumber.toString(),
-            type: "bytes"
-          });
-          const token = types.encodeProcaptchaOutput({
-            [types.ApiParams.user]: account.account.address,
-            [types.ApiParams.dapp]: getDappAccount(),
-            [types.ApiParams.blockNumber]: procaptchaStorage.blockNumber
-          });
-          const verifyDappUserResponse = await providerApi.verifyUser(
-            token,
-            signature,
-            configOptional.captchas.image.cachedTimeout
-          );
-          if (verifyDappUserResponse.verified) {
-            updateState({ isHuman: true, loading: false });
-            const output = {
-              [types.ApiParams.providerUrl]: procaptchaStorage.providerUrl,
-              [types.ApiParams.user]: account.account.address,
-              [types.ApiParams.dapp]: getDappAccount(),
-              [types.ApiParams.commitmentId]: util.hashToHex(verifyDappUserResponse.commitmentId),
-              [types.ApiParams.blockNumber]: verifyDappUserResponse.blockNumber
-            };
-            events.onHuman(types.encodeProcaptchaOutput(output));
-            setValidChallengeTimeout();
-            return;
-          }
-        } catch (err) {
-          console.error("Error contacting provider from storage", procaptchaStorage.providerUrl);
-        }
-      }
-      const getRandomProviderResponse = await contract.wrapQuery(
-        contract$1.query.getRandomActiveProvider,
-        contract$1.query
-      )(account.account.address, getDappAccount());
-      const blockNumber = parseInt(getRandomProviderResponse.blockNumber.toString());
-      const providerUrl = common.trimProviderUrl(getRandomProviderResponse.provider.url.toString());
-      providerApi = await loadProviderApi(providerUrl);
-      const captchaApi = await loadCaptchaApi(contract$1, getRandomProviderResponse, providerApi);
+      const contract = getNetwork(config).contract.address;
+      const getRandomProviderResponse = getRandomActiveProvider(getConfig());
+      const blockNumber = getRandomProviderResponse.blockNumber;
+      const providerUrl = getRandomProviderResponse.provider.url;
+      const providerApi = await loadProviderApi(providerUrl);
+      const captchaApi = new ProsopoCaptchaApi.ProsopoCaptchaApi(
+        account.account.address,
+        contract,
+        getRandomProviderResponse,
+        providerApi,
+        config.web2,
+        config.account.address || ""
+      );
+      updateState({ captchaApi });
       const challenge = await captchaApi.getCaptchaChallenge();
       if (challenge.captchas.length <= 0) {
         throw new common.ProsopoDatasetError("DEVELOPER.PROVIDER_NO_CAPTCHA");
       }
       const timeMillis = challenge.captchas.map(
-        (captcha) => captcha.captcha.timeLimitMs || config.captchas.image.challengeTimeout
+        (captcha) => captcha.timeLimitMs || config.captchas.image.challengeTimeout
       ).reduce((a, b) => a + b);
       const timeout = setTimeout(() => {
         events.onChallengeExpired();
@@ -186,8 +148,8 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         (captcha, index) => {
           const solution = util.at(state.solutions, index);
           return {
-            captchaId: captcha.captcha.captchaId,
-            captchaContentId: captcha.captcha.captchaContentId,
+            captchaId: captcha.captchaId,
+            captchaContentId: captcha.captchaContentId,
             salt,
             solution
           };
@@ -197,18 +159,24 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       const blockNumber = getBlockNumber();
       const signer = getExtension(account).signer;
       const first = util.at(challenge.captchas, 0);
-      if (!first.captcha.datasetId) {
+      if (!first.datasetId) {
         throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_ID", {
           context: { error: "No datasetId set for challenge" }
         });
       }
-      const captchaApi = getCaptchaApi();
+      const captchaApi = state.captchaApi;
+      if (!captchaApi) {
+        throw new common.ProsopoError("CAPTCHA.INVALID_TOKEN", {
+          context: { error: "No Captcha API found in state" }
+        });
+      }
       const submission = await captchaApi.submitCaptchaSolution(
         signer,
         challenge.requestHash,
-        first.captcha.datasetId,
         captchaSolution,
-        salt
+        salt,
+        challenge.timestamp,
+        challenge.signature.provider.timestamp
       );
       const isHuman = submission[0].verified;
       if (!isHuman) {
@@ -220,15 +188,25 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         loading: false
       });
       if (state.isHuman) {
-        const providerUrl = common.trimProviderUrl(captchaApi.provider.provider.url.toString());
-        storage.setProcaptchaStorage({ ...storage.getProcaptchaStorage(), providerUrl, blockNumber });
+        const providerUrl = captchaApi.provider.provider.url;
+        storage.setProcaptchaStorage({
+          ...storage.getProcaptchaStorage(),
+          providerUrl,
+          blockNumber
+        });
         events.onHuman(
           types.encodeProcaptchaOutput({
             [types.ApiParams.providerUrl]: providerUrl,
             [types.ApiParams.user]: account.account.address,
             [types.ApiParams.dapp]: getDappAccount(),
             [types.ApiParams.commitmentId]: util.hashToHex(submission[1]),
-            [types.ApiParams.blockNumber]: blockNumber
+            [types.ApiParams.blockNumber]: blockNumber,
+            [types.ApiParams.timestamp]: challenge.timestamp,
+            [types.ApiParams.signature]: {
+              [types.ApiParams.provider]: {
+                [types.ApiParams.timestamp]: challenge.signature.provider.timestamp
+              }
+            }
           })
         );
         setValidChallengeTimeout();
@@ -248,7 +226,9 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
     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" }
+        context: {
+          error: "Cannot select, index is out of range for this Captcha"
+        }
       });
     }
     const index = state.index;
@@ -269,24 +249,13 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
     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" }
+        context: {
+          error: "Cannot select, index is out of range for this Captcha"
+        }
       });
     }
     updateState({ index: state.index + 1 });
   };
-  const loadCaptchaApi = async (contract2, provider, providerApi) => {
-    const config = getConfig();
-    const captchaApi = new ProsopoCaptchaApi.ProsopoCaptchaApi(
-      getAccount().account.address,
-      contract2,
-      provider,
-      providerApi,
-      config.web2,
-      getDappAccount()
-    );
-    updateState({ captchaApi });
-    return getCaptchaApi();
-  };
   const loadProviderApi = async (providerUrl) => {
     const config = getConfig();
     const network = getNetwork(config);
@@ -311,14 +280,6 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     clearTimeout();
     updateState(defaultState());
   };
-  const getCaptchaApi = () => {
-    if (!state.captchaApi) {
-      throw new common.ProsopoEnvError("API.UNKNOWN", {
-        context: { error: "Captcha api not set", state }
-      });
-    }
-    return state.captchaApi;
-  };
   const loadAccount = async () => {
     const config = getConfig();
     if (!config.web2 && !config.userAccountAddress) {
@@ -334,7 +295,9 @@ 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 common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
+        context: { error: "Account not loaded" }
+      });
     }
     const account = state.account;
     return account;
@@ -347,72 +310,24 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     return dappAccount;
   };
   const getBlockNumber = () => {
-    if (!state.blockNumber) {
-      throw new common.ProsopoContractError("CAPTCHA.INVALID_BLOCK_NO", { context: { error: "Block number not found" } });
-    }
-    const blockNumber = state.blockNumber;
+    const blockNumber = state.blockNumber || 0;
     return blockNumber;
   };
-  const getExtension = (account) => {
-    account = account || getAccount();
+  const getExtension = (possiblyAccount) => {
+    const account = possiblyAccount || getAccount();
     if (!account.extension) {
-      throw new common.ProsopoEnvError("ACCOUNT.NO_POLKADOT_EXTENSION", { context: { error: "Extension not loaded" } });
+      throw new common.ProsopoEnvError("ACCOUNT.NO_POLKADOT_EXTENSION", {
+        context: { error: "Extension not loaded" }
+      });
     }
     return account.extension;
   };
-  const loadContract = async () => {
-    const config = getConfig();
-    const network = getNetwork(config);
-    const api2 = await Api.ApiPromise.create({
-      provider: new ws.WsProvider(network.endpoint),
-      initWasm: false,
-      noInitWarn: true
-    });
-    const type = "sr25519";
-    const keyring$1 = new keyring.Keyring({ type, ss58Format: api2.registry.chainSS58 });
-    return new contract.ProsopoCaptchaContract(
-      api2,
-      JSON.parse(contractInfo.ContractAbi),
-      network.contract.address,
-      "prosopo",
-      0,
-      keyring$1.addFromAddress(getAccount().account.address)
-    );
-  };
-  const exportData = async (events2) => {
-    const procaptchaStorage = storage.getProcaptchaStorage();
-    const providerUrlFromStorage = procaptchaStorage.providerUrl;
-    let providerApi;
-    if (providerUrlFromStorage) {
-      providerApi = await loadProviderApi(providerUrlFromStorage);
-    } else {
-      const contract$1 = await loadContract();
-      const getRandomProviderResponse = await contract.wrapQuery(
-        contract$1.query.getRandomActiveProvider,
-        contract$1.query
-      )(getAccount().account.address, getDappAccount());
-      const providerUrl2 = common.trimProviderUrl(getRandomProviderResponse.provider.url.toString());
-      providerApi = await loadProviderApi(providerUrl2);
-    }
-    const providerUrl = storage.getProcaptchaStorage().providerUrl || state.captchaApi?.provider.provider.url.toString();
-    if (!providerUrl) {
-      return;
-    }
-    let account = "";
-    try {
-      account = getAccount().account.address;
-    } catch (e) {
-      console.error(e);
-    }
-    await providerApi.submitUserEvents(events2, account);
-  };
   return {
     start,
     cancel,
     submit,
     select,
-    nextRound,
-    exportData
+    nextRound
   };
 }
 exports.Manager = Manager;

package/dist/cjs/modules/ProsopoCaptchaApi.cjs

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const datasets = require("@prosopo/datasets");
-const common = require("@prosopo/common");
-const util = require("@prosopo/util");
 const string = require("@polkadot/util/string");
+const common = require("@prosopo/common");
+const datasets = require("@prosopo/datasets");
 class ProsopoCaptchaApi {
   constructor(userAccount, contract, provider, providerApi, web2, dappAccount) {
     this.userAccount = userAccount;
@@ -18,47 +17,43 @@ class ProsopoCaptchaApi {
   }
   async getCaptchaChallenge() {
     try {
-      const captchaChallenge = await this.providerApi.getCaptchaChallenge(this.userAccount, this.provider);
-      this.verifyCaptchaChallengeContent(this.provider, captchaChallenge);
-      captchaChallenge.captchas.forEach((captcha) => {
-        captcha.captcha.items.forEach((item) => {
+      const captchaChallenge = await this.providerApi.getCaptchaChallenge(
+        this.userAccount,
+        this.provider
+      );
+      for (const captcha of captchaChallenge.captchas) {
+        for (const item of captcha.items) {
           if (item.data) {
             item.data = item.data.replace(/^http(s)*:\/\//, "//");
           }
-        });
-      });
+        }
+      }
       return captchaChallenge;
     } catch (error) {
-      throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", { context: { error } });
-    }
-  }
-  verifyCaptchaChallengeContent(provider, captchaChallenge) {
-    const first = util.at(captchaChallenge.captchas, 0);
-    const proofLength = first.proof.length;
-    const last = util.at(first.proof, proofLength - 1);
-    if (provider.provider.datasetIdContent.toString() !== util.at(last, 0)) {
-      throw new common.ProsopoEnvError("CAPTCHA.INVALID_DATASET_CONTENT_ID");
-    }
-    for (const captchaWithProof of captchaChallenge.captchas) {
-      if (!verifyCaptchaData(captchaWithProof)) {
-        throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
-      }
-      if (!datasets.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
-        throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
-      }
+      throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", {
+        context: { error }
+      });
     }
-    return;
   }
-  async submitCaptchaSolution(signer, requestHash, datasetId, solutions, salt) {
+  async submitCaptchaSolution(signer, requestHash, solutions, salt, timestamp, providerTimestampSignature) {
     const tree = new datasets.CaptchaMerkleTree();
-    const captchasHashed = solutions.map((captcha) => datasets.computeCaptchaSolutionHash(captcha));
+    const captchasHashed = solutions.map(
+      (captcha) => datasets.computeCaptchaSolutionHash(captcha)
+    );
     tree.build(captchasHashed);
+    if (!tree.root) {
+      throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", {
+        context: { error: "Merkle tree root is undefined" }
+      });
+    }
     const commitmentId = tree.root.hash;
     const tx = void 0;
-    let signature = void 0;
+    let userRequestHashSignature = void 0;
     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" }
+        context: {
+          error: "Signer is not defined, cannot sign message to prove account ownership"
+        }
       });
     }
     let result;
@@ -67,34 +62,24 @@ class ProsopoCaptchaApi {
       data: string.stringToHex(requestHash),
       type: "bytes"
     });
-    signature = signed.signature;
+    userRequestHashSignature = signed.signature;
     try {
       result = await this.providerApi.submitCaptchaSolution(
         solutions,
         requestHash,
-        this.contract.pair.address,
+        this.userAccount,
         salt,
-        signature
+        timestamp,
+        providerTimestampSignature,
+        userRequestHashSignature
       );
     } catch (error) {
-      throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", { context: { error } });
+      throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE", {
+        context: { error }
+      });
     }
     return [result, commitmentId, tx];
   }
 }
-async function verifyCaptchaData(captchaWithProof) {
-  const captcha = captchaWithProof.captcha;
-  const proof = captchaWithProof.proof;
-  if (!(await Promise.all(captcha.items.map(async (item) => (await datasets.computeItemHash(item)).hash === item.hash))).every(
-    (hash) => hash === true
-  )) {
-    return false;
-  }
-  const captchaHash = datasets.computeCaptchaHash(captcha, false, false, false);
-  if (captchaHash !== captcha.captchaContentId) {
-    return false;
-  }
-  return util.at(proof, 0).indexOf(captchaHash) !== -1;
-}
 exports.ProsopoCaptchaApi = ProsopoCaptchaApi;
 exports.default = ProsopoCaptchaApi;

package/dist/cjs/modules/collector.cjs

@@ -29,19 +29,43 @@ const logKeyboardEvent = (event, setKeyboardEvent) => {
 };
 const logTouchEvent = (event, setTouchEvent) => {
   for (const touch of Array.from(event.touches)) {
-    storeLog({ x: touch.clientX, y: touch.clientY, timestamp: event.timeStamp }, setTouchEvent);
+    storeLog(
+      { x: touch.clientX, y: touch.clientY, timestamp: event.timeStamp },
+      setTouchEvent
+    );
   }
 };
 const startCollector = (setStoredMouseEvents, setStoredTouchEvents, setStoredKeyboardEvents, rootElement) => {
   const form = findContainingForm(rootElement);
   if (form) {
-    form.addEventListener("mousemove", (e) => logMouseEvent(e, setStoredMouseEvents));
-    form.addEventListener("keydown", (e) => logKeyboardEvent(e, setStoredKeyboardEvents));
-    form.addEventListener("keyup", (e) => logKeyboardEvent(e, setStoredKeyboardEvents));
-    form.addEventListener("touchstart", (e) => logTouchEvent(e, setStoredTouchEvents));
-    form.addEventListener("touchend", (e) => logTouchEvent(e, setStoredTouchEvents));
-    form.addEventListener("touchcancel", (e) => logTouchEvent(e, setStoredTouchEvents));
-    form.addEventListener("touchmove", (e) => logTouchEvent(e, setStoredTouchEvents));
+    form.addEventListener(
+      "mousemove",
+      (e) => logMouseEvent(e, setStoredMouseEvents)
+    );
+    form.addEventListener(
+      "keydown",
+      (e) => logKeyboardEvent(e, setStoredKeyboardEvents)
+    );
+    form.addEventListener(
+      "keyup",
+      (e) => logKeyboardEvent(e, setStoredKeyboardEvents)
+    );
+    form.addEventListener(
+      "touchstart",
+      (e) => logTouchEvent(e, setStoredTouchEvents)
+    );
+    form.addEventListener(
+      "touchend",
+      (e) => logTouchEvent(e, setStoredTouchEvents)
+    );
+    form.addEventListener(
+      "touchcancel",
+      (e) => logTouchEvent(e, setStoredTouchEvents)
+    );
+    form.addEventListener(
+      "touchmove",
+      (e) => logTouchEvent(e, setStoredTouchEvents)
+    );
   }
 };
 const findContainingForm = (element) => {

package/dist/cjs/modules/storage.cjs

@@ -1,15 +1,20 @@
 "use strict";
-const types = require("@prosopo/types");
 const util = require("@polkadot/util");
 const string = require("@polkadot/util/string");
+const types = require("@prosopo/types");
 const PROCAPTCHA_STORAGE_KEY = "@prosopo/procaptcha";
 function getProcaptchaStorage() {
   return types.ProsopoLocalStorageSchema.parse(
-    JSON.parse(util.hexToString(localStorage.getItem(PROCAPTCHA_STORAGE_KEY) || "0x7b7d"))
+    JSON.parse(
+      util.hexToString(localStorage.getItem(PROCAPTCHA_STORAGE_KEY) || "0x7b7d")
+    )
   );
 }
 function setProcaptchaStorage(storage2) {
-  localStorage.setItem(PROCAPTCHA_STORAGE_KEY, string.stringToHex(JSON.stringify(types.ProsopoLocalStorageSchema.parse(storage2))));
+  localStorage.setItem(
+    PROCAPTCHA_STORAGE_KEY,
+    string.stringToHex(JSON.stringify(types.ProsopoLocalStorageSchema.parse(storage2)))
+  );
 }
 function setAccount(account) {
   setProcaptchaStorage({ ...getProcaptchaStorage(), account });

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from './modules/index.js';
-export * from './utils/index.js';
+export * from "./modules/index.js";
+export * from "./utils/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from './modules/index.js';
-export * from './utils/index.js';
+export * from "./modules/index.js";
+export * from "./utils/index.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/dist/modules/Manager.d.ts

@@ -1,10 +1,9 @@
-import { ProcaptchaCallbacks, ProcaptchaClientConfigOutput, ProcaptchaState, ProcaptchaStateUpdateFn, StoredEvents } from '@prosopo/types';
+import { type ProcaptchaCallbacks, type ProcaptchaClientConfigOutput, type ProcaptchaState, type ProcaptchaStateUpdateFn } from "@prosopo/types";
 export declare function Manager(configOptional: ProcaptchaClientConfigOutput, state: ProcaptchaState, onStateUpdate: ProcaptchaStateUpdateFn, callbacks: ProcaptchaCallbacks): {
     start: () => Promise<void>;
     cancel: () => Promise<void>;
     submit: () => Promise<void>;
     select: (hash: string) => void;
     nextRound: () => void;
-    exportData: (events: StoredEvents) => Promise<void>;
 };
 //# sourceMappingURL=Manager.d.ts.map

package/dist/modules/Manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAaA,OAAO,EAMH,mBAAmB,EAEnB,4BAA4B,EAE5B,eAAe,EACf,uBAAuB,EACvB,YAAY,EAGf,MAAM,gBAAgB,CAAA;AAmDvB,wBAAgB,OAAO,CACnB,cAAc,EAAE,4BAA4B,EAC5C,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAkSR,MAAM;;yBA0LM,YAAY;EAwCjD"}
+{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAyBA,OAAO,EAKL,KAAK,mBAAmB,EAExB,KAAK,4BAA4B,EAEjC,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAK7B,MAAM,gBAAgB,CAAC;AA8DxB,wBAAgB,OAAO,CACrB,cAAc,EAAE,4BAA4B,EAC5C,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBA4OR,MAAM;;EAiJ7B"}