@prosopo/procaptcha-frictionless 2.12.24 → 2.13.0

package/src/customDetectBot.ts

@@ -25,7 +25,16 @@ import type {
 	ProviderSelectRetryContext,
 } from "@prosopo/types";
 import type { BotDetectionFunctionResult } from "@prosopo/types";
-import { DetectorLoader } from "./detectorLoader.js";
+import {
+	DetectorLoaderFromScript,
+	type DetectorType,
+} from "./detectorLoader.js";
+
+// Upper bound on the detector-bundle assignment + load probe. The detector
+// lives ONLY in the provider-served pool bundles, so if the provider is
+// slow/unreachable we abandon the probe and signal `detectorUnavailable`, and
+// the provider serves a PoW challenge instead of running detection.
+const ASSIGN_TIMEOUT_MS = 2000;
 
 // The page(s) the widget is rendered on, reduced to origin + path.
 // Deliberately built from `origin` + `pathname` (never `href`) so the query
@@ -129,69 +138,36 @@ const customDetectBot: BotDetectionFunction = async (
 	restartFn: () => void,
 	retryContext?: ProviderSelectRetryContext,
 ): Promise<BotDetectionFunctionResult> => {
-	// Kick off the provider-pin resolution (which hits `/healthz` on the
-	// load-balancer DNS endpoint) in parallel with the module loaders and
-	// the whole `detect()` flow. `getProcaptchaRandomActiveProvider` is
-	// memoised via `pinPromiseCache` keyed on `(env, ipMode)`, so the
-	// in-flight promise is reused when catcher's internal provider selector
-	// and the awaited `getProcaptchaRandomActiveProvider(...)` below reach
-	// for it — no duplicate healthz request. Before this ordering change
-	// the healthz round-trip was fully serial with `detect()`, adding
-	// ~100–200ms to the frictionless critical path on cold DNS/TLS.
-	//
-	// We warm both cache keys because the catcher-internal selector call
-	// (line ~145 below) passes no ipMode, while the awaited call further
-	// down passes `pickIpMode(config)`. Same key when the dapp opts into
-	// neither ipv4 nor ipv6 (dual stack — the common case); different
-	// keys when the dapp is pinned to a single stack. Fire-and-forget on
-	// both — the real synchronisation happens at the awaits below.
-	const ipMode = pickIpMode(config);
-	void getProcaptchaRandomActiveProvider(config.defaultEnvironment).catch(
-		() => undefined,
-	);
-	if (ipMode !== undefined) {
-		void getProcaptchaRandomActiveProvider(
-			config.defaultEnvironment,
-			ipMode,
-			retryContext,
-		).catch(() => undefined);
-	}
-
-	const [ExtClass, detect] = await Promise.all([
-		ExtensionLoader(config.web2),
-		DetectorLoader(),
-	]);
-	const ext = new ExtClass();
-
-	// The detector bundle still expects the legacy 5-arg signature
-	// `(env, randomProviderSelectorFn, container, restart, accountGenerator)`.
-	// Until the bundle is rebuilt without the provider selector, hand it a
-	// noop selector that resolves to the static DNS endpoint — the detector
-	// no longer uses the returned RandomProvider for routing.
-	const detectionResult = await detect(
-		config.defaultEnvironment,
-		async () => getProcaptchaRandomActiveProvider(config.defaultEnvironment),
-		container,
-		restartFn,
-		() => ext.getAccount(config),
-	);
-
-	const userAccount = detectionResult.userAccount;
-
 	if (!config.account.address) {
 		throw new ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
 	}
 
+	const ipMode = pickIpMode(config);
+
+	// Start the extension/account module load now rather than after the bundle
+	// assignment. It depends on nothing above, so it overlaps the provider-pin
+	// `/healthz` round-trip and the assign request for free; it is awaited below
+	// at the point `ExtClass` is first needed.
+	//
+	// This is what survives of main's parallel-pin optimisation. That change
+	// warmed BOTH `pinPromiseCache` keys — with and without ipMode — because the
+	// catcher-internal provider selector called with no ipMode while the awaited
+	// call passed one. The 3-arg detector has no provider selector at all, so
+	// only the `(env, ipMode)` key is ever used now and warming the bare-env key
+	// would just issue a healthz request nothing consumes. Nor can the pin be
+	// moved off the critical path the way it was before: the detector now comes
+	// FROM the provider, so resolving the provider is a hard prerequisite of
+	// having anything to run, not something that can proceed alongside it.
+	const extClassPromise = ExtensionLoader(config.web2);
+
 	// On the first attempt this resolves the static DNS endpoint for this env —
 	// the DNS layer load-balances across the pronode fleet. On a retry
 	// (`retryContext.attempt > 1`) the previously used pronode errored, so we
 	// pick a random provider straight from the list instead of re-pinning the
 	// same one. `pickIpMode(config)` honours the dapp's data-ipv4 / data-ipv6
 	// preference so frictionless and the subsequent captcha hops stay on the
-	// same stack.
-	//
-	// This await usually hits the in-flight/resolved promise warmed at the
-	// top of this function — see the prefetch call there.
+	// same stack. Resolved up front — before detection rather than alongside it —
+	// because the detector bundle is served BY this provider.
 	const provider = await getProcaptchaRandomActiveProvider(
 		config.defaultEnvironment,
 		ipMode,
@@ -203,6 +179,87 @@ const customDetectBot: BotDetectionFunction = async (
 		config.account.address,
 	);
 
+	// Ask the provider for a per-session detector bundle. The detector lives ONLY
+	// in the provider-served pool: when the provider has a populated pool it
+	// returns the obfuscated detector (each with its own keys + inner cipher)
+	// plus a detectorSessionId. When it cannot (no pool, network, decode, or
+	// timeout) we have NO detector to run — there is no bundled fallback — so we
+	// signal `detectorUnavailable` and the provider serves a PoW challenge.
+	let detectorSessionId: string | undefined;
+	let providerDetect: DetectorType | undefined;
+	try {
+		const assigned = await withTimeout(
+			providerApi.assignDetectorBundle(config.account.address),
+			ASSIGN_TIMEOUT_MS,
+		);
+		if (assigned.useProviderBundle && assigned.detectorScript) {
+			detectorSessionId = assigned.detectorSessionId;
+			providerDetect = await withTimeout(
+				DetectorLoaderFromScript(assigned.detectorScript),
+				ASSIGN_TIMEOUT_MS,
+			);
+		}
+	} catch {
+		// No detector available — fall through to the PoW request below.
+	}
+
+	const ExtClass = await extClassPromise;
+	const ext = new ExtClass();
+
+	// No provider detector ⇒ no detection is possible. Request a PoW challenge
+	// directly: send no token and the detectorUnavailable flag so the provider
+	// serves PoW rather than attempting to score an absent payload.
+	if (providerDetect === undefined) {
+		const userAccount = await ext.getAccount(config);
+		const { currentUrl: fallbackUrl, iframeUrl: fallbackIframeUrl } =
+			getCurrentPageUrls();
+		const powCaptcha = await withTimeout(
+			providerApi.getFrictionlessCaptcha(
+				undefined,
+				undefined,
+				config.account.address,
+				userAccount.account.address,
+				config.mode,
+				undefined,
+				undefined,
+				true,
+				fallbackUrl,
+				fallbackIframeUrl,
+			),
+			10000,
+		);
+		if (powCaptcha.dns_url) {
+			try {
+				void fetch(powCaptcha.dns_url, {
+					method: "GET",
+					mode: "no-cors",
+					credentials: "omit",
+					keepalive: true,
+					cache: "no-store",
+				}).catch(() => undefined);
+			} catch {
+				/* swallow */
+			}
+		}
+		return {
+			captchaType: powCaptcha.captchaType,
+			sessionId: powCaptcha.sessionId,
+			provider: provider,
+			status: powCaptcha.status,
+			userAccount: userAccount,
+			error: powCaptcha.error,
+			hp: powCaptcha.hp,
+		};
+	}
+
+	const detect: DetectorType = providerDetect;
+
+	const detectionResult = await detect(container, restartFn, () =>
+		ext.getAccount(config),
+	);
+
+	const userAccount = detectionResult.userAccount;
+
 	// SIMD readings deliberately omitted from the frictionless hop. The WASM
 	// benchmark is a CPU-bound loop that contends with BotScoreWorker if it
 	// runs during detection; deferring it until after the POST is in flight
@@ -217,6 +274,8 @@ const customDetectBot: BotDetectionFunction = async (
 		userAccount.account.address,
 		config.mode,
 		undefined,
+		detectorSessionId,
+		undefined,
 		currentUrl,
 		iframeUrl,
 	);

package/src/detectorLoader.ts

@@ -12,7 +12,69 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-type DetectorType = typeof import("@prosopo/detector").default;
+import type {
+	Account,
+	BehavioralData,
+	ClickEventPoint,
+	MouseMovementPoint,
+	PackedBehavioralData,
+	TouchEventPoint,
+} from "@prosopo/types";
 
-export const DetectorLoader = async (): Promise<DetectorType> =>
-	(await import("@prosopo/detector")).default;
+// The detector is NOT bundled into the widget — it lives only in the
+// provider-served pool bundles, loaded at runtime via a blob URL below. So the
+// signature is declared locally here (mirroring `@prosopo/detector`'s default
+// export) from shared @prosopo/types primitives, rather than importing the
+// detector package as a build-time type dependency.
+export type DetectorType = (
+	container: HTMLElement | undefined,
+	restart: () => void,
+	accountGenerator: () => Promise<Account>,
+) => Promise<{
+	token: string;
+	shadowDomCleanup: () => void;
+	encryptHeadHash: string;
+	mouseTracker?: {
+		start: () => void;
+		stop: () => void;
+		getData: () => MouseMovementPoint[];
+		clear: () => void;
+	};
+	touchTracker?: {
+		start: () => void;
+		stop: () => void;
+		getData: () => TouchEventPoint[];
+		clear: () => void;
+	};
+	clickTracker?: {
+		start: () => void;
+		stop: () => void;
+		getData: () => ClickEventPoint[];
+		clear: () => void;
+	};
+	hasTouchSupport?: string;
+	encryptBehavioralData?: (data: string) => Promise<string>;
+	packBehavioralData?: (behavioralData: BehavioralData) => PackedBehavioralData;
+	getSimdReadings?: (timeoutMs?: number) => Promise<string | undefined>;
+	userAccount: Account;
+}>;
+
+/**
+ * Loads a detector from a provider-served obfuscated ESM string (the per-session
+ * pool bundle). Evaluated via a blob URL — the served module is self-contained
+ * (no imports), so dynamic `import()` of the blob yields its default export.
+ */
+export const DetectorLoaderFromScript = async (
+	script: string,
+): Promise<DetectorType> => {
+	const blob = new Blob([script], { type: "text/javascript" });
+	const url = URL.createObjectURL(blob);
+	try {
+		const mod = (await import(/* @vite-ignore */ url)) as {
+			default: DetectorType;
+		};
+		return mod.default;
+	} finally {
+		URL.revokeObjectURL(url);
+	}
+};

package/src/tests/customDetectBotSimd.test.ts

@@ -19,6 +19,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 const mocks = vi.hoisted(() => ({
 	getFrictionlessCaptcha: vi.fn(),
 	getProcaptchaRandomActiveProvider: vi.fn(),
+	assignDetectorBundle: vi.fn(),
 	detect: vi.fn(),
 }));
 
@@ -29,6 +30,7 @@ vi.mock("@prosopo/api", () => ({
 	ProviderApi: vi.fn(function () {
 		return {
 			getFrictionlessCaptcha: mocks.getFrictionlessCaptcha,
+			assignDetectorBundle: mocks.assignDetectorBundle,
 		};
 	}),
 }));
@@ -48,7 +50,7 @@ vi.mock("@prosopo/procaptcha-common", () => ({
 }));
 
 vi.mock("../detectorLoader.js", () => ({
-	DetectorLoader: vi.fn(async () => mocks.detect),
+	DetectorLoaderFromScript: vi.fn(async () => mocks.detect),
 }));
 
 import customDetectBot from "../customDetectBot.js";
@@ -81,11 +83,19 @@ const captchaResponse = {
 beforeEach(() => {
 	mocks.getFrictionlessCaptcha.mockReset();
 	mocks.getProcaptchaRandomActiveProvider.mockReset();
+	mocks.assignDetectorBundle.mockReset();
 	mocks.detect.mockReset();
 	mocks.getProcaptchaRandomActiveProvider.mockResolvedValue({
 		providerAccount: "dns-routed",
 		provider: { url: "https://provider.test" },
 	});
+	// Provider serves a per-session detector bundle (the only detector source).
+	mocks.assignDetectorBundle.mockResolvedValue({
+		useProviderBundle: true,
+		detectorSessionId: "det-1",
+		detectorScript: "SELF_CONTAINED_ESM",
+		status: "ok",
+	});
 	mocks.getFrictionlessCaptcha.mockResolvedValue(captchaResponse);
 });
 

package/tsconfig.cjs.json

@@ -11,9 +11,6 @@
 		{
 			"path": "../../dev/config/tsconfig.cjs.json"
 		},
-		{
-			"path": "../detector/tsconfig.cjs.json"
-		},
 		{
 			"path": "../locale/tsconfig.cjs.json"
 		},

package/tsconfig.json

@@ -18,9 +18,6 @@
 		{
 			"path": "../../dev/config/tsconfig.json"
 		},
-		{
-			"path": "../detector"
-		},
 		{
 			"path": "../locale"
 		},