@prosopo/procaptcha 2.11.34 → 2.11.36

package/.turbo/turbo-build$colon$cjs.log

@@ -51,4 +51,4 @@ dist/cjs/modules/collector.cjs           1.83 kB │ gzip: 0.59 kB
 dist/cjs/modules/ProsopoCaptchaApi.cjs   2.33 kB │ gzip: 0.82 kB
 dist/cjs/modules/Manager.cjs            16.38 kB │ gzip: 4.38 kB
 
-✓ built in 45ms
+✓ built in 35ms

package/.turbo/{turbo-build.log → turbo-build$colon$esm.log}

@@ -1,5 +1,4 @@
-$ pnpm run build:cross-env --mode ${NODE_ENV:-development}
-$ vite build --config vite.esm.config.ts --mode production
+$ vite build --config vite.esm.config.ts --mode ${NODE_ENV:-development}
 ViteEsmConfig: .
 {
   tsConfigPaths: [
@@ -20,7 +19,6 @@ ViteEsmConfig: .
     '/home/runner/work/captcha/captcha/packages/keyring/tsconfig.json'
   ]
 }
-The plugin "vite-tsconfig-paths" is detected. Vite now supports tsconfig paths resolution natively via the resolve.tsconfigPaths option. You can remove the plugin and set resolve.tsconfigPaths: true in your Vite config instead.
 {
   externals: [
     '@prosopo/datasets',
@@ -40,17 +38,18 @@ ViteEsmConfig: .
     '@prosopo/keyring'
   ]
 }
+The plugin "vite-tsconfig-paths" is detected. Vite now supports tsconfig paths resolution natively via the resolve.tsconfigPaths option. You can remove the plugin and set resolve.tsconfigPaths: true in your Vite config instead.
 vite v8.1.6 building ssr environment for production...
 Bundle build started
 
 ✓ 6 modules transformed.
 rendering chunks...
 computing gzip size...
-dist/_virtual/_rolldown/runtime.js   0.04 kB │ gzip: 0.06 kB
-dist/modules/index.js                0.20 kB │ gzip: 0.11 kB
-dist/index.js                        0.27 kB │ gzip: 0.14 kB
-dist/modules/collector.js            1.81 kB │ gzip: 0.59 kB
-dist/modules/ProsopoCaptchaApi.js    2.23 kB │ gzip: 0.80 kB
-dist/modules/Manager.js             15.49 kB │ gzip: 4.32 kB
+dist/esm/_virtual/_rolldown/runtime.js   0.04 kB │ gzip: 0.06 kB
+dist/esm/modules/index.js                0.20 kB │ gzip: 0.11 kB
+dist/esm/index.js                        0.27 kB │ gzip: 0.14 kB
+dist/esm/modules/collector.js            1.81 kB │ gzip: 0.59 kB
+dist/esm/modules/ProsopoCaptchaApi.js    2.23 kB │ gzip: 0.80 kB
+dist/esm/modules/Manager.js             15.49 kB │ gzip: 4.32 kB
 
-✓ built in 56ms
+✓ built in 60ms

package/.turbo/turbo-build$colon$tsc.log

@@ -1,5 +1,5 @@
 $ tsc --build --verbose
-7:41:02 PM - Projects in this build: 
+11:54:44 AM - Projects in this build: 
     * ../../dev/config/tsconfig.json
     * ../util/tsconfig.json
     * ../locale/tsconfig.json
@@ -18,39 +18,39 @@ $ tsc --build --verbose
     * ../procaptcha-common/tsconfig.json
     * tsconfig.json
 
