@prosopo/provider 3.15.0 → 4.7.1

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

@@ -1,12 +1,13 @@
 import { u8aToHex } from "@polkadot/util";
-import { ProsopoEnvError, getLogger } from "@prosopo/common";
-import { computePendingRequestHash, parseAndSortCaptchaSolutions, } from "@prosopo/datasets";
-import { CaptchaStatus, } from "@prosopo/types";
-import { IpAddressType, } from "@prosopo/types-database";
+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 } from "@prosopo/util-crypto";
+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", () => ({
@@ -126,9 +127,18 @@ describe("ImgCaptchaManager", () => {
             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(),
@@ -156,6 +166,15 @@ describe("ImgCaptchaManager", () => {
                     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();
     });
@@ -275,13 +294,13 @@ describe("ImgCaptchaManager", () => {
     });
     it("should validate dapp user solution request is pending", async () => {
         const requestHash = "requestHash";
-        const timestamp = Date.now() + 10000;
+        const deadlineTimestamp = new Date(Date.now() + 10000);
         const pendingRecord = {
             requestHash: "requestHash",
             userAccount: "userAccount",
             datasetId: "datasetId",
             salt: "salt",
-            deadlineTimestamp: timestamp,
+            deadlineTimestamp: deadlineTimestamp,
             currentBlockNumber: 0,
         };
         const userAccount = "userAccount";
@@ -292,13 +311,13 @@ describe("ImgCaptchaManager", () => {
     });
     it("should return false if deadline has expired", async () => {
         const requestHash = "requestHash";
-        const timestamp = Date.now() - 10000;
+        const deadline = new Date(Date.now() - 10000);
         const pendingRecord = {
             requestHash: "requestHash",
             userAccount: "userAccount",
             datasetId: "datasetId",
             salt: "salt",
-            deadlineTimestamp: timestamp,
+            deadlineTimestamp: deadline,
             currentBlockNumber: 0,
         };
         const userAccount = "userAccount";
@@ -311,6 +330,55 @@ describe("ImgCaptchaManager", () => {
             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 = {
@@ -384,5 +452,647 @@ describe("ImgCaptchaManager", () => {
         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