@prosopo/procaptcha 2.10.57 → 2.10.59

package/dist/cjs/modules/Manager.cjs

@@ -1,388 +1,292 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const string = require("@polkadot/util/string");
-const api = require("@prosopo/api");
-const common = require("@prosopo/common");
-const procaptchaCommon = require("@prosopo/procaptcha-common");
-const types = require("@prosopo/types");
-const util = require("@prosopo/util");
-const utilCrypto = require("@prosopo/util-crypto");
-const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
-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 require_ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
+let _polkadot_util_string = require("@polkadot/util/string");
+let _prosopo_api = require("@prosopo/api");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_procaptcha_common = require("@prosopo/procaptcha-common");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_util = require("@prosopo/util");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+//#region src/modules/Manager.ts
+var defaultState = () => {
+	return {
+		showModal: false,
+		loading: false,
+		index: 0,
+		challenge: void 0,
+		solutions: void 0,
+		isHuman: false,
+		captchaApi: void 0,
+		account: void 0
+	};
 };
+/**
+* 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.
+*/
 function Manager(configOptional, state, onStateUpdate, callbacks, frictionlessState, getHoneypotValue) {
-  const events = procaptchaCommon.getDefaultEvents(callbacks);
-  const updateState = procaptchaCommon.buildUpdateState(state, onStateUpdate);
-  let checkboxClickX = 0;
-  let checkboxClickY = 0;
-  let previousProviderUrl;
-  const getConfig = () => {
-    const config = {
-      userAccountAddress: "",
-      ...configOptional
-    };
-    if (state.account) {
-      config.userAccountAddress = state.account.account.address;
-    }
-    return types.ProcaptchaConfigSchema.parse(config);
-  };
-  const start = async (checkboxX = 0, checkboxY = 0) => {
-    checkboxClickX = checkboxX;
-    checkboxClickY = checkboxY;
-    events.onOpen();
-    await procaptchaCommon.providerRetry(
-      async () => {
-        if (state.loading) {
-          return;
-        }
-        if (state.isHuman) {
-          return;
-        }
-        updateState({ loading: true });
-        updateState({
-          attemptCount: state.attemptCount ? state.attemptCount + 1 : 1
-        });
-        updateState({
-          sessionId: frictionlessState?.sessionId
-        });
-        const config = getConfig();
-        updateState({ dappAccount: config.account.address });
-        await util.sleep(100);
-        const account = await loadAccount();
-        let captchaApi = state.captchaApi;
-        if (!frictionlessState?.provider) {
-          const currentConfig = getConfig();
-          const getRandomProviderResponse = await procaptchaCommon.getProcaptchaRandomActiveProvider(
-            currentConfig.defaultEnvironment,
-            procaptchaCommon.pickIpMode(currentConfig),
-            { attempt: state.attemptCount, excludeUrl: previousProviderUrl }
-          );
-          const providerUrl = getRandomProviderResponse.provider.url;
-          previousProviderUrl = providerUrl;
-          const providerApi = await loadProviderApi(providerUrl);
-          captchaApi = new ProsopoCaptchaApi.ProsopoCaptchaApi(
-            account.account.address,
-            getRandomProviderResponse,
-            providerApi,
-            config.web2,
-            config.account.address || ""
-          );
-          updateState({ captchaApi });
-        } else {
-          const providerUrl = frictionlessState.provider.provider.url;
-          const providerApi = await loadProviderApi(providerUrl);
-          captchaApi = new ProsopoCaptchaApi.ProsopoCaptchaApi(
-            account.account.address,
-            frictionlessState.provider,
-            providerApi,
-            config.web2,
-            config.account.address || ""
-          );
-          updateState({ captchaApi });
-        }
-        const simdReadingsOnChallenge = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings(0) : void 0;
-        const challenge = await captchaApi?.getCaptchaChallenge(
-          state.sessionId,
-          simdReadingsOnChallenge
-        );
-        if (challenge.error) {
-          updateState({
-            loading: false,
-            error: {
-              message: challenge.error.message,
-              key: challenge.error.key || "API.UNKNOWN_ERROR"
-            }
-          });
-          events.onError(new Error(challenge.error?.message));
-        } else {
-          if (challenge.captchas.length <= 0) {
-            throw new common.ProsopoDatasetError("DEVELOPER.PROVIDER_NO_CAPTCHA");
-          }
-          const timeMillis = challenge.captchas.map(
-            (captcha) => captcha.timeLimitMs || config.captchas.image.challengeTimeout
-          ).reduce((a, b) => a + b);
-          const timeout = setTimeout(() => {
-            events.onChallengeExpired();
-            updateState({ isHuman: false, showModal: false, loading: false });
-          }, timeMillis);
-          updateState({
-            index: 0,
-            solutions: challenge.captchas.map(() => []),
-            challenge,
-            showModal: true,
-            timeout,
-            loading: false
-          });
-        }
-      },
-      start,
-      resetState,
-      state.attemptCount,
-      10
-    );
-  };
-  const submit = async () => {
-    await procaptchaCommon.providerRetry(
-      async () => {
-        clearTimeout();
-        if (!state.challenge) {
-          throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-            context: { error: "Cannot submit, no Captcha found in state" }
-          });
-        }
-        updateState({ showModal: false });
-        const challenge = state.challenge;
-        const captchaSolution = state.challenge.captchas.map(
-          (captcha, index) => {
-            const solution = util.at(state.solutions, index);
-            const shapeCoords = solution.flatMap(([_, x, y]) => [x, y]);
-            const coords = index === 0 ? [checkboxClickX, checkboxClickY, ...shapeCoords] : shapeCoords;
-            const salt = utilCrypto.randomAsHex(
-              coords.map((x) => x.toString(16).length + 4).reduce((acc, curr) => acc + curr, 0)
-            );
-            const saltCoord = util.embedData(salt, coords);
-            return {
-              captchaId: captcha.captchaId,
-              captchaContentId: captcha.captchaContentId,
-              salt: saltCoord,
-              solution: solution.flatMap((s) => s[0])
-            };
-          }
-        );
-        const account = getAccount();
-        const signer = getExtension(account).signer;
-        const first = util.at(challenge.captchas, 0);
-        if (!first.datasetId) {
-          throw new common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_ID", {
-            context: { error: "No datasetId set for challenge" }
-          });
-        }
-        const captchaApi = state.captchaApi;
-        if (!captchaApi) {
-          throw new common.ProsopoError("CAPTCHA.INVALID_TOKEN", {
-            context: { error: "No Captcha API found in state" }
-          });
-        }
-        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"
-            }
-          });
-        }
-        const userTimestampSignature = await signer.signRaw({
-          address: account.account.address,
-          data: string.stringToHex(challenge[types.ApiParams.timestamp]),
-          type: "bytes"
-        });
-        let encryptedBehavioralData;
-        if (frictionlessState?.encryptBehavioralData && (frictionlessState?.behaviorCollector1 || frictionlessState?.behaviorCollector2 || frictionlessState?.behaviorCollector3)) {
-          try {
-            const behavioralData = {
-              collector1: frictionlessState.behaviorCollector1?.getData() || [],
-              collector2: frictionlessState.behaviorCollector2?.getData() || [],
-              collector3: frictionlessState.behaviorCollector3?.getData() || [],
-              deviceCapability: frictionlessState.deviceCapability || "unknown"
-            };
-            const dataToEncrypt = frictionlessState.packBehavioralData ? frictionlessState.packBehavioralData(behavioralData) : behavioralData;
-            encryptedBehavioralData = await frictionlessState.encryptBehavioralData(
-              JSON.stringify(dataToEncrypt)
-            );
-          } catch {
-          }
-        }
-        const simdReadings = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings() : void 0;
-        const hpValue = getHoneypotValue?.();
-        const clientMetaData = hpValue ? { hp: hpValue } : void 0;
-        const submission = await captchaApi.submitCaptchaSolution(
-          userTimestampSignature.signature,
-          challenge.requestHash,
-          captchaSolution,
-          challenge.timestamp,
-          challenge.signature.provider.requestHash,
-          encryptedBehavioralData,
-          simdReadings,
-          clientMetaData
-        );
-        const isHuman = submission[0].verified;
-        updateState({
-          submission,
-          isHuman,
-          loading: false
-        });
-        if (state.isHuman) {
-          const providerUrl = captchaApi.provider.provider.url;
-          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.timestamp]: challenge.timestamp,
-              [types.ApiParams.signature]: {
-                [types.ApiParams.provider]: {
-                  [types.ApiParams.requestHash]: challenge.signature.provider.requestHash
-                },
-                [types.ApiParams.user]: {
-                  [types.ApiParams.timestamp]: userTimestampSignature.signature
-                }
-              },
-              [types.ApiParams.captchaType]: types.CaptchaType.image
-            })
-          );
-          setValidChallengeTimeout();
-        } else {
-          events.onFailed();
-          resetState(frictionlessState?.restart);
-        }
-      },
-      start,
-      resetState,
-      state.attemptCount,
-      10
-    );
-  };
-  const cancel = async () => {
-    clearTimeout();
-    resetState(frictionlessState?.restart);
-    events.onClose();
-  };
-  const reload = async () => {
-    clearTimeout();
-    events.onReload();
-    resetState(frictionlessState?.restart);
-    if (!frictionlessState?.restart) {
-      await start();
-    }
-  };
-  const select = (hash, x, y) => {
-    if (!state.challenge) {
-      throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-        context: { error: "Cannot select, no Captcha found in state" }
-      });
-    }
-    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"
-        }
-      });
-    }
-    const index = state.index;
-    const solutions = state.solutions;
-    const solution = util.at(solutions, index);
-    if (solution.some((s) => s[0] === hash)) {
-      const newSolution = solution.filter((s) => s[0] !== hash);
-      solutions[index] = newSolution;
-    } else {
-      solutions[index] = [...solution, [hash, x || 0, y || 0]];
-    }
-    updateState({ solutions });
-  };
-  const nextRound = () => {
-    if (!state.challenge) {
-      throw new common.ProsopoError("CAPTCHA.NO_CAPTCHA", {
-        context: { error: "Cannot select, no Captcha found in state" }
-      });
-    }
-    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"
-        }
-      });
-    }
-    updateState({ index: state.index + 1 });
-  };
-  const loadProviderApi = async (providerUrl) => {
-    const config = getConfig();
-    if (!config.account.address) {
-      throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
-    }
-    return new api.ProviderApi(providerUrl, config.account.address);
-  };
-  const clearTimeout = () => {
-    window.clearTimeout(Number(state.timeout));
-    updateState({ timeout: void 0 });
-  };
-  const setValidChallengeTimeout = () => {
-    const timeMillis = configOptional.captchas.image.solutionTimeout;
-    const successfullChallengeTimeout = setTimeout(() => {
-      updateState({ isHuman: false });
-      events.onExpired();
-    }, timeMillis);
-    updateState({ successfullChallengeTimeout });
-  };
-  const resetState = (frictionlessRestart) => {
-    clearTimeout();
-    updateState(defaultState());
-    events.onReset();
-    if (frictionlessRestart) {
-      frictionlessRestart();
-    }
-  };
-  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" }
-      });
-    }
-    const selectAccount = async () => {
-      const ext = new (await procaptchaCommon.ExtensionLoader(config.web2))();
-      if (frictionlessState) {
-        return frictionlessState.userAccount;
-      }
-      return await ext.getAccount(config);
-    };
-    const account = await selectAccount();
-    updateState({ account });
-    return getAccount();
-  };
-  const getAccount = () => {
-    if (!state.account) {
-      throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
-        context: { error: "Account not loaded" }
-      });
-    }
-    const account = state.account;
-    return account;
-  };
-  const getDappAccount = () => {
-    if (!state.dappAccount) {
-      throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
-    }
-    const dappAccount = state.dappAccount;
-    return dappAccount;
-  };
-  const getExtension = (possiblyAccount) => {
-    const account = possiblyAccount || getAccount();
-    if (!account.extension) {
-      throw new common.ProsopoEnvError("ACCOUNT.NO_POLKADOT_EXTENSION", {
-        context: { error: "Extension not loaded" }
-      });
-    }
-    return account.extension;
-  };
-  return {
-    start,
-    cancel,
-    submit,
-    select,
-    nextRound,
-    reload
-  };
+	const events = (0, _prosopo_procaptcha_common.getDefaultEvents)(callbacks);
+	const updateState = (0, _prosopo_procaptcha_common.buildUpdateState)(state, onStateUpdate);
+	let checkboxClickX = 0;
+	let checkboxClickY = 0;
+	let previousProviderUrl;
+	/**
+	* Build the config on demand, using the optional config passed in from the outside. State may override various
+	* config values depending on the state of the captcha process. E.g. if the process has been started using account
+	* "ABC" and then the user changes account to "DEF" via the optional config prop, the account in use will not change.
+	* This is because the captcha process has already been started using account "ABC".
+	* @returns the config for procaptcha
+	*/
+	const getConfig = () => {
+		const config = {
+			userAccountAddress: "",
+			...configOptional
+		};
+		if (state.account) config.userAccountAddress = state.account.account.address;
+		return _prosopo_types.ProcaptchaConfigSchema.parse(config);
+	};
+	/**
+	* Called on start of user verification. This is when the user ticks the box to claim they are human.
+	*/
+	const start = async (checkboxX = 0, checkboxY = 0) => {
+		checkboxClickX = checkboxX;
+		checkboxClickY = checkboxY;
+		events.onOpen();
+		await (0, _prosopo_procaptcha_common.providerRetry)(async () => {
+			if (state.loading) return;
+			if (state.isHuman) return;
+			updateState({ loading: true });
+			updateState({ attemptCount: state.attemptCount ? state.attemptCount + 1 : 1 });
+			updateState({ sessionId: frictionlessState?.sessionId });
+			const config = getConfig();
+			updateState({ dappAccount: config.account.address });
+			await (0, _prosopo_util.sleep)(100);
+			const account = await loadAccount();
+			let captchaApi = state.captchaApi;
+			if (!frictionlessState?.provider) {
+				const currentConfig = getConfig();
+				const getRandomProviderResponse = await (0, _prosopo_procaptcha_common.getProcaptchaRandomActiveProvider)(currentConfig.defaultEnvironment, (0, _prosopo_procaptcha_common.pickIpMode)(currentConfig), {
+					attempt: state.attemptCount,
+					excludeUrl: previousProviderUrl
+				});
+				const providerUrl = getRandomProviderResponse.provider.url;
+				previousProviderUrl = providerUrl;
+				const { providerApi, siteKey } = await loadProviderApi(providerUrl);
+				captchaApi = new require_ProsopoCaptchaApi.ProsopoCaptchaApi(account.account.address, getRandomProviderResponse, providerApi, config.web2, siteKey);
+				updateState({ captchaApi });
+			} else {
+				const providerUrl = frictionlessState.provider.provider.url;
+				const { providerApi, siteKey } = await loadProviderApi(providerUrl);
+				captchaApi = new require_ProsopoCaptchaApi.ProsopoCaptchaApi(account.account.address, frictionlessState.provider, providerApi, config.web2, siteKey);
+				updateState({ captchaApi });
+			}
+			const simdReadingsOnChallenge = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings(0) : void 0;
+			const challenge = await captchaApi?.getCaptchaChallenge(state.sessionId, simdReadingsOnChallenge);
+			if (challenge.error) {
+				updateState({
+					loading: false,
+					error: {
+						message: challenge.error.message,
+						key: challenge.error.key || "API.UNKNOWN_ERROR"
+					}
+				});
+				events.onError(new Error(challenge.error?.message));
+			} else {
+				if (challenge.captchas.length <= 0) throw new _prosopo_common.ProsopoDatasetError("DEVELOPER.PROVIDER_NO_CAPTCHA");
+				const timeMillis = challenge.captchas.map((captcha) => captcha.timeLimitMs || config.captchas.image.challengeTimeout).reduce((a, b) => a + b);
+				const timeout = setTimeout(() => {
+					events.onChallengeExpired();
+					updateState({
+						isHuman: false,
+						showModal: false,
+						loading: false
+					});
+				}, timeMillis);
+				updateState({
+					index: 0,
+					solutions: challenge.captchas.map(() => []),
+					challenge,
+					showModal: true,
+					timeout,
+					loading: false
+				});
+			}
+		}, start, resetState, state.attemptCount, 10);
+	};
+	const submit = async () => {
+		await (0, _prosopo_procaptcha_common.providerRetry)(async () => {
+			clearTimeout();
+			if (!state.challenge) throw new _prosopo_common.ProsopoError("CAPTCHA.NO_CAPTCHA", { context: { error: "Cannot submit, no Captcha found in state" } });
+			updateState({ showModal: false });
+			const challenge = state.challenge;
+			const captchaSolution = state.challenge.captchas.map((captcha, index) => {
+				const solution = (0, _prosopo_util.at)(state.solutions, index);
+				const shapeCoords = solution.flatMap(([_, x, y]) => [x, y]);
+				const coords = index === 0 ? [
+					checkboxClickX,
+					checkboxClickY,
+					...shapeCoords
+				] : shapeCoords;
+				const salt = (0, _prosopo_util_crypto.randomAsHex)(coords.map((x) => x.toString(16).length + 4).reduce((acc, curr) => acc + curr, 0));
+				const saltCoord = (0, _prosopo_util.embedData)(salt, coords);
+				return {
+					captchaId: captcha.captchaId,
+					captchaContentId: captcha.captchaContentId,
+					salt: saltCoord,
+					solution: solution.flatMap((s) => s[0])
+				};
+			});
+			const account = getAccount();
+			const signer = getExtension(account).signer;
+			if (!(0, _prosopo_util.at)(challenge.captchas, 0).datasetId) throw new _prosopo_common.ProsopoDatasetError("CAPTCHA.INVALID_CAPTCHA_ID", { context: { error: "No datasetId set for challenge" } });
+			const captchaApi = state.captchaApi;
+			if (!captchaApi) throw new _prosopo_common.ProsopoError("CAPTCHA.INVALID_TOKEN", { context: { error: "No Captcha API found in state" } });
+			if (!signer || !signer.signRaw) throw new _prosopo_common.ProsopoEnvError("GENERAL.CANT_FIND_KEYRINGPAIR", { context: { error: "Signer is not defined, cannot sign message to prove account ownership" } });
+			const userTimestampSignature = await signer.signRaw({
+				address: account.account.address,
+				data: (0, _polkadot_util_string.stringToHex)(challenge[_prosopo_types.ApiParams.timestamp]),
+				type: "bytes"
+			});
+			let encryptedBehavioralData;
+			if (frictionlessState?.encryptBehavioralData && (frictionlessState?.behaviorCollector1 || frictionlessState?.behaviorCollector2 || frictionlessState?.behaviorCollector3)) try {
+				const behavioralData = {
+					collector1: frictionlessState.behaviorCollector1?.getData() || [],
+					collector2: frictionlessState.behaviorCollector2?.getData() || [],
+					collector3: frictionlessState.behaviorCollector3?.getData() || [],
+					deviceCapability: frictionlessState.deviceCapability || "unknown"
+				};
+				const dataToEncrypt = frictionlessState.packBehavioralData ? frictionlessState.packBehavioralData(behavioralData) : behavioralData;
+				encryptedBehavioralData = await frictionlessState.encryptBehavioralData(JSON.stringify(dataToEncrypt));
+			} catch {}
+			const simdReadings = await (0, _prosopo_procaptcha_common.getSimdReadingsForSubmit)(frictionlessState);
+			const hpValue = getHoneypotValue?.();
+			const clientMetaData = hpValue ? { hp: hpValue } : void 0;
+			const submission = await captchaApi.submitCaptchaSolution(userTimestampSignature.signature, challenge.requestHash, captchaSolution, challenge.timestamp, challenge.signature.provider.requestHash, encryptedBehavioralData, simdReadings, clientMetaData);
+			const isHuman = submission[0].verified;
+			updateState({
+				submission,
+				isHuman,
+				loading: false
+			});
+			if (state.isHuman) {
+				const providerUrl = captchaApi.provider.provider.url;
+				events.onHuman((0, _prosopo_types.encodeProcaptchaOutput)({
+					[_prosopo_types.ApiParams.providerUrl]: providerUrl,
+					[_prosopo_types.ApiParams.user]: account.account.address,
+					[_prosopo_types.ApiParams.dapp]: getDappAccount(),
+					[_prosopo_types.ApiParams.commitmentId]: (0, _prosopo_util.hashToHex)(submission[1]),
+					[_prosopo_types.ApiParams.timestamp]: challenge.timestamp,
+					[_prosopo_types.ApiParams.signature]: {
+						[_prosopo_types.ApiParams.provider]: { [_prosopo_types.ApiParams.requestHash]: challenge.signature.provider.requestHash },
+						[_prosopo_types.ApiParams.user]: { [_prosopo_types.ApiParams.timestamp]: userTimestampSignature.signature }
+					},
+					[_prosopo_types.ApiParams.captchaType]: _prosopo_types.CaptchaType.image
+				}));
+				setValidChallengeTimeout();
+			} else {
+				events.onFailed();
+				resetState(frictionlessState?.restart);
+			}
+		}, start, resetState, state.attemptCount, 10);
+	};
+	const cancel = async () => {
+		clearTimeout();
+		resetState(frictionlessState?.restart);
+		events.onClose();
+	};
+	const reload = async () => {
+		clearTimeout();
+		events.onReload();
+		resetState(frictionlessState?.restart);
+		if (!frictionlessState?.restart) await start();
+	};
+	/**
+	* (De)Select an image from the solution for the current round. If the hash is already in the solutions list, it will be removed (deselected) and if not it will be added (selected).
+	* @param hash the hash of the image
+	* @param x
+	* @param y
+	*/
+	const select = (hash, x, y) => {
+		if (!state.challenge) throw new _prosopo_common.ProsopoError("CAPTCHA.NO_CAPTCHA", { context: { error: "Cannot select, no Captcha found in state" } });
+		if (state.index >= state.challenge.captchas.length || state.index < 0) throw new _prosopo_common.ProsopoError("CAPTCHA.NO_CAPTCHA", { context: { error: "Cannot select, index is out of range for this Captcha" } });
+		const index = state.index;
+		const solutions = state.solutions;
+		const solution = (0, _prosopo_util.at)(solutions, index);
+		if (solution.some((s) => s[0] === hash)) solutions[index] = solution.filter((s) => s[0] !== hash);
+		else solutions[index] = [...solution, [
+			hash,
+			x || 0,
+			y || 0
+		]];
+		updateState({ solutions });
+	};
+	/**
+	* Proceed to the next round of the challenge.
+	*/
+	const nextRound = () => {
+		if (!state.challenge) throw new _prosopo_common.ProsopoError("CAPTCHA.NO_CAPTCHA", { context: { error: "Cannot select, no Captcha found in state" } });
+		if (state.index + 1 >= state.challenge.captchas.length) throw new _prosopo_common.ProsopoError("CAPTCHA.NO_CAPTCHA", { context: { error: "Cannot select, index is out of range for this Captcha" } });
+		updateState({ index: state.index + 1 });
+	};
+	const loadProviderApi = async (providerUrl) => {
+		const siteKey = getConfig().account.address;
+		if (!siteKey) throw new _prosopo_common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
+		return {
+			providerApi: new _prosopo_api.ProviderApi(providerUrl, siteKey),
+			siteKey
+		};
+	};
+	const clearTimeout = () => {
+		window.clearTimeout(Number(state.timeout));
+		updateState({ timeout: void 0 });
+	};
+	const setValidChallengeTimeout = () => {
+		const timeMillis = configOptional.captchas.image.solutionTimeout;
+		const successfullChallengeTimeout = setTimeout(() => {
+			updateState({ isHuman: false });
+			events.onExpired();
+		}, timeMillis);
+		updateState({ successfullChallengeTimeout });
+	};
+	const resetState = (frictionlessRestart) => {
+		clearTimeout();
+		updateState(defaultState());
+		events.onReset();
+		if (frictionlessRestart) frictionlessRestart();
+	};
+	/**
+	* Load the account using address specified in config, or generate new address if not found in local storage for web2 mode.
+	*/
+	const loadAccount = async () => {
+		const config = getConfig();
+		if (!config.web2 && !config.userAccountAddress) throw new _prosopo_common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", { context: { error: "Account address has not been set for web3 mode" } });
+		const selectAccount = async () => {
+			const ext = new (await ((0, _prosopo_procaptcha_common.ExtensionLoader)(config.web2)))();
+			if (frictionlessState) return frictionlessState.userAccount;
+			return await ext.getAccount(config);
+		};
+		const account = await selectAccount();
+		updateState({ account });
+		return getAccount();
+	};
+	const getAccount = () => {
+		if (!state.account) throw new _prosopo_common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", { context: { error: "Account not loaded" } });
+		return state.account;
+	};
+	const getDappAccount = () => {
+		if (!state.dappAccount) throw new _prosopo_common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
+		return state.dappAccount;
+	};
+	const getExtension = (account) => {
+		if (!account.extension) throw new _prosopo_common.ProsopoEnvError("ACCOUNT.NO_POLKADOT_EXTENSION", { context: { error: "Extension not loaded" } });
+		return account.extension;
+	};
+	return {
+		start,
+		cancel,
+		submit,
+		select,
+		nextRound,
+		reload
+	};
 }
+//#endregion
 exports.Manager = Manager;