@prosopo/procaptcha-pow 2.13.7 → 2.13.8

package/src/services/Manager.ts

@@ -1,482 +0,0 @@
-// Copyright 2021-2026 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.
-
-import { stringToHex } from "@polkadot/util/string";
-import { ProviderApi } from "@prosopo/api";
-import { ProsopoEnvError } from "@prosopo/common";
-import {
-	FINGERPRINT_DISCLOSURE_KEYS,
-	encodeFingerprintProof,
-	getFingerprintProof,
-} from "@prosopo/fingerprint";
-import {
-	ExtensionLoader,
-	buildClientMetaData,
-	buildUpdateState,
-	getDefaultEvents,
-	getProcaptchaRandomActiveProvider,
-	getSimdReadingsForSubmit,
-	pickIpMode,
-	providerRetry,
-} from "@prosopo/procaptcha-common";
-import {
-	type Account,
-	ApiParams,
-	CaptchaType,
-	type FrictionlessState,
-	type ProcaptchaCallbacks,
-	type ProcaptchaClientConfigInput,
-	ProcaptchaConfigSchema,
-	type ProcaptchaEscalationHandler,
-	type ProcaptchaState,
-	type ProcaptchaStateUpdateFn,
-	encodeProcaptchaOutput,
-} from "@prosopo/types";
-import { embedData, sleep } from "@prosopo/util";
-import { solvePoW } from "@prosopo/util";
-import { randomAsHex } from "@prosopo/util-crypto";
-
-export const Manager = (
-	configInput: ProcaptchaClientConfigInput,
-	state: ProcaptchaState,
-	onStateUpdate: ProcaptchaStateUpdateFn,
-	callbacks: ProcaptchaCallbacks,
-	frictionlessState?: FrictionlessState,
-	onEscalate?: ProcaptchaEscalationHandler,
-	// Reads the live honeypot input value at submit time. Returns undefined
-	// when the input doesn't exist (honeypot disabled) or hasn't been filled.
-	// Bots that auto-fill text inputs populate it; humans never see it.
-	getHoneypotValue?: () => string | undefined,
-) => {
-	const events = getDefaultEvents(callbacks);
-
-	// URL of the provider used on the previous attempt. On a retry we exclude it
-	// from the candidate pool so the fallback lands on a different provider.
-	let previousProviderUrl: string | undefined;
-
-	const defaultState = (): Partial<ProcaptchaState> => {
-		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: undefined,
-			solutions: undefined,
-			isHuman: false,
-			captchaApi: undefined,
-			account: undefined,
-			// don't handle timeout here, this should be handled by the state management
-		};
-	};
-
-	const clearTimeout = () => {
-		// clear the timeout
-		window.clearTimeout(Number(state.timeout));
-		// then clear the timeout from the state
-		updateState({ timeout: undefined });
-	};
-
-	const onFailed = () => {
-		updateState({
-			isHuman: false,
-			loading: false,
-		});
-		events.onFailed();
-		resetState(frictionlessState?.restart);
-	};
-
-	const clearSuccessfulChallengeTimeout = () => {
-		// clear the timeout
-		window.clearTimeout(Number(state.successfullChallengeTimeout));
-		// then clear the timeout from the state
-		updateState({ successfullChallengeTimeout: undefined });
-	};
-
-	const getConfig = () => {
-		const config: ProcaptchaClientConfigInput = {
-			userAccountAddress: configInput.userAccountAddress || "",
-			...configInput,
-		};
-
-		// overwrite the account in use with the one in state if it exists. Reduces likelihood of bugs where the user
-		// changes account in the middle of the captcha process.
-		if (state.account) {
-			config.userAccountAddress = state.account.account.address;
-		}
-
-		return ProcaptchaConfigSchema.parse(config);
-	};
-
-	const getAccount = () => {
-		if (!state.account) {
-			throw new ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
-				context: { error: "Account not loaded" },
-			});
-		}
-		const account: Account = state.account;
-		return { account };
-	};
-
-	const getDappAccount = () => {
-		if (!state.dappAccount) {
-			throw new ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
-		}
-
-		const dappAccount: string = state.dappAccount;
-		return dappAccount;
-	};
-
-	// get the state update mechanism
-	const updateState = buildUpdateState(state, onStateUpdate);
-
-	const resetState = (frictionlessRestart?: () => void) => {
-		// clear timeout just in case a timer is still active (shouldn't be)
-		clearTimeout();
-		clearSuccessfulChallengeTimeout();
-		updateState(defaultState());
-		events.onReset();
-		// reset the frictionless state if necessary
-		if (frictionlessRestart) {
-			frictionlessRestart();
-		}
-	};
-
-	const setValidChallengeTimeout = () => {
-		const timeMillis: number = getConfig().captchas.pow.solutionTimeout;
-		const successfullChallengeTimeout = setTimeout(() => {
-			if (disposed) return;
-			// Human state expired, disallow user's claim to be human
-			updateState({ isHuman: false });
-
-			events.onExpired();
-			resetState(frictionlessState?.restart);
-		}, timeMillis);
-
-		updateState({ successfullChallengeTimeout });
-	};
-
-	// Checkbox click coords captured on the entry-point tick (or forwarded
-	// from a session-invalidated retry). Persisted in the closure so an
-	// eventual escalation can hand them to the escalated image/puzzle widget
-	// via `onEscalate` — otherwise the escalated widget seeds (0, 0) into
-	// its own salt and the entry-point telemetry is lost across the hop.
-	let checkboxClickX = 0;
-	let checkboxClickY = 0;
-
-	const start = async (x = 0, y = 0) => {
-		checkboxClickX = x;
-		checkboxClickY = y;
-		await providerRetry(
-			async () => {
-				if (state.loading) {
-					return;
-				}
-				if (state.isHuman) {
-					return;
-				}
-
-				// reset the state to defaults - do not reset the frictionless state
-				resetState();
-
-				// set the loading flag to true (allow UI to show some sort of loading / pending indicator while we get the captcha process going)
-				updateState({
-					loading: true,
-				});
-				updateState({ attemptCount: state.attemptCount + 1 });
-
-				const config = getConfig();
-
-				// check if account exists in extension
-				const selectAccount = async () => {
-					if (frictionlessState) {
-						return frictionlessState.userAccount;
-					}
-					const ext = new (await ExtensionLoader(config.web2))();
-					return ext.getAccount(config);
-				};
-
-				// use the passed in account (could be web3) or create a new account
-				const user = await selectAccount();
-				const userAccount = user.account.address;
-
-				// set the account created or injected by the extension
-				updateState({
-					account: { account: { address: userAccount } },
-				});
-
-				// snapshot the config into the state
-				updateState({ dappAccount: config.account.address });
-
-				// allow UI to catch up with the loading state
-				await sleep(100);
-
-				// check if account has been provided in config (doesn't matter in web2 mode)
-				if (!config.web2 && !config.userAccountAddress) {
-					throw new ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
-						context: {
-							error: "Account address has not been set for web3 mode",
-						},
-					});
-				}
-
-				let getRandomProviderResponse = undefined;
-
-				if (frictionlessState?.provider) {
-					getRandomProviderResponse = frictionlessState.provider;
-				} else {
-					const currentConfig = getConfig();
-					getRandomProviderResponse = await getProcaptchaRandomActiveProvider(
-						currentConfig.defaultEnvironment,
-						pickIpMode(currentConfig),
-						{ attempt: state.attemptCount, excludeUrl: previousProviderUrl },
-					);
-				}
-
-				const providerUrl = getRandomProviderResponse.provider.url;
-				previousProviderUrl = providerUrl;
-
-				const providerApi = new ProviderApi(providerUrl, getDappAccount());
-
-				// Non-blocking check (timeoutMs=0): only attach SIMD readings if
-				// the benchmark prefetched by the catcher has already resolved.
-				// We want this signal as early as possible — first request that
-				// has it wins; later attach points (submission) are backups.
-				const simdReadingsOnChallenge = frictionlessState?.getSimdReadings
-					? await frictionlessState.getSimdReadings(0)
-					: undefined;
-				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 solvePoW(
-						challenge.challenge,
-						challenge.difficulty,
-					);
-
-					// Create salt with encoded coordinates if coordinates are provided
-					let salt: string | undefined;
-					if (x !== undefined && y !== undefined) {
-						const coords = [x, y];
-						const randomSalt = randomAsHex(
-							coords
-								.map((coord) => coord.toString(16).length + 4)
-								.reduce((acc, curr) => acc + curr, 0),
-						);
-						salt = embedData(randomSalt, coords);
-					}
-
-					const signer = user.extension?.signer;
-
-					if (!signer || !signer.signRaw) {
-						throw new 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: stringToHex(challenge[ApiParams.timestamp].toString()),
-						type: "bytes",
-					});
-
-					let encryptedBehavioralData: string | undefined;
-
-					// Collect and encrypt behavioral data before submission
-					if (
-						frictionlessState?.encryptBehavioralData &&
-						(frictionlessState?.behaviorCollector1 ||
-							frictionlessState?.behaviorCollector2 ||
-							frictionlessState?.behaviorCollector3 ||
-							frictionlessState?.behaviorCollector4)
-					) {
-						try {
-							const behavioralData = {
-								collector1:
-									frictionlessState.behaviorCollector1?.getData() || [],
-								collector2:
-									frictionlessState.behaviorCollector2?.getData() || [],
-								collector3:
-									frictionlessState.behaviorCollector3?.getData() || [],
-								collector4:
-									frictionlessState.behaviorCollector4?.getData() || [],
-								deviceCapability:
-									frictionlessState.deviceCapability || "unknown",
-							};
-
-							// Pack the behavioral data before stringifying
-							const dataToEncrypt = frictionlessState.packBehavioralData
-								? frictionlessState.packBehavioralData(behavioralData)
-								: behavioralData;
-
-							encryptedBehavioralData =
-								await frictionlessState.encryptBehavioralData(
-									JSON.stringify(dataToEncrypt),
-								);
-						} catch {
-							// Silently ignore behavioral data errors - captcha should still work
-						}
-					}
-
-					// Wait 5 secs for ongoing SIMD, else submit without
-					const simdReadings =
-						await getSimdReadingsForSubmit(frictionlessState);
-					const clientMetaData = buildClientMetaData(
-						getHoneypotValue?.(),
-						getConfig().clientSessionId,
-					);
-					// Best-effort proof of fingerprint; submission proceeds without it
-					// if a proof can't be produced (e.g. fingerprint unavailable).
-					// Only the validator-checked keys are disclosed to keep the
-					// payload small (see FINGERPRINT_DISCLOSURE_KEYS).
-					let fingerprintProof: string | undefined;
-					try {
-						fingerprintProof = encodeFingerprintProof(
-							await getFingerprintProof(FINGERPRINT_DISCLOSURE_KEYS),
-						);
-					} catch {
-						fingerprintProof = undefined;
-					}
-					// Test hook for exercising the provider's fingerprint failure
-					// path. In a browser console set:
-					//   window.__prosopoFingerprintProofTest__ = "malformed" // → image
-					//   window.__prosopoFingerprintProofTest__ = "omit"      // → image
-					// Never set in production; unset/any other value = normal proof.
-					const fpTest = (globalThis as Record<string, unknown>)
-						.__prosopoFingerprintProofTest__;
-					if (fpTest === "omit") {
-						fingerprintProof = undefined;
-					} 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,
-					);
-					if (disposed) return;
-					const escalation = verifiedSolution[ApiParams.escalation];
-					if (
-						escalation &&
-						(escalation[ApiParams.captchaType] === CaptchaType.image ||
-							escalation[ApiParams.captchaType] === CaptchaType.puzzle)
-					) {
-						// Provider accepted the PoW but wants the user to complete a
-						// follow-up image/puzzle challenge. Hand off to the wrapper —
-						// don't fire onHuman or onFailed; the wrapper mounts the next
-						// widget and the standard success/failure path resumes there.
-						//
-						// Forward the trusted checkbox coords captured on this widget's
-						// tick so the escalated widget seeds its salt with the real
-						// (x, y) rather than defaulting to (0, 0). Mirrors the
-						// session-invalidated retry path in ProcaptchaFrictionless.
-						updateState({ loading: false });
-						// (0, 0) is the untrusted-event / autoStart default —
-						// treat it as "no coords" so the escalated widget doesn't
-						// re-encode a fake click into its salt. Matches the
-						// filter applied in handleSessionInvalidated.
-						const isRealClick = checkboxClickX !== 0 || checkboxClickY !== 0;
-						onEscalate?.(
-							escalation[ApiParams.captchaType],
-							escalation[ApiParams.sessionId],
-							isRealClick
-								? { x: checkboxClickX, y: checkboxClickY }
-								: undefined,
-						);
-					} else if (verifiedSolution[ApiParams.verified]) {
-						updateState({
-							isHuman: true,
-							loading: false,
-						});
-
-						events.onHuman(
-							encodeProcaptchaOutput({
-								[ApiParams.providerUrl]: providerUrl,
-								[ApiParams.user]: getAccount().account.account.address,
-								[ApiParams.dapp]: getDappAccount(),
-								[ApiParams.challenge]: challenge.challenge,
-								[ApiParams.nonce]: solution,
-								[ApiParams.timestamp]: challenge.timestamp,
-								[ApiParams.signature]: {
-									[ApiParams.provider]: challenge.signature.provider,
-									[ApiParams.user]: {
-										[ApiParams.timestamp]:
-											userTimestampSignature.signature.toString(),
-									},
-								},
-								[ApiParams.captchaType]: CaptchaType.pow,
-							}),
-						);
-						setValidChallengeTimeout();
-					} else {
-						onFailed();
-					}
-				}
-			},
-			// Retry with the same coordinates: a bare `start` restarts at the
-			// default (0, 0), which reads as "no real click" further down and
-			// costs the escalated widget the entry-point telemetry.
-			() => start(x, y),
-			() => {
-				resetState();
-			},
-			state.attemptCount,
-			3,
-		);
-	};
-
-	// Set once the widget that owns this manager is torn down. A solve still in
-	// flight can land afterwards, so the timer callbacks check it as well as
-	// being cleared here.
-	let disposed = false;
-
-	/**
-	 * Stops this manager's challenge and solution-expiry timers without firing
-	 * any event. Left running after the widget is destroyed (reset(), a
-	 * restart, an SPA route change) they fired onExpired/onReset later on,
-	 * which also cleared the replacement widget's token from the form.
-	 */
-	const dispose = () => {
-		disposed = true;
-		window.clearTimeout(Number(state.timeout));
-		window.clearTimeout(Number(state.successfullChallengeTimeout));
-	};
-
-	return {
-		start,
-		resetState,
-		dispose,
-	};
-};

