@prosopo/procaptcha 0.2.13 → 0.2.15

package/dist/cjs/modules/Manager.cjs

@@ -1,34 +1,43 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const errors = require("../api/errors.cjs");
-const api = require("@polkadot/api");
+const Api = require("@polkadot/api/promise/Api");
 const types = require("@prosopo/types");
-const rxjs = require("rxjs");
+const api = require("@prosopo/api");
+const keyring = require("@polkadot/keyring");
 const contract = require("@prosopo/contract");
 const common = require("@prosopo/common");
-const api$1 = require("@prosopo/api");
-require("../contracts/captcha/dist/index.cjs");
+const ws = require("@polkadot/rpc-provider/ws");
+const contractInfo = require("@prosopo/captcha-contract/contract-info");
 const util = require("@prosopo/util");
-const utilCrypto = require("@polkadot/util-crypto");
-const operators = require("rxjs/operators");
+const random = require("@polkadot/util-crypto/random");
+const utils = require("../utils/utils.cjs");
+const string = require("@polkadot/util/string");
 const ExtensionWeb2 = require("../api/ExtensionWeb2.cjs");
 const ExtensionWeb3 = require("../api/ExtensionWeb3.cjs");
 const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
 const storage = require("./storage.cjs");
-const captcha = require("../contracts/captcha/dist/contract-info/captcha.cjs");
-const defaultState = () => ({
-  showModal: false,
-  loading: false,
-  index: 0,
-  challenge: void 0,
-  solutions: void 0,
-  isHuman: false,
-  captchaApi: void 0,
-  account: void 0
-});
-const buildUpdateState = (state, onStateUpdate) => (nextState) => {
-  Object.assign(state, nextState);
-  onStateUpdate(nextState);
+const defaultState = () => {
+  return {
+    // note order matters! see buildUpdateState. These fields are set in order, so disable modal first, then set loading to false, etc.
+    showModal: false,
+    loading: false,
+    index: 0,
+    challenge: void 0,
+    solutions: void 0,
+    isHuman: false,
+    captchaApi: void 0,
+    account: void 0
+    // don't handle timeout here, this should be handled by the state management
+  };
+};
+const buildUpdateState = (state, onStateUpdate) => {
+  const updateCurrentState = (nextState) => {
+    Object.assign(state, nextState);
+    onStateUpdate(nextState);
+    console.log("Procaptcha state update:", nextState, "\nResult:", state);
+  };
+  return updateCurrentState;
 };
 const getNetwork = (config) => {
   const network = config.networks[config.defaultNetwork];
@@ -39,7 +48,7 @@ const getNetwork = (config) => {
 };
 function Manager(configOptional, state, onStateUpdate, callbacks) {
   const alertError = (error) => {
-    console.error(error);
+    console.log(error);
     alert(error.message);
   };
   const events = Object.assign(
@@ -47,7 +56,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       onAccountNotFound: alertError,
       onError: alertError,
       onHuman: (output) => {
-        console.info("onHuman event triggered", output);
+        console.log("onHuman event triggered", output);
       },
       onExtensionNotFound: () => {
         alert("No extension found");
@@ -62,10 +71,10 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         alert("Uncompleted challenge has expired, please try again");
       },
       onOpen: () => {
-        console.info("onOpen event triggered");
+        console.log("onOpen event triggered");
       },
       onClose: () => {
-        console.info("onClose event triggered");
+        console.log("onClose event triggered");
       }
     },
     callbacks
@@ -79,10 +88,16 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
   };
   const updateState = buildUpdateState(state, onStateUpdate);
-  const getConfig = () => types.ProcaptchaConfigSchema.parse({
-    ...configOptional,
-    userAccountAddress: state.account ? state.account.account.address : configOptional.userAccountAddress || ""
-  });
+  const getConfig = () => {
+    const config = {
+      userAccountAddress: "",
+      ...configOptional
+    };
+    if (state.account) {
+      config.userAccountAddress = state.account.account.address;
+    }
+    return types.ProcaptchaConfigSchema.parse(config);
+  };
   const fallable = async (fn) => {
     try {
       await fn();
@@ -93,59 +108,135 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
   };
   const start = async () => {
+    console.log("Starting procaptcha");
     events.onOpen();
     await fallable(async () => {
-      if (state.loading || state.isHuman)
+      if (state.loading) {
+        console.log("Procaptcha already loading");
+        return;
+      }
+      if (state.isHuman) {
+        console.log("already human");
         return;
+      }
       resetState();
-      updateState({ dappAccount: getConfig().account.address, loading: true });
+      updateState({ loading: true });
+      const config = getConfig();
+      updateState({ dappAccount: config.account.address });
+      await utils.sleep(100);
       const account = await loadAccount();
-      const contract2 = await loadContract();
-      if (await checkHumanInContract(contract2, account)) {
-        handleHumanInContract(account);
+      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({
+          user: account.account.address,
+          dapp: getDappAccount()
+        });
+        setValidChallengeTimeout();
         return;
       }
       const providerUrlFromStorage = storage.getProviderUrl();
+      let providerApi;
       if (providerUrlFromStorage) {
+        providerApi = await loadProviderApi(providerUrlFromStorage);
         try {
-          const verifyDappUserResponse = await getVerifyDappUserFunction(providerUrlFromStorage, account);
+          const verifyDappUserResponse = await providerApi.verifyDappUser(
+            account.account.address,
+            void 0,
+            configOptional.challengeValidLength
+          );
           if (verifyDappUserResponse.solutionApproved) {
-            handleHumanInCachedProvider(providerUrlFromStorage, account, verifyDappUserResponse);
+            updateState({ isHuman: true, loading: false });
+            events.onHuman({
+              providerUrl: providerUrlFromStorage,
+              user: account.account.address,
+              dapp: getDappAccount(),
+              commitmentId: verifyDappUserResponse.commitmentId
+            });
+            setValidChallengeTimeout();
             return;
           }
         } catch (err) {
           console.error("Error contacting provider from storage", providerUrlFromStorage);
         }
       }
-      const randomProviderResponse = await getRandomProviderResponse(contract2, account);
-      const challenge = await getChallenge(randomProviderResponse, contract2);
+      const payload = {
+        address: account.account.address,
+        data: string.stringToU8a("message"),
+        type: "bytes"
+      };
+      const signed = await account.extension.signer.signRaw(payload);
+      console.log("Signature:", signed);
+      const getRandomProviderResponse = await contract.wrapQuery(
+        contract$1.query.getRandomActiveProvider,
+        contract$1.query
+      )(account.account.address, getDappAccount());
+      const blockNumber = parseInt(getRandomProviderResponse.blockNumber.toString());
+      console.log("provider", getRandomProviderResponse);
+      const providerUrl = common.trimProviderUrl(getRandomProviderResponse.provider.url.toString());
+      providerApi = await loadProviderApi(providerUrl);
+      console.log("providerApi", providerApi);
+      const captchaApi = await loadCaptchaApi(contract$1, getRandomProviderResponse, providerApi);
+      console.log("captchaApi", captchaApi);
+      const challenge = await captchaApi.getCaptchaChallenge();
+      console.log("challenge", challenge);
       if (challenge.captchas.length <= 0) {
         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 timeout = setTimeout(() => {
+        console.log("challenge expired after " + timeMillis + "ms");
+        events.onChallengeExpired();
+        updateState({ isHuman: false, showModal: false, loading: false });
+      }, timeMillis);
       updateState({
-        challenge,
         index: 0,
         solutions: challenge.captchas.map(() => []),
+        challenge,
         showModal: true,
-        timeout: setTimeToComplete(challenge),
-        blockNumber: getBlockNumberFromProvider(randomProviderResponse)
+        timeout,
+        blockNumber
       });
     });
   };
   const submit = async () => {
     await fallable(async () => {
+      console.log("submitting solutions");
       clearTimeout();
-      updateState({ showModal: false });
       if (!state.challenge) {
         throw new Error("cannot submit, no challenge found");
       }
-      const datasetId = getDatasetId();
-      const salt = utilCrypto.randomAsHex();
-      const submission = await getCaptchaApi().submitCaptchaSolution(
-        getAccount().extension.signer,
-        state.challenge.requestHash,
-        datasetId,
-        getSolutionsFromState(salt),
+      updateState({ showModal: false });
+      const challenge = state.challenge;
+      const salt = random.randomAsHex();
+      const captchaSolution = state.challenge.captchas.map((captcha, index) => {
+        const solution = util.at(state.solutions, index);
+        return {
+          captchaId: captcha.captcha.captchaId,
+          captchaContentId: captcha.captcha.captchaContentId,
+          salt,
+          solution
+        };
+      });
+      const account = getAccount();
+      const blockNumber = getBlockNumber();
+      const signer = account.extension.signer;
+      const first = util.at(challenge.captchas, 0);
+      if (!first.captcha.datasetId) {
+        throw new Error("No datasetId set for challenge");
+      }
+      const captchaApi = getCaptchaApi();
+      const submission = await captchaApi.submitCaptchaSolution(
+        signer,
+        challenge.requestHash,
+        first.captcha.datasetId,
+        captchaSolution,
         salt
       );
       const isHuman = submission[0].solutionApproved;
@@ -157,20 +248,26 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         isHuman,
         loading: false
       });
-      if (isHuman) {
-        const trimmedUrl = common.trimProviderUrl(getCaptchaApi().provider.provider.url.toString());
+      if (state.isHuman) {
+        const trimmedUrl = common.trimProviderUrl(captchaApi.provider.provider.url.toString());
         storage.setProviderUrl(trimmedUrl);
         events.onHuman({
           providerUrl: trimmedUrl,
-          user: getAccount().account.address,
+          user: account.account.address,
           dapp: getDappAccount(),
           commitmentId: submission[1],
-          blockNumber: getBlockNumberFromState()
+          blockNumber
         });
         setValidChallengeTimeout();
       }
     });
   };
+  const cancel = async () => {
+    console.log("cancel");
+    clearTimeout();
+    resetState();
+    events.onClose();
+  };
   const select = (hash) => {
     if (!state.challenge) {
       throw new Error("cannot select, no challenge found");
@@ -178,9 +275,17 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     if (state.index >= state.challenge.captchas.length || state.index < 0) {
       throw new Error("cannot select, round index out of range");
     }
-    const solution = util.at(state.solutions, state.index);
-    handleIsSelected(solution, hash);
-    updateState({ solutions: state.solutions });
+    const index = state.index;
+    const solutions = state.solutions;
+    const solution = util.at(solutions, index);
+    if (solution.includes(hash)) {
+      console.log("deselecting", hash);
+      solution.splice(solution.indexOf(hash), 1);
+    } else {
+      console.log("selecting", hash);
+      solution.push(hash);
+    }
+    updateState({ solutions });
   };
   const nextRound = () => {
     if (!state.challenge) {
@@ -189,161 +294,44 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     if (state.index + 1 >= state.challenge.captchas.length) {
       throw new Error("cannot proceed to next round, already at last round");
     }
+    console.log("proceeding to next round");
     updateState({ index: state.index + 1 });
   };
   const loadCaptchaApi = async (contract2, provider, providerApi) => {
-    updateState({
-      captchaApi: new ProsopoCaptchaApi.ProsopoCaptchaApi(
-        getAccount().account.address,
-        contract2,
-        provider,
-        providerApi,
-        getConfig().web2,
-        getDappAccount()
-      )
-    });
-    return getCaptchaApi();
-  };
-  const createBlockObservable = () => new rxjs.Observable(
-    (subscriber) => () => api.ApiPromise.create({ provider: new api.WsProvider(getNetwork(getConfig()).endpoint) }).then((api2) => {
-      api2.rpc.chain.subscribeNewHeads((header) => {
-        subscriber.next(header);
-      });
-    }).catch((error) => {
-      subscriber.error(error);
-    })
-  );
-  const loadAccount = async () => {
     const config = getConfig();
-    if (!config.web2 && !config.userAccountAddress) {
-      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);
-    storage.setAccount(account.account.address);
-    updateState({ account });
-    return getAccount();
+    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);
     if (!config.account.address) {
       throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
     }
-    return new api$1.ProviderApi(getNetwork(config), providerUrl, config.account.address);
-  };
-  const loadContract = async () => {
-    const network = getNetwork(getConfig());
-    const api$12 = await api.ApiPromise.create({ provider: new api.WsProvider(network.endpoint) });
-    const type = "sr25519";
-    return new contract.ProsopoCaptchaContract(
-      api$12,
-      JSON.parse(captcha.ContractAbi),
-      network.contract.address,
-      "prosopo",
-      0,
-      new api.Keyring({ type, ss58Format: api$12.registry.chainSS58 }).addFromAddress(getAccount().account.address)
-    );
-  };
-  function handleIsSelected(solution, hash) {
-    if (solution.includes(hash)) {
-      solution.splice(solution.indexOf(hash), 1);
-    } else {
-      solution.push(hash);
-    }
-  }
-  function getSolutionsFromState(salt) {
-    if (!state.challenge) {
-      throw new Error("cannot get solutions, no challenge found");
-    }
-    return state.challenge.captchas.map((captcha2, index) => ({
-      captchaId: captcha2.captcha.captchaId,
-      captchaContentId: captcha2.captcha.captchaContentId,
-      salt,
-      solution: util.at(state.solutions, index)
-    }));
-  }
-  function handleHumanInCachedProvider(providerUrlFromStorage, account, verifyDappUserResponse) {
-    updateState({ isHuman: true, loading: false });
-    events.onHuman({
-      providerUrl: providerUrlFromStorage,
-      user: account.account.address,
-      dapp: getDappAccount(),
-      commitmentId: verifyDappUserResponse.commitmentId
-    });
-    setValidChallengeTimeout();
-  }
-  function getVerifyDappUserFunction(providerUrlFromStorage, account) {
-    return loadProviderApi(providerUrlFromStorage).then(
-      (providerApi) => providerApi.verifyDappUser(account.account.address)
-    );
-  }
-  function handleHumanInContract(account) {
-    updateState({ isHuman: true, loading: false });
-    events.onHuman({
-      user: account.account.address,
-      dapp: getDappAccount()
-    });
-    setValidChallengeTimeout();
-  }
-  async function checkHumanInContract(contract2, account) {
-    try {
-      return await contract2.query.dappOperatorIsHumanUser(account.account.address, getConfig().solutionThreshold).then((res) => res.value.unwrap().unwrap());
-    } catch (err) {
-      console.error(err);
-      return false;
-    }
-  }
-  function getChallenge(getRandomProviderResponse2, contract2) {
-    return loadProviderApi(common.trimProviderUrl(getRandomProviderResponse2.provider.url.toString())).then((api2) => loadCaptchaApi(contract2, getRandomProviderResponse2, api2)).then((captchaApi) => captchaApi.getCaptchaChallenge());
-  }
-  function getRandomProviderResponse(contract$1, account) {
-    return rxjs.lastValueFrom(
-      rxjs.from(
-        contract.wrapQuery(contract$1.query.getRandomActiveProvider, contract$1.query)(
-          account.account.address,
-          getDappAccount()
-        )
-      ).pipe(
-        operators.retry({
-          count: 3,
-          delay: (error, retryCount) => {
-            console.error(`Attempt ${retryCount} failed. Retrying on next block. Error: ${error}`);
-            return createBlockObservable().pipe(operators.take(1));
-          },
-          resetOnSuccess: true
-        })
-      )
-    );
-  }
-  function setTimeToComplete(challenge) {
-    return setTimeout(
-      () => {
-        events.onChallengeExpired();
-        updateState({ isHuman: false, showModal: false, loading: false });
-      },
-      challenge.captchas.map((captcha2) => captcha2.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b)
-    );
-  }
-  const setValidChallengeTimeout = () => {
-    updateState({
-      successfullChallengeTimeout: setTimeout(
-        () => {
-          updateState({ isHuman: false });
-          events.onExpired();
-        },
-        configOptional.challengeValidLength || 120 * 1e3
-      )
-    });
-  };
-  const cancel = async () => {
-    clearTimeout();
-    resetState();
-    events.onClose();
+    return new api.ProviderApi(network, providerUrl, config.account.address);
   };
   const clearTimeout = () => {
     window.clearTimeout(state.timeout);
     updateState({ timeout: void 0 });
   };
+  const setValidChallengeTimeout = () => {
+    console.log("setting valid challenge timeout");
+    const timeMillis = configOptional.challengeValidLength || 120 * 1e3;
+    const successfullChallengeTimeout = setTimeout(() => {
+      console.log("valid challenge expired after " + timeMillis + "ms");
+      updateState({ isHuman: false });
+      events.onExpired();
+    }, timeMillis);
+    updateState({ successfullChallengeTimeout });
+  };
   const resetState = () => {
     clearTimeout();
     updateState(defaultState());
@@ -354,37 +342,54 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
     return state.captchaApi;
   };
+  const loadAccount = async () => {
+    const config = getConfig();
+    if (!config.web2 && !config.userAccountAddress) {
+      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);
+    storage.setAccount(account.account.address);
+    console.log("Using account:", account);
+    updateState({ account });
+    return getAccount();
+  };
   const getAccount = () => {
     if (!state.account) {
       throw new Error("Account not loaded");
     }
-    return state.account;
+    const account = state.account;
+    return account;
   };
   const getDappAccount = () => {
     if (!state.dappAccount) {
       throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
     }
-    return state.dappAccount;
+    const dappAccount = state.dappAccount;
+    return dappAccount;
   };
-  const getBlockNumberFromState = () => {
+  const getBlockNumber = () => {
     if (!state.blockNumber) {
       throw new Error("Account not loaded");
     }
-    return state.blockNumber;
+    const blockNumber = state.blockNumber;
+    return blockNumber;
+  };
+  const loadContract = async () => {
+    const config = getConfig();
+    const network = getNetwork(config);
+    const api2 = await Api.ApiPromise.create({ provider: new ws.WsProvider(network.endpoint), initWasm: false });
+    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)
+    );
   };
-  function getBlockNumberFromProvider(getRandomProviderResponse2) {
-    return parseInt(getRandomProviderResponse2.blockNumber.toString());
-  }
-  function getDatasetId() {
-    if (!state.challenge) {
-      throw new Error("cannot get datasetId, no challenge found");
-    }
-    const datasetId = util.at(state.challenge.captchas, 0).captcha.datasetId;
-    if (!datasetId) {
-      throw new Error("No datasetId set for challenge");
-    }
-    return datasetId;
-  }
   return {
     start,
     cancel,

package/dist/cjs/modules/ProsopoCaptchaApi.cjs

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-require("../packages/datasets/dist/index.cjs");
+const datasets = require("@prosopo/datasets");
 const handlers = require("../api/handlers.cjs");
 const common = require("@prosopo/common");
 const util = require("@prosopo/util");
-const util$1 = require("@polkadot/util");
-const merkle = require("../packages/datasets/dist/captcha/merkle.cjs");
-const captcha = require("../packages/datasets/dist/captcha/captcha.cjs");
+const string = require("@polkadot/util/string");
 class ProsopoCaptchaApi {
   constructor(userAccount, contract, provider, providerApi, web2, dappAccount) {
     this.userAccount = userAccount;
@@ -37,7 +35,7 @@ class ProsopoCaptchaApi {
       if (!verifyCaptchaData(captchaWithProof)) {
         throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
       }
-      if (!merkle.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
+      if (!datasets.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
         throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
       }
     }
@@ -45,8 +43,8 @@ class ProsopoCaptchaApi {
     return;
   }
   async submitCaptchaSolution(signer, requestHash, datasetId, solutions, salt) {
-    const tree = new merkle.CaptchaMerkleTree();
-    const captchasHashed = solutions.map((captcha$1) => captcha.computeCaptchaSolutionHash(captcha$1));
+    const tree = new datasets.CaptchaMerkleTree();
+    const captchasHashed = solutions.map((captcha) => datasets.computeCaptchaSolutionHash(captcha));
     tree.build(captchasHashed);
     const commitmentId = tree.root.hash;
     console.log("solveCaptchaChallenge commitmentId", commitmentId);
@@ -58,7 +56,7 @@ class ProsopoCaptchaApi {
       }
       const signed = await signer.signRaw({
         address: this.userAccount,
-        data: util$1.stringToHex(requestHash),
+        data: string.stringToHex(requestHash),
         type: "bytes"
       });
       signature = signed.signature;
@@ -79,15 +77,15 @@ class ProsopoCaptchaApi {
   }
 }
 async function verifyCaptchaData(captchaWithProof) {
-  const captcha$1 = captchaWithProof.captcha;
+  const captcha = captchaWithProof.captcha;
   const proof = captchaWithProof.proof;
-  if (!(await Promise.all(captcha$1.items.map(async (item) => (await captcha.computeItemHash(item)).hash === item.hash))).every(
+  if (!(await Promise.all(captcha.items.map(async (item) => (await datasets.computeItemHash(item)).hash === item.hash))).every(
     (hash) => hash === true
   )) {
     return false;
   }
-  const captchaHash = captcha.computeCaptchaHash(captcha$1, false, false, false);
-  if (captchaHash !== captcha$1.captchaContentId) {
+  const captchaHash = datasets.computeCaptchaHash(captcha, false, false, false);
+  if (captchaHash !== captcha.captchaContentId) {
     return false;
   }
   return util.at(proof, 0).indexOf(captchaHash) !== -1;

package/dist/index.js

@@ -1,16 +1,3 @@
-// Copyright 2021-2023 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
 export * from './api/index.js';
 export * from './modules/index.js';
 export * from './types/index.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA"}

package/dist/modules/Manager.d.ts

@@ -10,9 +10,6 @@ export declare const getNetwork: (config: ProcaptchaClientConfigOutput) => {
     pairType: "sr25519" | "ed25519" | "ecdsa" | "ethereum";
     ss58Format: number;
 };
-/**
- * The state operator. This is used to mutate the state of Procaptcha during the captcha process. State updates are published via the onStateUpdate callback. This should be used by frontends, e.g. react, to maintain the state of Procaptcha across renders.
- */
 export declare function Manager(configOptional: ProcaptchaConfigOptional, state: ProcaptchaState, onStateUpdate: ProcaptchaStateUpdateFn, callbacks: ProcaptchaCallbacks): {
     start: () => Promise<void>;
     cancel: () => Promise<void>;

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,EAEH,mBAAmB,EACnB,wBAAwB,EAExB,eAAe,EACf,uBAAuB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAmB,4BAA4B,EAA0B,MAAM,gBAAgB,CAAA;AAetG,eAAO,MAAM,YAAY,QAAO,QAAQ,eAAe,CASrD,CAAA;AAQF,eAAO,MAAM,UAAU,WAAY,4BAA4B;;;;;;;;CAM9D,CAAA;AAED;;GAEG;AACH,wBAAgB,OAAO,CACnB,cAAc,EAAE,wBAAwB,EACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAqLR,MAAM;;EA4V/B"}
+{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAaA,OAAO,EAEH,mBAAmB,EACnB,wBAAwB,EAExB,eAAe,EACf,uBAAuB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAGH,4BAA4B,EAE/B,MAAM,gBAAgB,CAAA;AAmBvB,eAAO,MAAM,YAAY,QAAO,QAAQ,eAAe,CAatD,CAAA;AAgBD,eAAO,MAAM,UAAU,WAAY,4BAA4B;;;;;;;;CAM9D,CAAA;AAKD,wBAAgB,OAAO,CACnB,cAAc,EAAE,wBAAwB,EACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAuTR,MAAM;;EA+K/B"}