-7:41:02 PM - Project '../../dev/config/tsconfig.json' is up to date because newest input '../../dev/config/src/webpack/webpack.config.ts' is older than output '../../dev/config/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../../dev/config/tsconfig.json' is up to date because newest input '../../dev/config/src/webpack/webpack.config.ts' is older than output '../../dev/config/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../util/tsconfig.json' is up to date because newest input '../util/src/url.ts' is older than output '../util/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../util/tsconfig.json' is up to date because newest input '../util/src/url.ts' is older than output '../util/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../locale/tsconfig.json' is up to date because newest input '../locale/src/process.ts' is older than output '../locale/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../locale/tsconfig.json' is up to date because newest input '../locale/src/process.ts' is older than output '../locale/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../util-crypto/tsconfig.json' is up to date because newest input '../util-crypto/src/types.ts' is older than output '../util-crypto/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../util-crypto/tsconfig.json' is up to date because newest input '../util-crypto/src/types.ts' is older than output '../util-crypto/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../types/tsconfig.json' is up to date because newest input '../types/src/types.test-d.ts' is older than output '../types/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../types/tsconfig.json' is up to date because newest input '../types/src/types.test-d.ts' is older than output '../types/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../common/tsconfig.json' is up to date because newest input '../common/src/tests/utils/objectUtils.unit.test.ts' is older than output '../common/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../common/tsconfig.json' is up to date because newest input '../common/src/error.ts' is older than output '../common/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../logger/tsconfig.json' is up to date because newest input '../logger/src/tests/loggerBrowser.unit.test.ts' is older than output '../logger/tsconfig.tsbuildinfo'
+11:54:44 AM - Project '../logger/tsconfig.json' is up to date because newest input '../logger/src/index.ts' is older than output '../logger/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../datasets/tsconfig.json' is up to date because newest input '../datasets/src/errorSites.ts' is older than output '../datasets/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../datasets/tsconfig.json' is up to date because newest input '../datasets/src/errorSites.ts' is older than output '../datasets/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../api/tsconfig.json' is up to date because newest input '../api/src/index.ts' is older than output '../api/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../api/tsconfig.json' is up to date because newest input '../api/src/tests/apiHarness.ts' is older than output '../api/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../load-balancer/tsconfig.json' is up to date because newest input '../load-balancer/src/balancer.ts' is older than output '../load-balancer/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../load-balancer/tsconfig.json' is up to date because newest input '../load-balancer/src/balancer.ts' is older than output '../load-balancer/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../widget-skeleton/tsconfig.json' is up to date because newest input '../widget-skeleton/src/webComponent/createWidget.ts' is older than output '../widget-skeleton/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../widget-skeleton/tsconfig.json' is up to date because newest input '../widget-skeleton/src/webComponent/createWidget.ts' is older than output '../widget-skeleton/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../fingerprintjs/tsconfig.json' is up to date because newest input '../fingerprintjs/src/utils/browser.ts' is older than output '../fingerprintjs/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../fingerprintjs/tsconfig.json' is up to date because newest input '../fingerprintjs/src/utils/browser.ts' is older than output '../fingerprintjs/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../fingerprint/tsconfig.json' is up to date because newest input '../fingerprint/src/index.test.ts' is older than output '../fingerprint/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../fingerprint/tsconfig.json' is up to date because newest input '../fingerprint/src/index.test.ts' is older than output '../fingerprint/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../keyring/tsconfig.json' is up to date because newest input '../keyring/src/keyring/keyring.test.ts' is older than output '../keyring/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../keyring/tsconfig.json' is up to date because newest input '../keyring/src/errorSites.ts' is older than output '../keyring/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../account/tsconfig.json' is up to date because newest input '../account/src/custom.d.ts' is older than output '../account/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../account/tsconfig.json' is up to date because newest input '../account/src/custom.d.ts' is older than output '../account/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project '../procaptcha-common/tsconfig.json' is up to date because newest input '../procaptcha-common/src/extensionLoader.ts' is older than output '../procaptcha-common/tsconfig.tsbuildinfo'
+11:54:45 AM - Project '../procaptcha-common/tsconfig.json' is up to date because newest input '../procaptcha-common/src/extensionLoader.ts' is older than output '../procaptcha-common/dist/tsc/tsconfig.tsbuildinfo'
 
-7:41:02 PM - Project 'tsconfig.json' is out of date because output file 'tsconfig.tsbuildinfo' does not exist
+11:54:45 AM - Project 'tsconfig.json' is out of date because output file 'dist/tsc/tsconfig.tsbuildinfo' does not exist
 
-7:41:02 PM - Building project '/home/runner/work/captcha/captcha/packages/procaptcha/tsconfig.json'...
+11:54:45 AM - Building project '/home/runner/work/captcha/captcha/packages/procaptcha/tsconfig.json'...
 

package/.turbo/turbo-build$colon$types.log

@@ -0,0 +1 @@
+$ tsc --project tsconfig.types.json

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @prosopo/procaptcha
 
