@prosopo/provider 3.13.7 → 4.7.1

package/dist/tests/integration/imgCaptcha.integration.test.js

@@ -0,0 +1,646 @@
+import { stringToU8a, u8aToHex } from "@polkadot/util";
+import { buildDataset, datasetWithSolutionHashes } from "@prosopo/datasets";
+import { ProviderEnvironment } from "@prosopo/env";
+import { generateMnemonic, getPair } from "@prosopo/keyring";
+import { Tasks, isTlsAvailable, startProviderApi } from "@prosopo/provider";
+import { ApiParams, CaptchaType, ClientApiPaths, ClientSettingsSchema, DatabaseTypes, ProsopoConfigSchema, Tier, encodeProcaptchaOutput, } from "@prosopo/types";
+import { embedData } from "@prosopo/util";
+import { randomAsHex } from "@prosopo/util-crypto";
+import { GenericContainer } from "testcontainers";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { dummyUserAccount } from "./mocks/solvedTestCaptchas.js";
+const solutions = datasetWithSolutionHashes;
+const userAccount = "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty";
+function getRandomPort() {
+    return Math.floor(Math.random() * 50000) + 10000;
+}
+async function registerSiteKeyInDb(env, siteKey, captchaType) {
+    const tasks = new Tasks(env);
+    await tasks.clientTaskManager.registerSiteKey(siteKey, Tier.Free, ClientSettingsSchema.parse({
+        captchaType,
+        domains: ["localhost", "0.0.0.0", "127.0.0.0", "example.com"],
+        frictionlessThreshold: 0.5,
+        powDifficulty: 4,
+    }));
+}
+describe("Image Captcha Integration Tests", () => {
+    let env;
+    let mongoContainer;
+    let redisContainer;
+    let server;
+    let dappAccount;
+    let mnemonic;
+    let tasks;
+    let testPort;
+    let baseUrl;
+    let builtDataset;
+    beforeAll(async () => {
+        testPort = 40000 + (process.pid % 10000) + Math.floor(Math.random() * 5000);
+        const protocol = isTlsAvailable() ? "https" : "http";
+        baseUrl = `${protocol}://localhost:${testPort}`;
+        mongoContainer = await new GenericContainer("mongo:6.0.17")
+            .withExposedPorts(27017)
+            .withEnvironment({
+            MONGO_INITDB_ROOT_USERNAME: "root",
+            MONGO_INITDB_ROOT_PASSWORD: "root",
+            MONGO_INITDB_DATABASE: "prosopo_test",
+        })
+            .start();
+        const mongoHost = mongoContainer.getHost();
+        const mongoPort = mongoContainer.getMappedPort(27017);
+        const skipRedis = process.env.SKIP_REDIS === "true";
+        let redisHost = "localhost";
+        let redisPort = 6379;
+        if (!skipRedis) {
+            try {
+                redisContainer = await new GenericContainer("redis/redis-stack:latest")
+                    .withExposedPorts(6379)
+                    .withEnvironment({
+                    REDIS_ARGS: "--requirepass root",
+                })
+                    .start();
+                redisHost = redisContainer.getHost();
+                redisPort = redisContainer.getMappedPort(6379);
+            }
+            catch (error) {
+                console.warn("Failed to start Redis container, continuing without Redis:", error);
+            }
+        }
+        const config = ProsopoConfigSchema.parse({
+            defaultEnvironment: "development",
+            host: `${protocol}://localhost:${testPort}`,
+            account: {
+                secret: process.env.PROVIDER_MNEMONIC ||
+                    "puppy cream effort carbon despair leg pyramid cotton endorse immense drill peasant",
+            },
+            authAccount: {
+                secret: process.env.ADMIN_MNEMONIC ||
+                    "puppy cream effort carbon despair leg pyramid cotton endorse immense drill peasant",
+            },
+            database: {
+                development: {
+                    type: DatabaseTypes.enum.provider,
+                    endpoint: `mongodb://root:root@${mongoHost}:${mongoPort}`,
+                    dbname: "prosopo_test",
+                    authSource: "admin",
+                },
+            },
+            ...(redisContainer
+                ? {
+                    redisConnection: {
+                        url: `redis://:${encodeURIComponent("root")}@${redisHost}:${redisPort}`,
+                        password: "root",
+                        indexName: randomAsHex(16),
+                    },
+                }
+                : {}),
+            ipApi: {
+                baseUrl: "https://dummyUrl.com",
+                apiKey: "dummyKey",
+            },
+            server: {
+                baseURL: `${protocol}://localhost`,
+                port: testPort,
+            },
+        });
+        env = new ProviderEnvironment(config);
+        await env.isReady();
+        const db = env.getDb();
+        if (redisContainer) {
+            try {
+                await db.getRedisAccessRulesConnection().getClient();
+            }
+            catch (error) {
+                console.warn("Redis connection failed, continuing without Redis:", error);
+            }
+        }
+        tasks = new Tasks(env);
+        env.logger.info(() => ({ msg: "Setting up provider dataset" }));
+        await tasks.datasetManager.providerSetDataset(datasetWithSolutionHashes);
+        builtDataset = await buildDataset(datasetWithSolutionHashes);
+        env.logger.info(() => ({
+            msg: `Starting provider API on port ${testPort}`,
+        }));
+        let retries = 0;
+        const maxRetries = 3;
+        while (retries < maxRetries) {
+            try {
+                server = await startProviderApi(env, true, testPort);
+                await new Promise((resolve, reject) => {
+                    if (!server) {
+                        reject(new Error("Server is not running."));
+                        return;
+                    }
+                    const checkInterval = setInterval(() => {
+                        if (server?.listening) {
+                            clearInterval(checkInterval);
+                            resolve();
+                        }
+                    }, 100);
+                    setTimeout(() => {
+                        clearInterval(checkInterval);
+                        if (!server?.listening) {
+                            reject(new Error("Server failed to start listening within timeout"));
+                        }
+                    }, 5000);
+                });
+                env.logger.info(() => ({
+                    msg: `Provider API started successfully on port ${testPort}`,
+                }));
+                break;
+            }
+            catch (error) {
+                retries++;
+                env.logger.warn(() => ({
+                    msg: `Failed to start server (attempt ${retries}/${maxRetries})`,
+                    err: error,
+                }));
+                if (server) {
+                    await new Promise((resolve) => {
+                        server?.close(() => resolve());
+                    });
+                    server = undefined;
+                }
+                if (retries >= maxRetries) {
+                    throw new Error(`Failed to start server after ${maxRetries} attempts: ${error}`);
+                }
+                testPort =
+                    40000 + (process.pid % 10000) + Math.floor(Math.random() * 5000);
+                baseUrl = `${protocol}://localhost:${testPort}`;
+                env.logger.info(() => ({
+                    msg: `Retrying with port ${testPort}`,
+                }));
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+    });
+    beforeEach(async () => {
+        [mnemonic, dappAccount] = await generateMnemonic();
+        await registerSiteKeyInDb(env, dappAccount, CaptchaType.image);
+    });
+    afterAll(async () => {
+        if (server) {
+            await new Promise((resolve) => {
+                server?.close((err) => {
+                    if (err) {
+                        console.error("Error closing server:", err);
+                    }
+                    resolve();
+                });
+            });
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            server = undefined;
+        }
+        if (env) {
+            try {
+                await env.getDb().close();
+            }
+            catch (error) {
+                console.error("Error closing database:", error);
+            }
+        }
+        if (mongoContainer) {
+            try {
+                await mongoContainer.stop();
+            }
+            catch (error) {
+                console.error("Error stopping mongo container:", error);
+            }
+        }
+        if (redisContainer) {
+            try {
+                await redisContainer.stop();
+            }
+            catch (error) {
+                console.error("Error stopping redis container:", error);
+            }
+        }
+    });
+    describe("GetImageCaptchaChallenge", () => {
+        it("should supply an image captcha challenge to a Dapp User", async () => {
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const getImgCaptchaBody = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(getImgCaptchaBody),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            console.log(response);
+            expect(response.status).toBe(200);
+            const data = await response.json();
+            expect(data).toHaveProperty("captchas");
+        });
+        it("should not supply an image captcha challenge to a Dapp User if the site key is not registered", async () => {
+            const origin = "https://localhost";
+            const [_mnemonic, unregisteredAccount] = await generateMnemonic();
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const body = {
+                [ApiParams.dapp]: unregisteredAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": unregisteredAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data).toHaveProperty("error");
+            expect(data.error?.message).toBe("Site key not registered");
+        });
+        it("should not supply an image captcha challenge to a Dapp User if an invalid site key is provided", async () => {
+            const invalidSiteKey = "junk";
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const body = {
+                [ApiParams.dapp]: invalidSiteKey,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": invalidSiteKey,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            const data = (await response.json());
+            expect(response.status).toBe(400);
+            expect(data).toHaveProperty("error");
+            expect(data.error?.message).toBe("Invalid site key");
+        });
+        it("should fail if datasetID is incorrect", async () => {
+            const datasetId = "thewrongdsetId";
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const body = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            expect(response.status).toBe(500);
+        });
+        it("should return an error if the captcha type is set to pow", async () => {
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            await registerSiteKeyInDb(env, dappAccount, CaptchaType.pow);
+            const body = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data).toHaveProperty("error");
+            expect(data.error?.message).toBe("Incorrect CAPTCHA type");
+            expect(data.error?.code).toBe(400);
+        });
+        it("should return a translated error if the captcha type is set to pow and the language is set to es", async () => {
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            await registerSiteKeyInDb(env, dappAccount, CaptchaType.pow);
+            const body = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                    "Accept-Language": "es",
+                },
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data).toHaveProperty("error");
+            expect(data.error?.message).toBe("Tipo de CAPTCHA incorrecto");
+            expect(data.error?.code).toBe(400);
+        });
+    });
+    it("should return an error if the captcha type is set to frictionless and no sessionID is sent", async () => {
+        const origin = "https://localhost";
+        const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+        await registerSiteKeyInDb(env, dappAccount, CaptchaType.frictionless);
+        const body = {
+            [ApiParams.dapp]: dappAccount,
+            [ApiParams.user]: userAccount,
+            [ApiParams.datasetId]: solutions.datasetId,
+        };
+        const response = await fetch(getImageCaptchaURL, {
+            method: "POST",
+            body: JSON.stringify(body),
+            headers: {
+                "Content-Type": "application/json",
+                Origin: origin,
+                "Prosopo-Site-Key": dappAccount,
+                "Prosopo-User": userAccount,
+            },
+        });
+        expect(response.status).toBe(400);
+        const data = (await response.json());
+        expect(data).toHaveProperty("error");
+        expect(data.error?.message).toBe("Incorrect CAPTCHA type");
+        expect(data.error?.code).toBe(400);
+    });
+    describe("SubmitImageCaptchaSolution", () => {
+        it("should verify a correctly completed image captcha as true", async () => {
+            const pair = getPair(dummyUserAccount.seed, undefined, "sr25519", 42);
+            const userAccount = dummyUserAccount.address;
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const getImgCaptchaBody = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(getImgCaptchaBody),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            expect(response.status).toBe(200);
+            const data = (await response.json());
+            const solutionMap = new Map(builtDataset.captchas
+                .filter((captcha) => captcha.solution)
+                .map((captcha) => [
+                captcha.captchaContentId,
+                captcha.solution?.map((s) => s.toString()) ?? [],
+            ]));
+            const temp = data.captchas.map((captcha, index) => {
+                const solution = solutionMap.get(captcha.captchaContentId);
+                if (!solution) {
+                    throw new Error(`Solution not found for captchaContentId: ${captcha.captchaContentId}`);
+                }
+                return {
+                    captchaContentId: captcha.captchaContentId,
+                    captchaId: captcha.captchaId,
+                    salt: embedData(randomAsHex(), [
+                        1 + index,
+                        2 + index,
+                        3 + index,
+                        4 + index,
+                    ]),
+                    solution: solution,
+                };
+            });
+            const solveImgCaptchaBody = {
+                [ApiParams.captchas]: temp,
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.requestHash]: data.requestHash,
+                [ApiParams.signature]: {
+                    [ApiParams.user]: {
+                        [ApiParams.timestamp]: u8aToHex(pair.sign(stringToU8a(data.timestamp))),
+                    },
+                    [ApiParams.provider]: data[ApiParams.signature][ApiParams.provider],
+                },
+                [ApiParams.timestamp]: data.timestamp,
+                [ApiParams.user]: userAccount,
+            };
+            const solveThatCaptcha = await fetch(`${baseUrl}${ClientApiPaths.SubmitImageCaptchaSolution}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+                body: JSON.stringify(solveImgCaptchaBody),
+            });
+            const jsonRes = await solveThatCaptcha.json();
+            const res = jsonRes;
+            expect(res.status).toBe("You correctly answered the captchas");
+        });
+        it("should mark an incorrectly completed image captcha as disapproved", async () => {
+            const pair = getPair(dummyUserAccount.seed, undefined, "sr25519", 42);
+            const userAccount = dummyUserAccount.address;
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const getImgCaptchaBody = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(getImgCaptchaBody),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            expect(response.status).toBe(200);
+            const data = (await response.json());
+            const captchaInfoMap = new Map(builtDataset.captchas
+                .filter((captcha) => captcha.solution)
+                .map((captcha) => [
+                captcha.captchaContentId,
+                {
+                    solution: captcha.solution?.map((s) => s.toString()) ?? [],
+                    itemHashes: captcha.items.map((item) => item.hash),
+                },
+            ]));
+            const temp = data.captchas.map((captcha, index) => {
+                const info = captchaInfoMap.get(captcha.captchaContentId);
+                if (!info) {
+                    throw new Error(`Captcha info not found for captchaContentId: ${captcha.captchaContentId}`);
+                }
+                return {
+                    captchaContentId: captcha.captchaContentId,
+                    captchaId: captcha.captchaId,
+                    salt: embedData(randomAsHex(), [
+                        1 + index,
+                        2 + index,
+                        3 + index,
+                        4 + index,
+                    ]),
+                    solution: info.itemHashes.filter((hash) => !info.solution.includes(hash)),
+                };
+            });
+            const solveImgCaptchaBody = {
+                [ApiParams.captchas]: temp,
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.requestHash]: data.requestHash,
+                [ApiParams.signature]: {
+                    [ApiParams.user]: {
+                        [ApiParams.timestamp]: u8aToHex(pair.sign(stringToU8a(data.timestamp))),
+                    },
+                    [ApiParams.provider]: data[ApiParams.signature][ApiParams.provider],
+                },
+                [ApiParams.timestamp]: data.timestamp,
+                [ApiParams.user]: userAccount,
+            };
+            const solveThatCaptcha = await fetch(`${baseUrl}${ClientApiPaths.SubmitImageCaptchaSolution}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+                body: JSON.stringify(solveImgCaptchaBody),
+            });
+            const res = (await solveThatCaptcha.json());
+            expect(res.verified).toBe(false);
+            expect(res.status).toBe("You answered one or more captchas incorrectly. Please try again");
+        });
+        it("should disapprove a correct solution submitted after the time limit, and the dapp should verify the challenge as disapproved", async () => {
+            const pair = getPair(dummyUserAccount.seed, undefined, "sr25519", 42);
+            const userAccount = dummyUserAccount.address;
+            const origin = "https://localhost";
+            const getImageCaptchaURL = `${baseUrl}${ClientApiPaths.GetImageCaptchaChallenge}`;
+            const getImgCaptchaBody = {
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.datasetId]: solutions.datasetId,
+            };
+            const response = await fetch(getImageCaptchaURL, {
+                method: "POST",
+                body: JSON.stringify(getImgCaptchaBody),
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+            });
+            expect(response.status).toBe(200);
+            const data = (await response.json());
+            const expireResult = await env
+                .getDb()
+                .getTables()
+                .commitment.updateOne({ requestHash: data.requestHash, pending: true }, { $set: { deadlineTimestamp: new Date(Date.now() - 60 * 1000) } });
+            expect(expireResult.modifiedCount).toBe(1);
+            const solutionMap = new Map(builtDataset.captchas
+                .filter((captcha) => captcha.solution)
+                .map((captcha) => [
+                captcha.captchaContentId,
+                captcha.solution?.map((s) => s.toString()) ?? [],
+            ]));
+            const temp = data.captchas.map((captcha, index) => {
+                const solution = solutionMap.get(captcha.captchaContentId);
+                if (!solution) {
+                    throw new Error(`Solution not found for captchaContentId: ${captcha.captchaContentId}`);
+                }
+                return {
+                    captchaContentId: captcha.captchaContentId,
+                    captchaId: captcha.captchaId,
+                    salt: embedData(randomAsHex(), [
+                        1 + index,
+                        2 + index,
+                        3 + index,
+                        4 + index,
+                    ]),
+                    solution: solution,
+                };
+            });
+            const solveImgCaptchaBody = {
+                [ApiParams.captchas]: temp,
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.requestHash]: data.requestHash,
+                [ApiParams.signature]: {
+                    [ApiParams.user]: {
+                        [ApiParams.timestamp]: u8aToHex(pair.sign(stringToU8a(data.timestamp))),
+                    },
+                    [ApiParams.provider]: data[ApiParams.signature][ApiParams.provider],
+                },
+                [ApiParams.timestamp]: data.timestamp,
+                [ApiParams.user]: userAccount,
+            };
+            const solveThatCaptcha = await fetch(`${baseUrl}${ClientApiPaths.SubmitImageCaptchaSolution}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+                body: JSON.stringify(solveImgCaptchaBody),
+            });
+            expect(solveThatCaptcha.status).toBe(200);
+            const solutionResult = (await solveThatCaptcha.json());
+            expect(solutionResult.verified).toBe(false);
+            expect(solutionResult.status).toBe("You answered one or more captchas incorrectly. Please try again");
+            const dappPair = getPair(mnemonic);
+            const verifyTimestamp = Date.now().toString();
+            const token = encodeProcaptchaOutput({
+                [ApiParams.dapp]: dappAccount,
+                [ApiParams.user]: userAccount,
+                [ApiParams.timestamp]: verifyTimestamp,
+                [ApiParams.signature]: {
+                    [ApiParams.provider]: {},
+                    [ApiParams.user]: {},
+                },
+            });
+            const dappSignature = u8aToHex(dappPair.sign(stringToU8a(verifyTimestamp)));
+            const verifyBody = {
+                [ApiParams.token]: token,
+                [ApiParams.dappSignature]: dappSignature,
+            };
+            const verifyResponse = await fetch(`${baseUrl}${ClientApiPaths.VerifyImageCaptchaSolutionDapp}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Origin: origin,
+                    "Prosopo-Site-Key": dappAccount,
+                    "Prosopo-User": userAccount,
+                },
+                body: JSON.stringify(verifyBody),
+            });
+            expect(verifyResponse.status).toBe(200);
+            const verifyResult = (await verifyResponse.json());
+            expect(verifyResult.verified).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=imgCaptcha.integration.test.js.map