@prosopo/procaptcha-pow 2.10.23 → 2.10.25

package/dist/cjs/services/Manager.cjs

@@ -1,279 +1,195 @@
-"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 fingerprint = require("@prosopo/fingerprint");
-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, onEscalate, getHoneypotValue) => {
-  const events = procaptchaCommon.getDefaultEvents(callbacks);
-  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();
-    }
-  };
-  const setValidChallengeTimeout = () => {
-    const timeMillis = getConfig().captchas.pow.solutionTimeout;
-    const successfullChallengeTimeout = setTimeout(() => {
-      updateState({ isHuman: false });
-      events.onExpired();
-      resetState(frictionlessState?.restart);
-    }, timeMillis);
-    updateState({ successfullChallengeTimeout });
-  };
-  let checkboxClickX = 0;
-  let checkboxClickY = 0;
-  const start = async (x = 0, y = 0) => {
-    checkboxClickX = x;
-    checkboxClickY = 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.getPowCaptchaChallenge(
-          userAccount,
-          getDappAccount(),
-          frictionlessState?.sessionId,
-          simdReadingsOnChallenge
-        );
-        if (challenge.error) {
-          updateState({
-            loading: false,
-            error: {
-              message: challenge.error.message,
-              key: challenge.error.key || "API.UNKNOWN_ERROR"
-            }
-          });
-        } else {
-          const solution = await util.solvePoW(
-            challenge.challenge,
-            challenge.difficulty
-          );
-          let salt;
-          if (x !== void 0 && y !== void 0) {
-            const coords = [x, y];
-            const randomSalt = utilCrypto.randomAsHex(
-              coords.map((coord) => coord.toString(16).length + 4).reduce((acc, curr) => acc + curr, 0)
-            );
-            salt = util.embedData(randomSalt, coords);
-          }
-          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: userAccount,
-            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 {
-            }
-          }
-          const simdReadings = frictionlessState?.getSimdReadings ? await frictionlessState.getSimdReadings() : void 0;
-          const hpValue = getHoneypotValue?.();
-          const clientMetaData = hpValue ? { hp: hpValue } : void 0;
-          let fingerprintProof;
-          try {
-            fingerprintProof = fingerprint.encodeFingerprintProof(
-              await fingerprint.getFingerprintProof(fingerprint.FINGERPRINT_DISCLOSURE_KEYS)
-            );
-          } catch {
-            fingerprintProof = void 0;
-          }
-          const fpTest = globalThis.__prosopoFingerprintProofTest__;
-          if (fpTest === "omit") {
-            fingerprintProof = void 0;
-          } else if (typeof fpTest === "string" && fpTest.length > 0) {
-            fingerprintProof = "invalid-fingerprint-proof";
-          }
-          const verifiedSolution = await providerApi.submitPowCaptchaSolution(
-            challenge,
-            getAccount().account.account.address,
-            getDappAccount(),
-            solution,
-            userTimestampSignature.signature.toString(),
-            encryptedBehavioralData,
-            salt,
-            simdReadings,
-            clientMetaData,
-            fingerprintProof
-          );
-          const escalation = verifiedSolution[types.ApiParams.escalation];
-          if (escalation && (escalation[types.ApiParams.captchaType] === types.CaptchaType.image || escalation[types.ApiParams.captchaType] === types.CaptchaType.puzzle)) {
-            updateState({ loading: false });
-            const isRealClick = checkboxClickX !== 0 || checkboxClickY !== 0;
-            onEscalate?.(
-              escalation[types.ApiParams.captchaType],
-              escalation[types.ApiParams.sessionId],
-              isRealClick ? { x: checkboxClickX, y: checkboxClickY } : void 0
-            );
-          } else 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.nonce]: solution,
-                [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.pow
-              })
-            );
-            setValidChallengeTimeout();
-          } else {
-            onFailed();
-          }
-        }
-      },
-      start,
-      () => {
-        resetState();
-      },
-      state.attemptCount,
-      3
-    );
-  };
-  return {
-    start,
-    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_fingerprint = require("@prosopo/fingerprint");
+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, onEscalate, getHoneypotValue) => {
+	const events = (0, _prosopo_procaptcha_common.getDefaultEvents)(callbacks);
+	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();
+	};
+	const setValidChallengeTimeout = () => {
+		const timeMillis = getConfig().captchas.pow.solutionTimeout;
+		const successfullChallengeTimeout = setTimeout(() => {
+			updateState({ isHuman: false });
+			events.onExpired();
+			resetState(frictionlessState?.restart);
+		}, timeMillis);
+		updateState({ successfullChallengeTimeout });
+	};
+	let checkboxClickX = 0;
+	let checkboxClickY = 0;
+	const start = async (x = 0, y = 0) => {
+		checkboxClickX = x;
+		checkboxClickY = y;
+		await (0, _prosopo_procaptcha_common.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;
+				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.getPowCaptchaChallenge(userAccount, getDappAccount(), frictionlessState?.sessionId, simdReadingsOnChallenge);
+			if (challenge.error) updateState({
+				loading: false,
+				error: {
+					message: challenge.error.message,
+					key: challenge.error.key || "API.UNKNOWN_ERROR"
+				}
+			});
+			else {
+				const solution = await (0, _prosopo_util.solvePoW)(challenge.challenge, challenge.difficulty);
+				let salt;
+				if (x !== void 0 && y !== void 0) {
+					const coords = [x, y];
+					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 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: userAccount,
+					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 {}
+				const simdReadings = await (0, _prosopo_procaptcha_common.getSimdReadingsForSubmit)(frictionlessState);
+				const hpValue = getHoneypotValue?.();
+				const clientMetaData = hpValue ? { hp: hpValue } : void 0;
+				let fingerprintProof;
+				try {
+					fingerprintProof = (0, _prosopo_fingerprint.encodeFingerprintProof)(await (0, _prosopo_fingerprint.getFingerprintProof)(_prosopo_fingerprint.FINGERPRINT_DISCLOSURE_KEYS));
+				} catch {
+					fingerprintProof = void 0;
+				}
+				const fpTest = globalThis.__prosopoFingerprintProofTest__;
+				if (fpTest === "omit") fingerprintProof = void 0;
+				else if (typeof fpTest === "string" && fpTest.length > 0) fingerprintProof = "invalid-fingerprint-proof";
+				const verifiedSolution = await providerApi.submitPowCaptchaSolution(challenge, getAccount().account.account.address, getDappAccount(), solution, userTimestampSignature.signature.toString(), encryptedBehavioralData, salt, simdReadings, clientMetaData, fingerprintProof);
+				const escalation = verifiedSolution[_prosopo_types.ApiParams.escalation];
+				if (escalation && (escalation[_prosopo_types.ApiParams.captchaType] === _prosopo_types.CaptchaType.image || escalation[_prosopo_types.ApiParams.captchaType] === _prosopo_types.CaptchaType.puzzle)) {
+					updateState({ loading: false });
+					const isRealClick = checkboxClickX !== 0 || checkboxClickY !== 0;
+					onEscalate?.(escalation[_prosopo_types.ApiParams.captchaType], escalation[_prosopo_types.ApiParams.sessionId], isRealClick ? {
+						x: checkboxClickX,
+						y: checkboxClickY
+					} : void 0);
+				} else if (verifiedSolution[_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.nonce]: solution,
+						[_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.pow
+					}));
+					setValidChallengeTimeout();
+				} else onFailed();
+			}
+		}, () => start(x, y), () => {
+			resetState();
+		}, state.attemptCount, 3);
+	};
+	return {
+		start,
+		resetState
+	};
 };
+//#endregion
 exports.Manager = Manager;

package/dist/components/ProcaptchaPoW.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 ProcaptchaPow = (props) => /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ProcaptchaWidget, { ...props }) });
-export {
-  ProcaptchaPow
-};
+//#region src/components/ProcaptchaPoW.tsx
+var ProcaptchaWidget = lazy(async () => import("./ProcaptchaWidget.js"));
+var ProcaptchaPow = (props) => /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ProcaptchaWidget, { ...props }) });
+//#endregion
+export { ProcaptchaPow };

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,EAAY,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAQhE,QAAA,MAAM,UAAU,UAAW,eAAe,4DAwKzC,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"ProcaptchaWidget.d.ts","sourceRoot":"","sources":["../../src/components/ProcaptchaWidget.tsx"],"names":[],"mappings":"AAiBA,OAAO,EAAY,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAQhE,QAAA,MAAM,UAAU,UAAW,eAAe,4DAyLzC,CAAC;AAEF,eAAe,UAAU,CAAC"}