@prosopo/provider 3.13.7 → 4.7.1

package/dist/tests/unit/tasks/imgCaptcha/imgCaptchaTasks.unit.test.js

@@ -0,0 +1,1098 @@
+import { u8aToHex } from "@polkadot/util";
+import { ProsopoEnvError } from "@prosopo/common";
+import { compareCaptchaSolutions, computePendingRequestHash, parseAndSortCaptchaSolutions, } from "@prosopo/datasets";
+import { getLogger } from "@prosopo/logger";
+import { CaptchaStatus, IpAddressType, } from "@prosopo/types";
+import { getIPAddress } from "@prosopo/util";
+import { randomAsHex, signatureVerify } from "@prosopo/util-crypto";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ImgCaptchaManager } from "../../../../tasks/imgCaptcha/imgCaptchaTasks.js";
+import { buildTreeAndGetCommitmentId } from "../../../../tasks/imgCaptcha/imgCaptchaTasksUtils.js";
+import { shuffleArray } from "../../../../util.js";
+const loggerOuter = getLogger("info", import.meta.url);
+vi.mock("@prosopo/datasets", () => ({
+    computePendingRequestHash: vi.fn(),
+    compareCaptchaSolutions: vi.fn(),
+    parseAndSortCaptchaSolutions: vi.fn(),
+}));
+vi.mock("@prosopo/util-crypto", () => ({
+    randomAsHex: vi.fn(),
+    signatureVerify: vi.fn(),
+}));
+vi.mock("@polkadot/util", () => ({
+    u8aToHex: vi.fn(),
+    stringToHex: vi.fn(),
+}));
+vi.mock("../../../../util.js", async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        shuffleArray: vi.fn(),
+    };
+});
+vi.mock("../../../../tasks/imgCaptcha/imgCaptchaTasksUtils.js", () => ({
+    buildTreeAndGetCommitmentId: vi.fn(),
+}));
+const mockCaptchas = [
+    {
+        captchaId: "captcha1",
+        solution: "solution1",
+        question: "question1",
+        options: ["option1"],
+        datasetId: "datasetId",
+        solved: true,
+    },
+    {
+        captchaId: "captcha2",
+        solution: "solution2",
+        question: "question2",
+        options: ["option2"],
+        datasetId: "datasetId",
+        solved: true,
+    },
+    {
+        captchaId: "captcha3",
+        solution: "solution3",
+        question: "question3",
+        options: ["option3"],
+        datasetId: "datasetId",
+        solved: true,
+    },
+    {
+        captchaId: "captcha4",
+        solution: "solution4",
+        question: "question4",
+        options: ["option4"],
+        datasetId: "datasetId",
+        solved: true,
+    },
+    {
+        captchaId: "captcha5",
+        solution: "solution5",
+        question: "question5",
+        options: ["option5"],
+        datasetId: "datasetId",
+        solved: true,
+    },
+    {
+        captchaId: "captcha6",
+        solution: "solution6",
+        question: "question6",
+        options: ["option6"],
+        datasetId: "datasetId",
+        solved: false,
+    },
+    {
+        captchaId: "captcha7",
+        solution: "solution7",
+        question: "question7",
+        options: ["option7"],
+        datasetId: "datasetId",
+        solved: false,
+    },
+    {
+        captchaId: "captcha8",
+        solution: "solution8",
+        question: "question8",
+        options: ["option8"],
+        datasetId: "datasetId",
+        solved: false,
+    },
+    {
+        captchaId: "captcha9",
+        solution: "solution9",
+        question: "question9",
+        options: ["option9"],
+        datasetId: "datasetId",
+        solved: false,
+    },
+];
+describe("ImgCaptchaManager", () => {
+    let db;
+    let pair;
+    let logger;
+    let captchaConfig;
+    let imgCaptchaManager;
+    let mockEnv;
+    beforeEach(() => {
+        db = {
+            getRandomCaptcha: vi.fn((solved, datasetId, size) => {
+                console.log("solved", solved, "datasetId", datasetId, "size", size);
+                return mockCaptchas
+                    .filter((captcha) => captcha.solved === solved && captcha.datasetId === datasetId)
+                    .splice(0, size);
+            }),
+            getDatasetDetails: vi.fn(),
+            storePendingImageCommitment: vi.fn(),
+            getPendingImageCommitment: vi.fn(),
+            updatePendingImageCommitmentStatus: vi.fn(),
+            storeDappUserSolution: vi.fn(),
+            approveDappUserCommitment: vi.fn(),
+            disapproveDappUserCommitment: vi.fn(),
+            updateDappUserCommitment: vi.fn(),
+            getCaptchaById: vi.fn(),
+            getDappUserCommitmentById: vi.fn(),
+            getDappUserCommitmentByAccount: vi.fn(),
+            markDappUserCommitmentsChecked: vi.fn(),
+            getSessionRecordBySessionId: vi.fn(),
+            updateSessionRecord: vi.fn(),
+            getSpamEmailDomain: vi.fn(),
+            getClientRecord: vi.fn(),
+            getSolutionByCaptchaId: vi.fn(),
+            storeUserImageCaptchaSolution: vi.fn(),
+        };
+        pair = {
+            sign: vi.fn(),
+            address: "testAddress",
+        };
+        const mockLogger = {
+            debug: vi.fn().mockImplementation(loggerOuter.debug.bind(loggerOuter)),
+            log: vi.fn().mockImplementation(loggerOuter.log.bind(loggerOuter)),
+            info: vi.fn().mockImplementation(loggerOuter.info.bind(loggerOuter)),
+            error: vi.fn().mockImplementation(loggerOuter.error.bind(loggerOuter)),
+            trace: vi.fn().mockImplementation(loggerOuter.trace.bind(loggerOuter)),
+            fatal: vi.fn().mockImplementation(loggerOuter.fatal.bind(loggerOuter)),
+            warn: vi.fn().mockImplementation(loggerOuter.warn.bind(loggerOuter)),
+        };
+        logger = mockLogger;
+        captchaConfig = {
+            solved: { count: 5 },
+            unsolved: { count: 4 },
+        };
+        imgCaptchaManager = new ImgCaptchaManager(db, pair, captchaConfig, logger);
+        mockEnv = {
+            config: {
+                ipApi: {
+                    apiKey: "testKey",
+                    baseUrl: "https://api.ipapi.is",
+                },
+            },
+            ipInfoService: {
+                initialize: vi.fn().mockResolvedValue(undefined),
+                isAvailable: vi.fn().mockReturnValue(true),
+                lookup: vi.fn(async (ip) => ({
+                    isValid: false,
+                    error: "stubbed in test",
+                    ip,
+                })),
+            },
+        };
+        vi.clearAllMocks();
+    });
+    describe("getCaptchaWithProof", () => {
+        it("should get captcha with proof", async () => {
+            const datasetId = "datasetId";
+            const size = 3;
+            const solved = true;
+            const captchaDocs = [
+                {
+                    captchaId: "captcha1",
+                    solution: "solution1",
+                    question: "question1",
+                    options: ["option1"],
+                    datasetId,
+                },
+            ];
+            db.getRandomCaptcha.mockResolvedValue(captchaDocs);
+            const result = await imgCaptchaManager.getCaptchaWithProof(datasetId, solved, size);
+            expect(result).toEqual(captchaDocs);
+            expect(db.getRandomCaptcha).toHaveBeenCalledWith(solved, datasetId, size);
+        });
+        it("should throw an error if get captcha with proof fails", async () => {
+            const datasetId = "datasetId";
+            const size = 3;
+            const solved = true;
+            db.getRandomCaptcha.mockResolvedValue(null);
+            await expect(imgCaptchaManager.getCaptchaWithProof(datasetId, solved, size)).rejects.toThrow(new ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
+                context: {
+                    failedFuncName: "getCaptchaWithProof",
+                    datasetId,
+                    solved,
+                    size,
+                },
+            }));
+        });
+        it("should getCaptchaWithProof of specific size", async () => {
+            const datasetId = "datasetId";
+            const size = 3;
+            const solvedResult = await imgCaptchaManager.getCaptchaWithProof(datasetId, true, size);
+            expect(solvedResult.length).toBe(size);
+            const unsolvedResult = await imgCaptchaManager.getCaptchaWithProof(datasetId, false, size);
+            expect(unsolvedResult.length).toBe(size);
+        });
+    });
+    describe("getRandomCaptchasAndRequestHash", () => {
+        it("should get random captchas and request hash", async () => {
+            const datasetId = "datasetId";
+            const userAccount = "userAccount";
+            const dataset = { datasetId, captchas: [] };
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            db.getDatasetDetails.mockResolvedValue(dataset);
+            db.getRandomCaptcha.mockResolvedValue([]);
+            randomAsHex.mockReturnValue("randomSalt");
+            computePendingRequestHash.mockReturnValue("computedHash");
+            pair.sign.mockReturnValue("hexSignedRequestHash");
+            u8aToHex.mockReturnValue("hexSignedRequestHash");
+            shuffleArray.mockReturnValue([]);
+            const result = await imgCaptchaManager.getRandomCaptchasAndRequestHash(datasetId, userAccount, ipAddress, captchaConfig, 0.8);
+            expect(result).toEqual({
+                captchas: [],
+                requestHash: "computedHash",
+                timestamp: expect.any(Number),
+                signedRequestHash: "hexSignedRequestHash",
+            });
+        });
+        it("should throw an error if dataset details are not found", async () => {
+            const datasetId = "datasetId";
+            const userAccount = "userAccount";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            db.getDatasetDetails.mockResolvedValue(null);
+            await expect(imgCaptchaManager.getRandomCaptchasAndRequestHash(datasetId, userAccount, ipAddress, { solved: { count: 1 }, unsolved: { count: 1 } }, 0.8)).rejects.toThrow(new ProsopoEnvError("DATABASE.DATASET_GET_FAILED", {
+                context: {
+                    failedFuncName: "getRandomCaptchasAndRequestHash",
+                    dataset: null,
+                    datasetId,
+                },
+            }));
+        });
+    });
+    it("should validate received captchas against stored captchas", async () => {
+        const captchas = [
+            { captchaId: "captcha1", solution: "solution1", salt: "salt1" },
+        ];
+        const storedCaptchas = [
+            {
+                captchaId: "captcha1",
+                solution: "solution1",
+                question: "question1",
+                options: ["option1"],
+                datasetId: "dataset1",
+            },
+        ];
+        parseAndSortCaptchaSolutions.mockReturnValue(captchas);
+        db.getCaptchaById.mockResolvedValue(storedCaptchas);
+        const result = await imgCaptchaManager.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
+        expect(result).toEqual({
+            storedCaptchas,
+            receivedCaptchas: captchas,
+            captchaIds: ["captcha1"],
+        });
+    });
+    it("should throw an error if received captchas length does not match stored captchas", async () => {
+        const captchas = [
+            { captchaId: "captcha1", solution: "solution1", salt: "salt1" },
+        ];
+        parseAndSortCaptchaSolutions.mockReturnValue(captchas);
+        db.getCaptchaById.mockResolvedValue([]);
+        await expect(imgCaptchaManager.validateReceivedCaptchasAgainstStoredCaptchas(captchas)).rejects.toThrow(new ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_ID", {
+            context: {
+                failedFuncName: "validateReceivedCaptchasAgainstStoredCaptchas",
+                captchas,
+            },
+        }));
+    });
+    it("should validate dapp user solution request is pending", async () => {
+        const requestHash = "requestHash";
+        const deadlineTimestamp = new Date(Date.now() + 10000);
+        const pendingRecord = {
+            requestHash: "requestHash",
+            userAccount: "userAccount",
+            datasetId: "datasetId",
+            salt: "salt",
+            deadlineTimestamp: deadlineTimestamp,
+            currentBlockNumber: 0,
+        };
+        const userAccount = "userAccount";
+        const captchaIds = ["captcha1"];
+        computePendingRequestHash.mockReturnValue("requestHash");
+        const result = await imgCaptchaManager.validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds);
+        expect(result).toBe(true);
+    });
+    it("should return false if deadline has expired", async () => {
+        const requestHash = "requestHash";
+        const deadline = new Date(Date.now() - 10000);
+        const pendingRecord = {
+            requestHash: "requestHash",
+            userAccount: "userAccount",
+            datasetId: "datasetId",
+            salt: "salt",
+            deadlineTimestamp: deadline,
+            currentBlockNumber: 0,
+        };
+        const userAccount = "userAccount";
+        const captchaIds = ["captcha1"];
+        const result = await imgCaptchaManager.validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds);
+        expect(result).toBe(false);
+        const logFn = logger.info.mock.calls[0][0];
+        const logObj = logFn();
+        expect(logObj).toMatchObject({
+            msg: "Deadline for responding to captcha has expired",
+        });
+    });
+    describe("dappUserSolution — failed challenge", () => {
+        it("disapproves the commitment and returns verified:false when the submitted solution is incorrect", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const requestHash = "requestHash";
+            const captchas = [
+                { captchaId: "captcha1", solution: ["a"], salt: "0x00" },
+            ];
+            const timestamp = Date.now();
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            vi.mocked(signatureVerify).mockReturnValue({
+                crypto: "sr25519",
+                isValid: true,
+                isWrapped: false,
+                publicKey: new Uint8Array(),
+            });
+            const pendingRecord = {
+                requestHash,
+                salt: "0x00",
+                threshold: 0.8,
+                deadlineTimestamp: new Date(timestamp + 10_000),
+            };
+            vi.mocked(db.getPendingImageCommitment).mockResolvedValue(pendingRecord);
+            vi.spyOn(imgCaptchaManager, "validateDappUserSolutionRequestIsPending").mockResolvedValue(true);
+            const storedCaptchas = [
+                { captchaId: "captcha1", datasetId: "datasetId", items: [{}, {}] },
+            ];
+            vi.spyOn(imgCaptchaManager, "validateReceivedCaptchasAgainstStoredCaptchas").mockResolvedValue({
+                storedCaptchas,
+                receivedCaptchas: captchas,
+                captchaIds: ["captcha1"],
+            });
+            vi.mocked(buildTreeAndGetCommitmentId).mockReturnValue({
+                tree: { proof: vi.fn() },
+                commitmentId: "commitmentId",
+            });
+            vi.mocked(db.getSolutionByCaptchaId).mockResolvedValue({
+                captchaId: "captcha1",
+                solution: ["a"],
+            });
+            vi.mocked(compareCaptchaSolutions).mockReturnValue(false);
+            const result = await imgCaptchaManager.dappUserSolution(userAccount, dappAccount, requestHash, captchas, "userTimestampSignature", timestamp, "providerRequestHashSignature", ipAddress, headers, "ja4");
+            expect(result.verified).toBe(false);
+            expect(compareCaptchaSolutions).toHaveBeenCalled();
+            expect(db.disapproveDappUserCommitment).toHaveBeenCalledWith("commitmentId", "CAPTCHA.INVALID_SOLUTION", expect.anything());
+            expect(db.approveDappUserCommitment).not.toHaveBeenCalled();
+        });
+    });
+    it("should get dapp user commitment by ID", async () => {
+        const commitmentId = "commitmentId";
+        const dappUserCommitment = {
+            id: "commitmentId",
+            userAccount: "userAccount",
+            dappAccount: "dappAccount",
+            providerAccount: "providerAccount",
+            datasetId: "datasetId",
+            result: { status: CaptchaStatus.approved },
+            userSignature: "",
+            userSubmitted: true,
+            serverChecked: false,
+            requestedAtTimestamp: new Date(0),
+            ipAddress: {
+                lower: getIPAddress("1.1.1.1").bigInt(),
+                upper: 0n,
+                type: IpAddressType.v4,
+            },
+            headers: { a: "1", b: "2", c: "3" },
+            ja4: "ja4",
+            lastUpdatedTimestamp: new Date(),
+        };
+        db.getDappUserCommitmentById.mockResolvedValue(dappUserCommitment);
+        const result = await imgCaptchaManager.getDappUserCommitmentById(commitmentId);
+        expect(result).toEqual(dappUserCommitment);
+    });
+    it("should throw an error if dapp user commitment is not found by ID", async () => {
+        const commitmentId = "commitmentId";
+        db.getDappUserCommitmentById.mockResolvedValue(null);
+        await expect(imgCaptchaManager.getDappUserCommitmentById(commitmentId)).rejects.toThrow(new ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
+            context: {
+                failedFuncName: "getDappUserCommitmentById",
+                commitmentId: commitmentId,
+            },
+        }));
+    });
+    it("should get dapp user commitment by account", async () => {
+        const userAccount = "userAccount";
+        const dappAccount = "dappAccount";
+        const dappUserCommitments = [
+            {
+                id: "commitmentId",
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(0),
+                ipAddress: {
+                    lower: getIPAddress("1.1.1.1").bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers: { a: "1", b: "2", c: "3" },
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            },
+        ];
+        db.getDappUserCommitmentByAccount.mockResolvedValue(dappUserCommitments);
+        const result = await imgCaptchaManager.getDappUserCommitmentByAccount(userAccount, dappAccount);
+        expect(result).toEqual(dappUserCommitments[0]);
+    });
+    it("should return undefined if no approved dapp user commitment is found by account", async () => {
+        const userAccount = "userAccount";
+        const dappAccount = "dappAccount";
+        const dappUserCommitments = [];
+        db.getDappUserCommitmentByAccount.mockResolvedValue(dappUserCommitments);
+        const result = await imgCaptchaManager.getDappUserCommitmentByAccount(userAccount, dappAccount);
+        expect(result).toBeUndefined();
+    });
+    describe("verifyImageCaptchaSolution with decision machine", () => {
+        it("should deny and disapprove commitment when decision machine returns Deny", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({
+                decision: "deny",
+                reason: "Suspicious behavior detected",
+                score: 10,
+                tags: ["suspicious"],
+            });
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("Suspicious behavior detected");
+            expect(db.disapproveDappUserCommitment).toHaveBeenCalledWith(commitmentId, expect.stringContaining("Suspicious behavior"));
+            imgCaptchaManager.decisionMachineRunner.decide = originalDecide;
+        });
+        it("should still approve when decision machine throws an error (fail-safe)", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockRejectedValue(new Error("Decision machine error"));
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv);
+            expect(result.verified).toBe(true);
+            expect(result.status).toBe("API.USER_VERIFIED");
+            imgCaptchaManager.decisionMachineRunner.decide = originalDecide;
+        });
+        it("should maintain existing behavior when decision machine returns Allow", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({
+                decision: "allow",
+                reason: "Legitimate user",
+                score: 95,
+            });
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv);
+            expect(result.verified).toBe(true);
+            expect(result.status).toBe("API.USER_VERIFIED");
+            expect(imgCaptchaManager.decisionMachineRunner.decide).toHaveBeenCalledWith(expect.objectContaining({
+                userAccount,
+                dappAccount,
+                captchaResult: "passed",
+                headers,
+                captchaType: "image",
+            }), expect.any(Object));
+            imgCaptchaManager.decisionMachineRunner.decide = originalDecide;
+        });
+    });
+    describe("session result tracking for verifyImageCaptchaSolution", () => {
+        const ipAddress = getIPAddress("1.1.1.1");
+        const headers = { a: "1", b: "2", c: "3" };
+        const sessionId = "test-session-for-result";
+        it("should update session as serverChecked and approved on successful verification", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId";
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                result: { status: CaptchaStatus.approved },
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+                sessionId,
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.getSessionRecordBySessionId.mockResolvedValue(undefined);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({ decision: "allow" });
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv);
+            expect(result.verified).toBe(true);
+            expect(db.updateSessionRecord).toHaveBeenCalledWith(sessionId, {
+                serverChecked: true,
+                result: { status: CaptchaStatus.approved },
+            }, true);
+            imgCaptchaManager.decisionMachineRunner.decide = originalDecide;
+        });
+        it("should update session as serverChecked and disapproved when decision machine denies", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId";
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                result: { status: CaptchaStatus.approved },
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+                sessionId,
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.getSessionRecordBySessionId.mockResolvedValue(undefined);
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({
+                decision: "deny",
+                reason: "Suspicious",
+            });
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv);
+            expect(result.verified).toBe(false);
+            expect(db.updateSessionRecord).toHaveBeenCalledWith(sessionId, {
+                serverChecked: true,
+                result: {
+                    status: CaptchaStatus.disapproved,
+                    reason: "Suspicious",
+                },
+            }, true);
+            imgCaptchaManager.decisionMachineRunner.decide = originalDecide;
+        });
+        it("should not update session when commitment has no sessionId", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId";
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                result: { status: CaptchaStatus.approved },
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({ decision: "allow" });
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv);
+            expect(result.verified).toBe(true);
+            expect(db.updateSessionRecord).not.toHaveBeenCalled();
+            imgCaptchaManager.decisionMachineRunner.decide = originalDecide;
+        });
+    });
+    describe("verifyImageCaptchaSolution with spam email domain checking", () => {
+        it("should disapprove when email domain is found in spam list", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const spamEmail = "user@spammydomain.com";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSpamEmailDomain.mockResolvedValue({
+                domain: "spammydomain.com",
+            });
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv, undefined, undefined, undefined, undefined, undefined, spamEmail, true);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("API.SPAM_EMAIL_DOMAIN");
+            expect(db.getSpamEmailDomain).toHaveBeenCalledWith("spammydomain.com");
+            expect(db.disapproveDappUserCommitment).toHaveBeenCalledWith(commitmentId, "API.SPAM_EMAIL_DOMAIN");
+        });
+        it("should allow when email domain is not in spam list", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const legitimateEmail = "user@legitimate.com";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSpamEmailDomain.mockResolvedValue(null);
+            db.disapproveDappUserCommitment = vi
+                .fn()
+                .mockResolvedValue(undefined);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({
+                decision: "allow",
+                reason: "Passed all checks",
+                score: 95,
+            });
+            try {
+                const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv, undefined, undefined, undefined, undefined, undefined, legitimateEmail, true);
+                expect(result.verified).toBe(true);
+                expect(result.status).toBe("API.USER_VERIFIED");
+                expect(db.getSpamEmailDomain).toHaveBeenCalledWith("legitimate.com");
+                expect(db.disapproveDappUserCommitment).not.toHaveBeenCalledWith(commitmentId, "API.SPAM_EMAIL_DOMAIN");
+            }
+            finally {
+                imgCaptchaManager.decisionMachineRunner.decide =
+                    originalDecide;
+            }
+        });
+        it("should skip spam check when no email is provided and email checking is enabled", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({
+                decision: "allow",
+                reason: "Passed all checks",
+                score: 95,
+            });
+            try {
+                const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv, undefined, undefined, undefined, undefined, undefined, undefined, true);
+                expect(result.verified).toBe(true);
+                expect(result.status).toBe("API.USER_VERIFIED");
+                expect(db.getSpamEmailDomain).not.toHaveBeenCalled();
+            }
+            finally {
+                imgCaptchaManager.decisionMachineRunner.decide =
+                    originalDecide;
+            }
+        });
+        it("should handle @domain.com email format correctly", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const atDomainEmail = "@spammydomain.com";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSpamEmailDomain.mockResolvedValue({
+                domain: "spammydomain.com",
+            });
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv, undefined, undefined, undefined, undefined, undefined, atDomainEmail, true);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("API.SPAM_EMAIL_DOMAIN");
+            expect(db.getSpamEmailDomain).toHaveBeenCalledWith("spammydomain.com");
+            expect(db.disapproveDappUserCommitment).toHaveBeenCalledWith(commitmentId, "API.SPAM_EMAIL_DOMAIN");
+        });
+        it("should handle domain-only format correctly", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const domainOnly = "spammydomain.com";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSpamEmailDomain.mockResolvedValue({
+                domain: "spammydomain.com",
+            });
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv, undefined, undefined, undefined, undefined, undefined, domainOnly, true);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("API.SPAM_EMAIL_DOMAIN");
+            expect(db.getSpamEmailDomain).toHaveBeenCalledWith("spammydomain.com");
+        });
+        it("should continue verification if spam check fails (fail-safe)", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const commitmentId = "commitmentId123";
+            const email = "user@example.com";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: commitmentId,
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentById.mockResolvedValue(commitment);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSpamEmailDomain.mockRejectedValue(new Error("Database connection error"));
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({
+                decision: "allow",
+                reason: "Passed all checks",
+                score: 95,
+            });
+            try {
+                const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, commitmentId, mockEnv, undefined, undefined, undefined, undefined, undefined, email, true);
+                expect(result.verified).toBe(true);
+                expect(result.status).toBe("API.USER_VERIFIED");
+                expect(db.getSpamEmailDomain).toHaveBeenCalled();
+            }
+            finally {
+                imgCaptchaManager.decisionMachineRunner.decide =
+                    originalDecide;
+            }
+        });
+        it("should not call disapproveDappUserCommitment when commitmentId is undefined", async () => {
+            const userAccount = "userAccount";
+            const dappAccount = "dappAccount";
+            const spamEmail = "user@spammydomain.com";
+            const ipAddress = getIPAddress("1.1.1.1");
+            const headers = { a: "1", b: "2", c: "3" };
+            const commitment = {
+                id: "someId",
+                userAccount,
+                dappAccount,
+                providerAccount: "providerAccount",
+                datasetId: "datasetId",
+                result: { status: CaptchaStatus.approved },
+                userSignature: "",
+                userSubmitted: true,
+                serverChecked: false,
+                requestedAtTimestamp: new Date(),
+                ipAddress: {
+                    lower: ipAddress.bigInt(),
+                    upper: 0n,
+                    type: IpAddressType.v4,
+                },
+                headers,
+                ja4: "ja4",
+                lastUpdatedTimestamp: new Date(),
+            };
+            db.getDappUserCommitmentByAccount.mockResolvedValue([
+                commitment,
+            ]);
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSpamEmailDomain.mockResolvedValue({
+                domain: "spammydomain.com",
+            });
+            db.disapproveDappUserCommitment = vi
+                .fn()
+                .mockResolvedValue(undefined);
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution(userAccount, dappAccount, undefined, mockEnv, undefined, undefined, undefined, undefined, undefined, spamEmail, true);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("API.SPAM_EMAIL_DOMAIN");
+            expect(db.getSpamEmailDomain).toHaveBeenCalledWith("spammydomain.com");
+            expect(db.disapproveDappUserCommitment).not.toHaveBeenCalled();
+        });
+    });
+    describe("verifyImageCaptchaSolution with disallowWebView", () => {
+        const ipAddress = getIPAddress("1.1.1.1");
+        const headers = { a: "1", b: "2", c: "3" };
+        const sessionId = "test-session-webview";
+        const baseCommitment = (commitmentId) => ({
+            id: commitmentId,
+            userAccount: "userAccount",
+            dappAccount: "dappAccount",
+            providerAccount: "providerAccount",
+            datasetId: "datasetId",
+            result: { status: CaptchaStatus.approved },
+            userSignature: "",
+            userSubmitted: true,
+            serverChecked: false,
+            requestedAtTimestamp: new Date(),
+            ipAddress: {
+                lower: ipAddress.bigInt(),
+                upper: 0n,
+                type: IpAddressType.v4,
+            },
+            headers,
+            ja4: "ja4",
+            lastUpdatedTimestamp: new Date(),
+            sessionId,
+        });
+        it("should disapprove and persist DISALLOWED_WEBVIEW when scoreComponents.webView > 0", async () => {
+            const commitmentId = "webviewScoreCommitmentId";
+            db.getDappUserCommitmentById.mockResolvedValue(baseCommitment(commitmentId));
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSessionRecordBySessionId.mockResolvedValue({
+                sessionId,
+                scoreComponents: { baseScore: 1, webView: 0.1 },
+                webView: true,
+                reason: "WEBVIEW_DETECTED",
+            });
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution("userAccount", "dappAccount", commitmentId, mockEnv, undefined, undefined, true);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("API.DISALLOWED_WEBVIEW");
+            expect(db.disapproveDappUserCommitment).toHaveBeenCalledWith(commitmentId, "API.DISALLOWED_WEBVIEW");
+            expect(db.updateSessionRecord).toHaveBeenCalledWith(sessionId, {
+                serverChecked: true,
+                result: {
+                    status: CaptchaStatus.disapproved,
+                    reason: "API.DISALLOWED_WEBVIEW",
+                },
+            }, true);
+            expect(db.approveDappUserCommitment).not.toHaveBeenCalled();
+        });
+        it("should disapprove when session.webView is true even if scoreComponents.webView is unset", async () => {
+            const commitmentId = "webviewBoolCommitmentId";
+            db.getDappUserCommitmentById.mockResolvedValue(baseCommitment(commitmentId));
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSessionRecordBySessionId.mockResolvedValue({
+                sessionId,
+                scoreComponents: { baseScore: 1 },
+                webView: true,
+                reason: "USER_AGENT_MISMATCH",
+            });
+            db.disapproveDappUserCommitment.mockResolvedValue(undefined);
+            const result = await imgCaptchaManager.verifyImageCaptchaSolution("userAccount", "dappAccount", commitmentId, mockEnv, undefined, undefined, true);
+            expect(result.verified).toBe(false);
+            expect(result.status).toBe("API.DISALLOWED_WEBVIEW");
+            expect(db.disapproveDappUserCommitment).toHaveBeenCalledWith(commitmentId, "API.DISALLOWED_WEBVIEW");
+        });
+        it("should not block when disallowWebView is false even if webview is detected", async () => {
+            const commitmentId = "webviewAllowedCommitmentId";
+            db.getDappUserCommitmentById.mockResolvedValue(baseCommitment(commitmentId));
+            db.markDappUserCommitmentsChecked.mockResolvedValue(undefined);
+            db.getSessionRecordBySessionId.mockResolvedValue({
+                sessionId,
+                scoreComponents: { baseScore: 1, webView: 0.1 },
+                webView: true,
+            });
+            const originalDecide = imgCaptchaManager.decisionMachineRunner.decide;
+            imgCaptchaManager.decisionMachineRunner.decide = vi
+                .fn()
+                .mockResolvedValue({ decision: "allow" });
+            try {
+                const result = await imgCaptchaManager.verifyImageCaptchaSolution("userAccount", "dappAccount", commitmentId, mockEnv, undefined, undefined, false);
+                expect(result.verified).toBe(true);
+                expect(result.status).toBe("API.USER_VERIFIED");
+                expect(db.approveDappUserCommitment).toHaveBeenCalledWith(commitmentId);
+            }
+            finally {
+                imgCaptchaManager.decisionMachineRunner.decide =
+                    originalDecide;
+            }
+        });
+    });
+});
+//# sourceMappingURL=imgCaptchaTasks.unit.test.js.map