package/src/tests/domHarness.ts

@@ -1,122 +0,0 @@
-// Copyright 2021-2026 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.
-
-/**
- * A minimal mount/unmount harness. The suite deliberately drives real DOM
- * events rather than calling handlers directly, because every interactive
- * element in this package drops untrusted events — behaviour that only shows
- * up when a real event carries the flag.
- */
-export interface Mounted {
-	container: HTMLDivElement;
-	unmount: () => void;
-}
-
-export const mount = (): Mounted => {
-	const container = document.createElement("div");
-	document.body.appendChild(container);
-	return {
-		container,
-		unmount: () => {
-			container.remove();
-		},
-	};
-};
-
-interface FireOptions {
-	trusted?: boolean;
-	clientX?: number;
-	clientY?: number;
-	touches?: { clientX: number; clientY: number }[];
-	key?: string;
-}
-
-/**
- * jsdom marks everything it dispatches untrusted, and exposes `isTrusted` as a
- * non-configurable accessor onto its internal implementation object, so the
- * flag has to be set there rather than shadowed on the event. Anything the
- * components filter on untrusted events is untestable otherwise.
- */
-const setTrusted = (event: Event, trusted: boolean): void => {
-	for (const symbol of Object.getOwnPropertySymbols(event)) {
-		const impl: unknown = Reflect.get(event, symbol);
-		if (impl && typeof impl === "object" && "isTrusted" in impl) {
-			// A plain assignment would not survive: dispatchEvent stamps
-			// isTrusted back to false on the way in, so the flag is pinned with
-			// an accessor that swallows the write.
-			Object.defineProperty(impl, "isTrusted", {
-				configurable: true,
-				get: () => trusted,
-				set: () => undefined,
-			});
-			return;
-		}
-	}
-	throw new Error("could not reach the jsdom event implementation");
-};
-
-const build = (type: string, options: FireOptions): Event => {
-	if (undefined !== options.key) {
-		return new KeyboardEvent(type, {
-			bubbles: true,
-			cancelable: true,
-			key: options.key,
-		});
-	}
-	return new MouseEvent(type, {
-		bubbles: true,
-		cancelable: true,
-		clientX: options.clientX ?? 0,
-		clientY: options.clientY ?? 0,
-	});
-};
-
-/**
- * Dispatches a real event at the element. Touch points are plain objects:
- * jsdom has no Touch constructor.
- */
-export const fire = (
-	element: Element,
-	type: string,
-	options: FireOptions = {},
-): void => {
-	fireAndReturn(element, type, options);
-};
-
-/** Like `fire`, but hands back the event so a test can inspect what the
- * handler did to it — whether it prevented the default form submission, say. */
-export const fireAndReturn = (
-	element: Element,
-	type: string,
-	options: FireOptions = {},
-): Event => {
-	const event = build(type, options);
-	setTrusted(event, options.trusted ?? true);
-	if (options.touches) {
-		Object.defineProperty(event, "touches", { value: options.touches });
-	}
-	element.dispatchEvent(event);
-	return event;
-};
-
-/**
- * Renders coalesce onto the microtask queue, so a state change is not visible
- * in the DOM until it has drained.
- */
-export const settle = async (): Promise<void> => {
-	// A macrotask turn, so a pending dynamic import resolves too — draining the
-	// microtask queue alone is not enough for the code-split boundaries.
-	await new Promise<void>((resolve: () => void) => setTimeout(resolve, 0));
-	await Promise.resolve();
-};