+## 2.11.36
+### Patch Changes
+
+- 2086040: Each kind of build now writes to its own folder under dist: dist/esm (vite ESM), dist/cjs (vite CommonJS), dist/types (declarations), dist/tsc (plain tsc), dist/bundle and dist/bundle-webpack (bundles) and dist/native (the Rust addons). Turbo caches each folder separately, so building one variant no longer overwrites or invalidates another. Package exports point at the new folders; anything importing a file from dist by path has to add the variant folder.
+  
+  The Rust addons are no longer committed. They are built into dist/native, in debug for development and tests and fully optimised when NODE_ENV=production, so building them now needs a Rust toolchain.
+  
+  Code that found the repo root or its certificates by climbing a fixed number of folders up from its own file now starts from its package's folder instead (new `packageDir` in @prosopo/util/node). The fixed count stopped working once the build output moved one folder deeper.
+- Updated dependencies [2086040]
+- Updated dependencies [915f30b]
+  - @prosopo/api@4.7.7
+  - @prosopo/common@3.3.1
+  - @prosopo/datasets@3.2.12
+  - @prosopo/load-balancer@2.11.16
+  - @prosopo/locale@3.13.1
+  - @prosopo/procaptcha-common@2.21.9
+  - @prosopo/types@5.19.0
+  - @prosopo/util-crypto@13.6.2
+  - @prosopo/util@3.3.17
+
+## 2.11.35
+### Patch Changes
+
+- Updated dependencies [b460b0b]
+- Updated dependencies [159766a]
+- Updated dependencies [96dbf9a]
+  - @prosopo/locale@3.13.0
+  - @prosopo/types@5.18.0
+  - @prosopo/procaptcha-common@2.21.8
+  - @prosopo/api@4.7.6
+  - @prosopo/common@3.3.0
+  - @prosopo/datasets@3.2.11
+  - @prosopo/load-balancer@2.11.15
+
 ## 2.11.34
 ### Patch Changes
 

package/dist/tsc/errorSites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorSites.d.ts","sourceRoot":"","sources":["../../src/errorSites.ts"],"names":[],"mappings":"AAcA,OAAO,QAAQ,iBAAiB,CAAC;IAChC,UAAU,UAAU;QACnB,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;KAChB;CACD;AAED,OAAO,EAAE,CAAC"}

package/dist/{errorSites.js.map → tsc/errorSites.js.map}

@@ -1 +1 @@
-{"version":3,"file":"errorSites.js","sourceRoot":"","sources":["../src/errorSites.ts"],"names":[],"mappings":""}
+{"version":3,"file":"errorSites.js","sourceRoot":"","sources":["../../src/errorSites.ts"],"names":[],"mappings":""}

