@prosopo/procaptcha-puzzle 2.10.39 → 2.10.41

package/dist/cjs/services/Manager.cjs

@@ -1,291 +1,211 @@
-"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 Manager = (configInput, state, onStateUpdate, callbacks, frictionlessState, getHoneypotValue) => {
-  const events = procaptchaCommon.getDefaultEvents(callbacks);
-  let storedChallengeResponse;
-  let storedProviderApi;
-  let storedProviderUrl;
-  let storedUser;
-  let storedClickX;
-  let storedClickY;
-  let previousProviderUrl;
-  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 clearTimeout = () => {
-    window.clearTimeout(Number(state.timeout));
-    updateState({ timeout: void 0 });
-  };
-  const onFailed = () => {
-    updateState({
-      isHuman: false,
-      loading: false
-    });
-    events.onFailed();
-    resetState(frictionlessState?.restart);
-  };
-  const clearSuccessfulChallengeTimeout = () => {
-    window.clearTimeout(Number(state.successfullChallengeTimeout));
-    updateState({ successfullChallengeTimeout: void 0 });
-  };
-  const getConfig = () => {
-    const config = {
-      userAccountAddress: configInput.userAccountAddress || "",
-      ...configInput
-    };
-    if (state.account) {
-      config.userAccountAddress = state.account.account.address;
-    }
-    return types.ProcaptchaConfigSchema.parse(config);
-  };
-  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 updateState = procaptchaCommon.buildUpdateState(state, onStateUpdate);
-  const resetState = (frictionlessRestart) => {
-    clearTimeout();
-    clearSuccessfulChallengeTimeout();
-    updateState(defaultState());
-    events.onReset();
-    if (frictionlessRestart) {
-      frictionlessRestart();
-    }
-    storedChallengeResponse = void 0;
-    storedProviderApi = void 0;
-    storedProviderUrl = void 0;
-    storedUser = void 0;
-    storedClickX = void 0;
-    storedClickY = void 0;
-  };
-  const setValidChallengeTimeout = () => {
-    const timeMillis = getConfig().captchas.puzzle.solutionTimeout;
-    const successfullChallengeTimeout = setTimeout(() => {
-      updateState({ isHuman: false });
-      events.onExpired();
-      resetState(frictionlessState?.restart);
-    }, timeMillis);
-    updateState({ successfullChallengeTimeout });
-  };
-  const start = async (x = 0, y = 0) => {
-    storedClickX = x;
-    storedClickY = y;
-    await procaptchaCommon.providerRetry(
-      async () => {
-        if (state.loading) {
-          return;
-        }
-        if (state.isHuman) {
-          return;
-        }
-        resetState();
-        updateState({
-          loading: true
-        });
-        updateState({ attemptCount: state.attemptCount + 1 });
-        const config = getConfig();
-        const selectAccount = async () => {
-          if (frictionlessState) {
-            return frictionlessState.userAccount;
-          }
-          const ext = new (await procaptchaCommon.ExtensionLoader(config.web2))();
-          return ext.getAccount(config);
-        };
-        const user = await selectAccount();
-        const userAccount = user.account.address;
-        updateState({
-          account: { account: { address: userAccount } }
-        });
-        updateState({ dappAccount: config.account.address });
-        await util.sleep(100);
-        if (!config.web2 && !config.userAccountAddress) {
-          throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
-            context: {
-              error: "Account address has not been set for web3 mode"
-            }
-          });
-        }
-        let getRandomProviderResponse = void 0;
-        if (frictionlessState?.provider) {
-          getRandomProviderResponse = frictionlessState.provider;
-        } else {
-          const currentConfig = getConfig();
-          getRandomProviderResponse = await procaptchaCommon.getProcaptchaRandomActiveProvider(
-            currentConfig.defaultEnvironment,
-            procaptchaCommon.pickIpMode(currentConfig),
-            { attempt: state.attemptCount, excludeUrl: previousProviderUrl }
-          );
-        }
-        const providerUrl = getRandomProviderResponse.provider.url;
-        previousProviderUrl = providerUrl;
-        const providerApi = new api.ProviderApi(providerUrl, getDappAccount());
-        const simdReadingsOnChallenge = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings(0) : void 0;
-        const challenge = await providerApi.getPuzzleCaptchaChallenge(
-          userAccount,
-          getDappAccount(),
-          frictionlessState?.sessionId,
-          simdReadingsOnChallenge
-        );
-        if (challenge.error) {
-          updateState({
-            loading: false,
-            error: {
-              message: challenge.error.message,
-              key: challenge.error.key || "API.UNKNOWN_ERROR"
-            }
-          });
-          return;
-        }
-        storedChallengeResponse = challenge;
-        storedProviderApi = providerApi;
-        storedProviderUrl = providerUrl;
-        storedUser = user;
-        updateState({
-          loading: false
-        });
-      },
-      async () => {
-        await start();
-      },
-      () => {
-        resetState();
-      },
-      state.attemptCount,
-      3
-    );
-    return storedChallengeResponse;
-  };
-  const submitSolution = async (finalX, finalY, puzzleEvents) => {
-    if (!storedChallengeResponse || !storedProviderApi || !storedProviderUrl || !storedUser) {
-      throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
-        context: { error: "No challenge data available. Call start() first." }
-      });
-    }
-    updateState({ loading: true });
-    try {
-      const challenge = storedChallengeResponse;
-      const providerApi = storedProviderApi;
-      const providerUrl = storedProviderUrl;
-      const user = storedUser;
-      const config = getConfig();
-      const signer = user.extension?.signer;
-      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: user.account.address,
-        data: string.stringToHex(challenge[types.ApiParams.timestamp].toString()),
-        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 {
-        }
-      }
-      let salt;
-      if (storedClickX !== void 0 && storedClickY !== void 0) {
-        const coords = [storedClickX, storedClickY];
-        const randomSalt = utilCrypto.randomAsHex(
-          coords.map((coord) => coord.toString(16).length + 4).reduce((acc, curr) => acc + curr, 0)
-        );
-        salt = util.embedData(randomSalt, coords);
-      }
-      const simdReadings = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings() : void 0;
-      const hpValue = getHoneypotValue?.();
-      const clientMetaData = hpValue ? { hp: hpValue } : void 0;
-      const verifiedSolution = await providerApi.submitPuzzleCaptchaSolution(
-        challenge,
-        getAccount().account.account.address,
-        getDappAccount(),
-        finalX,
-        finalY,
-        puzzleEvents,
-        userTimestampSignature.signature.toString(),
-        encryptedBehavioralData,
-        salt,
-        simdReadings,
-        clientMetaData
-      );
-      if (verifiedSolution[types.ApiParams.verified]) {
-        updateState({
-          isHuman: true,
-          loading: false
-        });
-        events.onHuman(
-          types.encodeProcaptchaOutput({
-            [types.ApiParams.providerUrl]: providerUrl,
-            [types.ApiParams.user]: getAccount().account.account.address,
-            [types.ApiParams.dapp]: getDappAccount(),
-            [types.ApiParams.challenge]: challenge.challenge,
-            [types.ApiParams.timestamp]: challenge.timestamp,
-            [types.ApiParams.signature]: {
-              [types.ApiParams.provider]: challenge.signature.provider,
-              [types.ApiParams.user]: {
-                [types.ApiParams.timestamp]: userTimestampSignature.signature.toString()
-              }
-            },
-            [types.ApiParams.captchaType]: types.CaptchaType.puzzle
-          })
-        );
-        setValidChallengeTimeout();
-        return true;
-      }
-      onFailed();
-      return false;
-    } catch (error) {
-      updateState({ loading: false });
-      throw error;
-    }
-  };
-  return {
-    start,
-    submitSolution,
-    resetState
-  };
+let _prosopo_procaptcha_common = require("@prosopo/procaptcha-common");
+let _prosopo_types = require("@prosopo/types");
+let _polkadot_util_string = require("@polkadot/util/string");
+let _prosopo_api = require("@prosopo/api");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_util = require("@prosopo/util");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+//#region src/services/Manager.ts
+var Manager = (configInput, state, onStateUpdate, callbacks, frictionlessState, getHoneypotValue) => {
+	const events = (0, _prosopo_procaptcha_common.getDefaultEvents)(callbacks);
+	let storedChallengeResponse;
+	let storedProviderApi;
+	let storedProviderUrl;
+	let storedUser;
+	let storedClickX;
+	let storedClickY;
+	let previousProviderUrl;
+	const defaultState = () => {
+		return {
+			showModal: false,
+			loading: false,
+			index: 0,
+			challenge: void 0,
+			solutions: void 0,
+			isHuman: false,
+			captchaApi: void 0,
+			account: void 0
+		};
+	};
+	const clearTimeout = () => {
+		window.clearTimeout(Number(state.timeout));
+		updateState({ timeout: void 0 });
+	};
+	const onFailed = () => {
+		updateState({
+			isHuman: false,
+			loading: false
+		});
+		events.onFailed();
+		resetState(frictionlessState?.restart);
+	};
+	const clearSuccessfulChallengeTimeout = () => {
+		window.clearTimeout(Number(state.successfullChallengeTimeout));
+		updateState({ successfullChallengeTimeout: void 0 });
+	};
+	const getConfig = () => {
+		const config = {
+			userAccountAddress: configInput.userAccountAddress || "",
+			...configInput
+		};
+		if (state.account) config.userAccountAddress = state.account.account.address;
+		return _prosopo_types.ProcaptchaConfigSchema.parse(config);
+	};
+	const getAccount = () => {
+		if (!state.account) throw new _prosopo_common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", { context: { error: "Account not loaded" } });
+		return { account: state.account };
+	};
+	const getDappAccount = () => {
+		if (!state.dappAccount) throw new _prosopo_common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
+		return state.dappAccount;
+	};
+	const updateState = (0, _prosopo_procaptcha_common.buildUpdateState)(state, onStateUpdate);
+	const resetState = (frictionlessRestart) => {
+		clearTimeout();
+		clearSuccessfulChallengeTimeout();
+		updateState(defaultState());
+		events.onReset();
+		if (frictionlessRestart) frictionlessRestart();
+		storedChallengeResponse = void 0;
+		storedProviderApi = void 0;
+		storedProviderUrl = void 0;
+		storedUser = void 0;
+		storedClickX = void 0;
+		storedClickY = void 0;
+	};
+	const setValidChallengeTimeout = () => {
+		const timeMillis = getConfig().captchas.puzzle.solutionTimeout;
+		const successfullChallengeTimeout = setTimeout(() => {
+			updateState({ isHuman: false });
+			events.onExpired();
+			resetState(frictionlessState?.restart);
+		}, timeMillis);
+		updateState({ successfullChallengeTimeout });
+	};
+	const start = async (x = 0, y = 0) => {
+		await (0, _prosopo_procaptcha_common.providerRetry)(async () => {
+			if (state.loading) return;
+			if (state.isHuman) return;
+			resetState();
+			storedClickX = x;
+			storedClickY = y;
+			updateState({ loading: true });
+			updateState({ attemptCount: state.attemptCount + 1 });
+			const config = getConfig();
+			const selectAccount = async () => {
+				if (frictionlessState) return frictionlessState.userAccount;
+				return new (await ((0, _prosopo_procaptcha_common.ExtensionLoader)(config.web2)))().getAccount(config);
+			};
+			const user = await selectAccount();
+			const userAccount = user.account.address;
+			updateState({ account: { account: { address: userAccount } } });
+			updateState({ dappAccount: config.account.address });
+			await (0, _prosopo_util.sleep)(100);
+			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" } });
+			let getRandomProviderResponse = void 0;
+			if (frictionlessState?.provider) getRandomProviderResponse = frictionlessState.provider;
+			else {
+				const currentConfig = getConfig();
+				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 = new _prosopo_api.ProviderApi(providerUrl, getDappAccount());
+			const simdReadingsOnChallenge = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings(0) : void 0;
+			const challenge = await providerApi.getPuzzleCaptchaChallenge(userAccount, getDappAccount(), frictionlessState?.sessionId, simdReadingsOnChallenge);
+			if (challenge.error) {
+				updateState({
+					loading: false,
+					error: {
+						message: challenge.error.message,
+						key: challenge.error.key || "API.UNKNOWN_ERROR"
+					}
+				});
+				return;
+			}
+			storedChallengeResponse = challenge;
+			storedProviderApi = providerApi;
+			storedProviderUrl = providerUrl;
+			storedUser = user;
+			updateState({ loading: false });
+		}, async () => {
+			await start(x, y);
+		}, () => {
+			resetState();
+		}, state.attemptCount, 3);
+		return storedChallengeResponse;
+	};
+	const submitSolution = async (finalX, finalY, puzzleEvents) => {
+		if (!storedChallengeResponse || !storedProviderApi || !storedProviderUrl || !storedUser) throw new _prosopo_common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", { context: { error: "No challenge data available. Call start() first." } });
+		updateState({ loading: true });
+		try {
+			const challenge = storedChallengeResponse;
+			const providerApi = storedProviderApi;
+			const providerUrl = storedProviderUrl;
+			const user = storedUser;
+			getConfig();
+			const signer = user.extension?.signer;
+			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: user.account.address,
+				data: (0, _polkadot_util_string.stringToHex)(challenge[_prosopo_types.ApiParams.timestamp].toString()),
+				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 {}
+			let salt;
+			if (storedClickX !== void 0 && storedClickY !== void 0) {
+				const coords = [storedClickX, storedClickY];
+				const randomSalt = (0, _prosopo_util_crypto.randomAsHex)(coords.map((coord) => coord.toString(16).length + 4).reduce((acc, curr) => acc + curr, 0));
+				salt = (0, _prosopo_util.embedData)(randomSalt, coords);
+			}
+			const simdReadings = await (0, _prosopo_procaptcha_common.getSimdReadingsForSubmit)(frictionlessState);
+			const hpValue = getHoneypotValue?.();
+			const clientMetaData = hpValue ? { hp: hpValue } : void 0;
+			if ((await providerApi.submitPuzzleCaptchaSolution(challenge, getAccount().account.account.address, getDappAccount(), finalX, finalY, puzzleEvents, userTimestampSignature.signature.toString(), encryptedBehavioralData, salt, simdReadings, clientMetaData))[_prosopo_types.ApiParams.verified]) {
+				updateState({
+					isHuman: true,
+					loading: false
+				});
+				events.onHuman((0, _prosopo_types.encodeProcaptchaOutput)({
+					[_prosopo_types.ApiParams.providerUrl]: providerUrl,
+					[_prosopo_types.ApiParams.user]: getAccount().account.account.address,
+					[_prosopo_types.ApiParams.dapp]: getDappAccount(),
+					[_prosopo_types.ApiParams.challenge]: challenge.challenge,
+					[_prosopo_types.ApiParams.timestamp]: challenge.timestamp,
+					[_prosopo_types.ApiParams.signature]: {
+						[_prosopo_types.ApiParams.provider]: challenge.signature.provider,
+						[_prosopo_types.ApiParams.user]: { [_prosopo_types.ApiParams.timestamp]: userTimestampSignature.signature.toString() }
+					},
+					[_prosopo_types.ApiParams.captchaType]: _prosopo_types.CaptchaType.puzzle
+				}));
+				setValidChallengeTimeout();
+				return true;
+			}
+			onFailed();
+			return false;
+		} catch (error) {
+			updateState({ loading: false });
+			throw error;
+		}
+	};
+	return {
+		start,
+		submitSolution,
+		resetState
+	};
 };
+//#endregion
 exports.Manager = Manager;

package/dist/components/ProcaptchaPuzzle.js

@@ -1,9 +1,7 @@
+import { Suspense, lazy } from "react";
 import { jsx } from "@emotion/react/jsx-runtime";
-import { lazy, Suspense } from "react";
-const ProcaptchaWidget = lazy(
-  async () => import("./ProcaptchaWidget.js")
-);
-const ProcaptchaPuzzle = (props) => /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ProcaptchaWidget, { ...props }) });
-export {
-  ProcaptchaPuzzle
-};
+//#region src/components/ProcaptchaPuzzle.tsx
+var ProcaptchaWidget = lazy(async () => import("./ProcaptchaWidget.js"));
+var ProcaptchaPuzzle = (props) => /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ProcaptchaWidget, { ...props }) });
+//#endregion
+export { ProcaptchaPuzzle };

package/dist/components/ProcaptchaWidget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProcaptchaWidget.d.ts","sourceRoot":"","sources":["../../src/components/ProcaptchaWidget.tsx"],"names":[],"mappings":"AAiBA,OAAO,EAGN,KAAK,eAAe,EAEpB,MAAM,gBAAgB,CAAC;AAWxB,QAAA,MAAM,UAAU,UAAW,eAAe,qDA+PzC,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"ProcaptchaWidget.d.ts","sourceRoot":"","sources":["../../src/components/ProcaptchaWidget.tsx"],"names":[],"mappings":"AAiBA,OAAO,EAGN,KAAK,eAAe,EAEpB,MAAM,gBAAgB,CAAC;AAWxB,QAAA,MAAM,UAAU,UAAW,eAAe,qDA0QzC,CAAC;AAEF,eAAe,UAAU,CAAC"}