package/dist/{index.d.ts.map → tsc/index.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAC"}

package/dist/tsc/index.js

@@ -0,0 +1,2 @@
+export * from "./modules/index.js";
+//# sourceMappingURL=index.js.map

package/dist/tsc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,oBAAoB,CAAC"}

package/dist/tsc/modules/Manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../../src/modules/Manager.ts"],"names":[],"mappings":"AA4BA,OAAO,EAMN,KAAK,iBAAiB,EACtB,WAAW,EACX,KAAK,mBAAmB,EAExB,KAAK,4BAA4B,EAEjC,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAG5B,MAAM,gBAAgB,CAAC;AAwBxB,wBAAgB,OAAO,CACtB,cAAc,EAAE,4BAA4B,EAC5C,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB,EAC9B,iBAAiB,CAAC,EAAE,iBAAiB,EAGrC,gBAAgB,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,EAM3C,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI;kEAiDpC,WAAW;;;mBAmZlB,MAAM,MACR,MAAM,MACN,MAAM,gBACG,WAAW;;;;EAmNzB"}

package/dist/tsc/modules/Manager.js

@@ -0,0 +1,445 @@
+import { stringToHex } from "@polkadot/util/string";
+import { ProviderApi } from "@prosopo/api";
+import { ProsopoError, toPublicError } from "@prosopo/common";
+import { widgetLanguageHeaders } from "@prosopo/locale";
+import { ExtensionLoader, buildClientMetaData, buildUpdateState, getDefaultEvents, getProcaptchaRandomActiveProvider, getSimdReadingsForSubmit, pickIpMode, providerRetry, } from "@prosopo/procaptcha-common";
+import { ApiParams, CaptchaType, InputMethod, ProcaptchaConfigSchema, encodeProcaptchaOutput, } from "@prosopo/types";
+import { at, embedData, hashToHex } from "@prosopo/util";
+import { sleep } from "@prosopo/util";
+import { randomAsHex } from "@prosopo/util-crypto";
+import ProsopoCaptchaApi from "./ProsopoCaptchaApi.js";
+const defaultState = () => {
+    return {
+        showModal: false,
+        loading: false,
+        index: 0,
+        challenge: undefined,
+        solutions: undefined,
+        isHuman: false,
+        captchaApi: undefined,
+        account: undefined,
+    };
+};
+export function Manager(configOptional, state, onStateUpdate, callbacks, frictionlessState, getHoneypotValue, onReloadRequest) {
+    const events = getDefaultEvents(callbacks);
+    const updateState = buildUpdateState(state, onStateUpdate);
+    let checkboxClickX = 0;
+    let checkboxClickY = 0;
+    let checkboxInputMethod = InputMethod.pointer;
+    let previousProviderUrl;
+    let spentSessionId;
+    const getConfig = () => {
+        const config = {
+            userAccountAddress: "",
+            ...configOptional,
+        };
+        if (state.account) {
+            config.userAccountAddress = state.account.account.address;
+        }
+        return ProcaptchaConfigSchema.parse(config);
+    };
+    const start = async (checkboxX = 0, checkboxY = 0, inputMethod = InputMethod.pointer) => {
+        checkboxClickX = checkboxX;
+        checkboxClickY = checkboxY;
+        if (state.answeredIncorrectly) {
+            updateState({ answeredIncorrectly: false });
+        }
+        checkboxInputMethod = inputMethod;
+        events.onOpen();
+        await 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 sleep(100);
+            const account = await loadAccount();
+            let captchaApi = state.captchaApi;
+            if (!frictionlessState?.provider) {
+                const currentConfig = getConfig();
+                const getRandomProviderResponse = await getProcaptchaRandomActiveProvider(currentConfig.defaultEnvironment, pickIpMode(currentConfig), { attempt: state.attemptCount, excludeUrl: previousProviderUrl });
+                const providerUrl = getRandomProviderResponse.provider.url;
+                previousProviderUrl = providerUrl;
+                const { providerApi, siteKey } = await loadProviderApi(providerUrl);
+                captchaApi = new 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 ProsopoCaptchaApi(account.account.address, frictionlessState.provider, providerApi, config.web2, siteKey);
+                updateState({ captchaApi });
+            }
+            if (state.sessionId && state.sessionId === spentSessionId) {
+                updateState({
+                    loading: false,
+                    error: toPublicError(new ProsopoError({
+                        code: "NO_SESSION_FOUND",
+                        errorSite: "PCAP-18",
+                    }), "FRONTEND_ERROR"),
+                });
+                events.onError(new Error("No session found"));
+                return;
+            }
+            const simdReadingsOnChallenge = frictionlessState?.getSimdReadings
+                ? await frictionlessState.getSimdReadings(0)
+                : undefined;
+            const challengeSessionId = state.sessionId;
+            if (challengeSessionId)
+                spentSessionId = challengeSessionId;
+            const challenge = await captchaApi?.getCaptchaChallenge(challengeSessionId, simdReadingsOnChallenge);
+            if (challenge.error) {
+                updateState({
+                    loading: false,
+                    error: challenge.error,
+                });
+                events.onError(new Error(challenge.error?.message));
+            }
+            else {
+                if (challenge.captchas.length <= 0) {
+                    throw new ProsopoError({
+                        code: "RECORD_NOT_FOUND",
+                        errorSite: "PCAP-1",
+                        message: "No captchas returned from provider",
+                    });
+                }
+                const timeMillis = challenge.captchas
+                    .map((captcha) => captcha.timeLimitMs || config.captchas.image.challengeTimeout)
+                    .reduce((a, b) => a + b);
+                const timeout = setTimeout(() => {
+                    if (disposed)
+                        return;
+                    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 providerRetry(async () => {
+            clearTimeout();
+            if (!state.challenge) {
+                throw new ProsopoError({
+                    code: "RECORD_NOT_FOUND",
+                    errorSite: "PCAP-2",
+                    message: "No captcha found",
+                    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 = at(state.solutions, index);
+                const shapeCoords = solution.flatMap(([_, x, y]) => [x, y]);
+                const shapeInputMethods = solution.map(([, , , inputMethod]) => inputMethod);
+                const coords = index === 0
+                    ? [checkboxClickX, checkboxClickY, ...shapeCoords]
+                    : shapeCoords;
+                const inputMethods = index === 0
+                    ? [checkboxInputMethod, ...shapeInputMethods]
+                    : shapeInputMethods;
+                const countByte = 1;
+                const salt = randomAsHex(coords
+                    .map((x) => x.toString(16).length + 4)
+                    .reduce((acc, curr) => acc + curr, countByte));
+                const saltCoord = embedData(salt, coords);
+                return {
+                    captchaId: captcha.captchaId,
+                    captchaContentId: captcha.captchaContentId,
+                    salt: saltCoord,
+                    solution: solution.flatMap((s) => s[0]),
+                    inputMethods,
+                };
+            });
+            const account = getAccount();
+            const signer = getExtension(account).signer;
+            const first = at(challenge.captchas, 0);
+            if (!first.datasetId) {
+                throw new ProsopoError({
+                    code: "INVALID_DATA",
+                    errorSite: "PCAP-3",
+                    message: "Invalid captcha id",
+                    context: { error: "No datasetId set for challenge" },
+                });
+            }
+            const captchaApi = state.captchaApi;
+            if (!captchaApi) {
+                throw new ProsopoError({
+                    code: "INVALID_REQUEST",
+                    errorSite: "PCAP-4",
+                    message: "Invalid token",
+                    context: { error: "No Captcha API found in state" },
+                });
+            }
+            if (!signer || !signer.signRaw) {
+                throw new ProsopoError({
+                    code: "CONFIG_INVALID",
+                    errorSite: "PCAP-5",
+                    message: "Can't find the keyringpair for {{address}}",
+                    context: {
+                        error: "Signer is not defined, cannot sign message to prove account ownership",
+                    },
+                });
+            }
+            const userTimestampSignature = await signer.signRaw({
+                address: account.account.address,
+                data: stringToHex(challenge[ApiParams.timestamp]),
+                type: "bytes",
+            });
+            let encryptedBehavioralData;
+            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",
+                    };
+                    const dataToEncrypt = frictionlessState.packBehavioralData
+                        ? frictionlessState.packBehavioralData(behavioralData)
+                        : behavioralData;
+                    encryptedBehavioralData =
+                        await frictionlessState.encryptBehavioralData(JSON.stringify(dataToEncrypt));
+                }
+                catch {
+                }
+            }
+            const simdReadings = await getSimdReadingsForSubmit(frictionlessState);
+            const clientMetaData = buildClientMetaData(getHoneypotValue?.(), getConfig().clientSessionId);
+            const submission = await captchaApi.submitCaptchaSolution(userTimestampSignature.signature, challenge.requestHash, captchaSolution, challenge.timestamp, challenge.signature.provider.requestHash, encryptedBehavioralData, simdReadings, clientMetaData);
+            if (disposed)
+                return;
+            const isHuman = submission[0].verified;
+            updateState({
+                submission,
+                isHuman,
+                loading: false,
+            });
+            if (state.isHuman) {
+                const providerUrl = captchaApi.provider.provider.url;
+                events.onHuman(encodeProcaptchaOutput({
+                    [ApiParams.providerUrl]: providerUrl,
+                    [ApiParams.user]: account.account.address,
+                    [ApiParams.dapp]: getDappAccount(),
+                    [ApiParams.commitmentId]: hashToHex(submission[1]),
+                    [ApiParams.timestamp]: challenge.timestamp,
+                    [ApiParams.signature]: {
+                        [ApiParams.provider]: {
+                            [ApiParams.requestHash]: challenge.signature.provider.requestHash,
+                        },
+                        [ApiParams.user]: {
+                            [ApiParams.timestamp]: userTimestampSignature.signature,
+                        },
+                    },
+                    [ApiParams.captchaType]: CaptchaType.image,
+                }));
+                setValidChallengeTimeout();
+            }
+            else {
+                events.onFailed();
+                updateState({ answeredIncorrectly: true });
+                resetState(frictionlessState
+                    ? () => frictionlessState.restart({ showRetry: true })
+                    : undefined);
+            }
+        }, start, resetState, state.attemptCount, 10);
+    };
+    const cancel = async () => {
+        clearTimeout();
+        resetState(frictionlessState?.restart);
+        events.onClose();
+    };
+    const reload = async () => {
+        clearTimeout();
+        events.onReload();
+        if (onReloadRequest) {
+            resetState();
+            onReloadRequest(checkboxClickX, checkboxClickY);
+            return;
+        }
+        resetState(frictionlessState?.restart);
+        if (!frictionlessState?.restart) {
+            await start(checkboxClickX, checkboxClickY, checkboxInputMethod);
+        }
+    };
+    const select = (hash, x, y, inputMethod = InputMethod.pointer) => {
+        if (!state.challenge) {
+            throw new ProsopoError({
+                code: "RECORD_NOT_FOUND",
+                errorSite: "PCAP-6",
+                message: "No captcha found",
+                context: { error: "Cannot select, no Captcha found in state" },
+            });
+        }
+        if (state.index >= state.challenge.captchas.length || state.index < 0) {
+            throw new ProsopoError({
+                code: "RECORD_NOT_FOUND",
+                errorSite: "PCAP-7",
+                message: "No captcha found",
+                context: {
+                    error: "Cannot select, index is out of range for this Captcha",
+                },
+            });
+        }
+        const index = state.index;
+        const solutions = state.solutions;
+        const solution = 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, inputMethod]];
+        }
+        updateState({ solutions });
+    };
+    const nextRound = () => {
+        if (!state.challenge) {
+            throw new ProsopoError({
+                code: "RECORD_NOT_FOUND",
+                errorSite: "PCAP-8",
+                message: "No captcha found",
+                context: { error: "Cannot select, no Captcha found in state" },
+            });
+        }
+        if (state.index + 1 >= state.challenge.captchas.length) {
+            throw new ProsopoError({
+                code: "RECORD_NOT_FOUND",
+                errorSite: "PCAP-9",
+                message: "No captcha found",
+                context: {
+                    error: "Cannot select, index is out of range for this Captcha",
+                },
+            });
+        }
+        updateState({ index: state.index + 1 });
+    };
+    const loadProviderApi = async (providerUrl) => {
+        const config = getConfig();
+        const siteKey = config.account.address;
+        if (!siteKey) {
+            throw new ProsopoError({
+                code: "SITE_KEY_MISSING",
+                errorSite: "PCAP-10",
+            });
+        }
+        return {
+            providerApi: new ProviderApi(providerUrl, siteKey, undefined, widgetLanguageHeaders(config.language)),
+            siteKey,
+        };
+    };
+    const clearTimeout = () => {
+        window.clearTimeout(Number(state.timeout));
+        updateState({ timeout: undefined });
+    };
+    const setValidChallengeTimeout = () => {
+        const timeMillis = configOptional.captchas.image.solutionTimeout;
+        const successfullChallengeTimeout = setTimeout(() => {
+            if (disposed)
+                return;
+            updateState({ isHuman: false });
+            events.onExpired();
+        }, timeMillis);
+        updateState({ successfullChallengeTimeout });
+    };
+    const resetState = (frictionlessRestart) => {
+        clearTimeout();
+        window.clearTimeout(Number(state.successfullChallengeTimeout));
+        updateState(defaultState());
+        events.onReset();
+        if (frictionlessRestart) {
+            frictionlessRestart();
+        }
+    };
+    const loadAccount = async () => {
+        const config = getConfig();
+        if (!config.web2 && !config.userAccountAddress) {
+            throw new ProsopoError({
+                code: "ACCOUNT_NOT_FOUND",
+                errorSite: "PCAP-11",
+                context: { error: "Account address has not been set for web3 mode" },
+            });
+        }
+        const selectAccount = async () => {
+            const ext = new (await 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 ProsopoError({
+                code: "ACCOUNT_NOT_FOUND",
+                errorSite: "PCAP-12",
+                context: { error: "Account not loaded" },
+            });
+        }
+        const account = state.account;
+        return account;
+    };
+    const getDappAccount = () => {
+        if (!state.dappAccount) {
+            throw new ProsopoError({
+                code: "SITE_KEY_MISSING",
+                errorSite: "PCAP-13",
+            });
+        }
+        const dappAccount = state.dappAccount;
+        return dappAccount;
+    };
+    const getExtension = (account) => {
+        if (!account.extension) {
+            throw new ProsopoError({
+                code: "WALLET_NOT_FOUND",
+                errorSite: "PCAP-14",
+                message: "Polkadot extension not found",
+                context: { error: "Extension not loaded" },
+            });
+        }
+        return account.extension;
+    };
+    let disposed = false;
+    const dispose = () => {
+        disposed = true;
+        window.clearTimeout(Number(state.timeout));
+        window.clearTimeout(Number(state.successfullChallengeTimeout));
+    };
+    return {
+        start,
+        cancel,
+        submit,
+        select,
+        nextRound,
+        reload,
+        dispose,
+    };
+}
+//# sourceMappingURL=Manager.js.map