@prosopo/provider 3.2.0 → 3.2.1

package/dist/tasks/imgCaptcha/imgCaptchaTasks.js

@@ -1,7 +1,7 @@
-import { stringToHex, u8aToHex } from "@polkadot/util";
+import { u8aToHex, stringToHex } from "@polkadot/util";
 import { ProsopoEnvError } from "@prosopo/common";
-import { compareCaptchaSolutions, computePendingRequestHash, parseAndSortCaptchaSolutions, } from "@prosopo/datasets";
-import { ApiParams, CaptchaStatus, DEFAULT_IMAGE_CAPTCHA_TIMEOUT, } from "@prosopo/types";
+import { computePendingRequestHash, compareCaptchaSolutions, parseAndSortCaptchaSolutions } from "@prosopo/datasets";
+import { DEFAULT_IMAGE_CAPTCHA_TIMEOUT, CaptchaStatus, ApiParams } from "@prosopo/types";
 import { at } from "@prosopo/util";
 import { randomAsHex, signatureVerify } from "@prosopo/util-crypto";
 import { checkLangRules } from "../../rules/lang.js";
@@ -9,293 +9,382 @@ import { shuffleArray, validateIpAddress } from "../../util.js";
 import { CaptchaManager } from "../captchaManager.js";
 import { computeFrictionlessScore } from "../frictionless/frictionlessTasksUtils.js";
 import { buildTreeAndGetCommitmentId } from "./imgCaptchaTasksUtils.js";
-export class ImgCaptchaManager extends CaptchaManager {
-    constructor(db, pair, config, logger) {
-        super(db, pair, logger);
-        this.config = config;
-    }
-    async getCaptchaWithProof(datasetId, solved, size) {
-        const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
-        if (!captchaDocs) {
-            throw new ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
-                context: {
-                    failedFuncName: this.getCaptchaWithProof.name,
-                    datasetId,
-                    solved,
-                    size,
-                },
-            });
+class ImgCaptchaManager extends CaptchaManager {
+  constructor(db, pair, config, logger) {
+    super(db, pair, logger);
+    this.config = config;
+  }
+  async getCaptchaWithProof(datasetId, solved, size) {
+    const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
+    if (!captchaDocs) {
+      throw new ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
+        context: {
+          failedFuncName: this.getCaptchaWithProof.name,
+          datasetId,
+          solved,
+          size
         }
-        return captchaDocs;
+      });
     }
-    async getRandomCaptchasAndRequestHash(datasetId, userAccount, ipAddress, captchaConfig, threshold, frictionlessTokenId) {
-        const dataset = await this.db.getDatasetDetails(datasetId);
-        if (!dataset) {
-            throw new ProsopoEnvError("DATABASE.DATASET_GET_FAILED", {
-                context: {
-                    failedFuncName: this.getRandomCaptchasAndRequestHash.name,
-                    dataset,
-                    datasetId,
-                },
-            });
-        }
-        const unsolvedCount = Math.abs(Math.trunc(captchaConfig.unsolved.count));
-        const solvedCount = Math.abs(Math.trunc(captchaConfig.solved.count));
-        if (!solvedCount) {
-            throw new ProsopoEnvError("CONFIG.INVALID_CAPTCHA_NUMBER");
-        }
-        const solved = await this.getCaptchaWithProof(datasetId, true, solvedCount);
-        let unsolved = [];
-        if (unsolvedCount) {
-            unsolved = await this.getCaptchaWithProof(datasetId, false, unsolvedCount);
+    return captchaDocs;
+  }
+  async getRandomCaptchasAndRequestHash(datasetId, userAccount, ipAddress, captchaConfig, threshold, frictionlessTokenId) {
+    const dataset = await this.db.getDatasetDetails(datasetId);
+    if (!dataset) {
+      throw new ProsopoEnvError("DATABASE.DATASET_GET_FAILED", {
+        context: {
+          failedFuncName: this.getRandomCaptchasAndRequestHash.name,
+          dataset,
+          datasetId
         }
-        const captchas = shuffleArray([...solved, ...unsolved]);
-        const salt = randomAsHex();
-        const requestHash = computePendingRequestHash(captchas.map((c) => c.captchaId), userAccount, salt);
-        const currentTime = Date.now();
-        const signedRequestHash = u8aToHex(this.pair.sign(stringToHex(requestHash)));
-        const timeLimit = captchas
-            .map((captcha) => captcha.timeLimitMs || DEFAULT_IMAGE_CAPTCHA_TIMEOUT)
-            .reduce((a, b) => a + b, 0);
-        const deadlineTs = timeLimit + currentTime;
-        await this.db.storePendingImageCommitment(userAccount, requestHash, salt, deadlineTs, currentTime, ipAddress.bigInt(), threshold, frictionlessTokenId);
-        return {
-            captchas,
-            requestHash,
-            timestamp: currentTime,
-            signedRequestHash,
-        };
+      });
     }
-    async dappUserSolution(userAccount, dappAccount, requestHash, captchas, userTimestampSignature, timestamp, providerRequestHashSignature, ipAddress, headers, ja4) {
-        const verification = signatureVerify(stringToHex(timestamp.toString()), userTimestampSignature, userAccount);
-        if (!verification.isValid) {
-            const err = new ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
-                context: { failedFuncName: this.dappUserSolution.name, userAccount },
-            });
-            this.logger.info(() => ({
-                err,
-                msg: "Invalid user timestamp signature",
-            }));
-            throw err;
+    const unsolvedCount = Math.abs(
+      Math.trunc(captchaConfig.unsolved.count)
+    );
+    const solvedCount = Math.abs(
+      Math.trunc(captchaConfig.solved.count)
+    );
+    if (!solvedCount) {
+      throw new ProsopoEnvError("CONFIG.INVALID_CAPTCHA_NUMBER");
+    }
+    const solved = await this.getCaptchaWithProof(datasetId, true, solvedCount);
+    let unsolved = [];
+    if (unsolvedCount) {
+      unsolved = await this.getCaptchaWithProof(
+        datasetId,
+        false,
+        unsolvedCount
+      );
+    }
+    const captchas = shuffleArray([...solved, ...unsolved]);
+    const salt = randomAsHex();
+    const requestHash = computePendingRequestHash(
+      captchas.map((c) => c.captchaId),
+      userAccount,
+      salt
+    );
+    const currentTime = Date.now();
+    const signedRequestHash = u8aToHex(
+      this.pair.sign(stringToHex(requestHash))
+    );
+    const timeLimit = captchas.map((captcha) => captcha.timeLimitMs || DEFAULT_IMAGE_CAPTCHA_TIMEOUT).reduce((a, b) => a + b, 0);
+    const deadlineTs = timeLimit + currentTime;
+    await this.db.storePendingImageCommitment(
+      userAccount,
+      requestHash,
+      salt,
+      deadlineTs,
+      currentTime,
+      ipAddress.bigInt(),
+      threshold,
+      frictionlessTokenId
+    );
+    return {
+      captchas,
+      requestHash,
+      timestamp: currentTime,
+      signedRequestHash
+    };
+  }
+  /**
+   * Validate and store the text captcha solution(s) from the Dapp User in a web2 environment
+   * @param {string} userAccount
+   * @param {string} dappAccount
+   * @param {string} requestHash
+   * @param {JSON} captchas
+   * @param userTimestampSignature
+   * @param timestamp
+   * @param providerRequestHashSignature
+   * @param ipAddress
+   * @param headers
+   * @param threshold the percentage of captchas that must be correct to return true
+   * @return {Promise<DappUserSolutionResult>} result containing the contract event
+   */
+  async dappUserSolution(userAccount, dappAccount, requestHash, captchas, userTimestampSignature, timestamp, providerRequestHashSignature, ipAddress, headers, ja4) {
+    const verification = signatureVerify(
+      stringToHex(timestamp.toString()),
+      userTimestampSignature,
+      userAccount
+    );
+    if (!verification.isValid) {
+      const err = new ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
+        context: { failedFuncName: this.dappUserSolution.name, userAccount }
+      });
+      this.logger.info(() => ({
+        err,
+        msg: "Invalid user timestamp signature"
+      }));
+      throw err;
+    }
+    const providerRequestHashSignatureVerify = signatureVerify(
+      stringToHex(requestHash.toString()),
+      providerRequestHashSignature,
+      this.pair.address
+    );
+    if (!providerRequestHashSignatureVerify.isValid) {
+      const err = new ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
+        context: {
+          failedFuncName: this.dappUserSolution.name,
+          userAccount,
+          error: "requestHash signature is invalid"
         }
-        const providerRequestHashSignatureVerify = signatureVerify(stringToHex(requestHash.toString()), providerRequestHashSignature, this.pair.address);
-        if (!providerRequestHashSignatureVerify.isValid) {
-            const err = new ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
-                context: {
-                    failedFuncName: this.dappUserSolution.name,
-                    userAccount,
-                    error: "requestHash signature is invalid",
-                },
+      });
+      this.logger.info(() => ({
+        err,
+        msg: "Invalid provider requestHash signature"
+      }));
+      throw err;
+    }
+    let response = {
+      captchas: [],
+      verified: false
+    };
+    const pendingRecord = await this.db.getPendingImageCommitment(requestHash);
+    const unverifiedCaptchaIds = captchas.map((captcha) => captcha.captchaId);
+    const pendingRequest = await this.validateDappUserSolutionRequestIsPending(
+      requestHash,
+      pendingRecord,
+      userAccount,
+      unverifiedCaptchaIds
+    );
+    if (pendingRequest) {
+      const { storedCaptchas, receivedCaptchas, captchaIds } = await this.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
+      const { tree, commitmentId } = buildTreeAndGetCommitmentId(receivedCaptchas);
+      const datasetId = at(storedCaptchas, 0).datasetId;
+      if (!datasetId) {
+        throw new ProsopoEnvError("CAPTCHA.ID_MISMATCH", {
+          context: { failedFuncName: this.dappUserSolution.name }
+        });
+      }
+      await this.db.updatePendingImageCommitmentStatus(requestHash);
+      const commit = {
+        id: commitmentId,
+        userAccount,
+        dappAccount,
+        providerAccount: this.pair.address,
+        datasetId,
+        result: { status: CaptchaStatus.pending },
+        userSignature: userTimestampSignature,
+        userSubmitted: true,
+        serverChecked: false,
+        requestedAtTimestamp: timestamp,
+        ipAddress,
+        headers,
+        frictionlessTokenId: pendingRecord.frictionlessTokenId,
+        ja4
+      };
+      await this.db.storeUserImageCaptchaSolution(receivedCaptchas, commit);
+      const solutionRecords = await Promise.all(
+        storedCaptchas.map(async (captcha) => {
+          const solutionRecord = await this.db.getSolutionByCaptchaId(
+            captcha.captchaId
+          );
+          if (!solutionRecord) {
+            throw new ProsopoEnvError("CAPTCHA.SOLUTION_NOT_FOUND", {
+              context: { failedFuncName: this.dappUserSolution.name }
             });
-            this.logger.info(() => ({
-                err,
-                msg: "Invalid provider requestHash signature",
-            }));
-            throw err;
-        }
-        let response = {
-            captchas: [],
-            verified: false,
+          }
+          return solutionRecord;
+        })
+      );
+      const totalImages = storedCaptchas[0]?.items.length || 0;
+      if (compareCaptchaSolutions(
+        receivedCaptchas,
+        solutionRecords,
+        totalImages,
+        pendingRecord.threshold
+      )) {
+        response = {
+          captchas: captchaIds.map((id) => ({
+            captchaId: id,
+            proof: tree.proof(id)
+          })),
+          verified: true
         };
-        const pendingRecord = await this.db.getPendingImageCommitment(requestHash);
-        const unverifiedCaptchaIds = captchas.map((captcha) => captcha.captchaId);
-        const pendingRequest = await this.validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, unverifiedCaptchaIds);
-        if (pendingRequest) {
-            const { storedCaptchas, receivedCaptchas, captchaIds } = await this.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
-            const { tree, commitmentId } = buildTreeAndGetCommitmentId(receivedCaptchas);
-            const datasetId = at(storedCaptchas, 0).datasetId;
-            if (!datasetId) {
-                throw new ProsopoEnvError("CAPTCHA.ID_MISMATCH", {
-                    context: { failedFuncName: this.dappUserSolution.name },
-                });
-            }
-            await this.db.updatePendingImageCommitmentStatus(requestHash);
-            const commit = {
-                id: commitmentId,
-                userAccount: userAccount,
-                dappAccount,
-                providerAccount: this.pair.address,
-                datasetId,
-                result: { status: CaptchaStatus.pending },
-                userSignature: userTimestampSignature,
-                userSubmitted: true,
-                serverChecked: false,
-                requestedAtTimestamp: timestamp,
-                ipAddress,
-                headers,
-                frictionlessTokenId: pendingRecord.frictionlessTokenId,
-                ja4,
-            };
-            await this.db.storeUserImageCaptchaSolution(receivedCaptchas, commit);
-            const solutionRecords = await Promise.all(storedCaptchas.map(async (captcha) => {
-                const solutionRecord = await this.db.getSolutionByCaptchaId(captcha.captchaId);
-                if (!solutionRecord) {
-                    throw new ProsopoEnvError("CAPTCHA.SOLUTION_NOT_FOUND", {
-                        context: { failedFuncName: this.dappUserSolution.name },
-                    });
-                }
-                return solutionRecord;
-            }));
-            const totalImages = storedCaptchas[0]?.items.length || 0;
-            if (compareCaptchaSolutions(receivedCaptchas, solutionRecords, totalImages, pendingRecord.threshold)) {
-                response = {
-                    captchas: captchaIds.map((id) => ({
-                        captchaId: id,
-                        proof: tree.proof(id),
-                    })),
-                    verified: true,
-                };
-                await this.db.approveDappUserCommitment(commitmentId);
-            }
-            else {
-                await this.db.disapproveDappUserCommitment(commitmentId, "CAPTCHA.INVALID_SOLUTION");
-                response = {
-                    captchas: captchaIds.map((id) => ({
-                        captchaId: id,
-                        proof: [[]],
-                    })),
-                    verified: false,
-                };
-            }
-        }
-        else {
-            this.logger.info(() => ({
-                msg: "Request hash not found",
-            }));
-        }
-        return response;
+        await this.db.approveDappUserCommitment(commitmentId);
+      } else {
+        await this.db.disapproveDappUserCommitment(
+          commitmentId,
+          "CAPTCHA.INVALID_SOLUTION"
+        );
+        response = {
+          captchas: captchaIds.map((id) => ({
+            captchaId: id,
+            proof: [[]]
+          })),
+          verified: false
+        };
+      }
+    } else {
+      this.logger.info(() => ({
+        msg: "Request hash not found"
+      }));
     }
-    async validateReceivedCaptchasAgainstStoredCaptchas(captchas) {
-        const receivedCaptchas = parseAndSortCaptchaSolutions(captchas);
-        const captchaIds = receivedCaptchas.map((captcha) => captcha.captchaId);
-        const storedCaptchas = await this.db.getCaptchaById(captchaIds);
-        if (!storedCaptchas || receivedCaptchas.length !== storedCaptchas.length) {
-            throw new ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_ID", {
-                context: {
-                    failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
-                    captchas,
-                },
-            });
-        }
-        if (!storedCaptchas.every((captcha) => captcha.datasetId === at(storedCaptchas, 0).datasetId)) {
-            throw new ProsopoEnvError("CAPTCHA.DIFFERENT_DATASET_IDS", {
-                context: {
-                    failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
-                    captchas,
-                },
-            });
+    return response;
+  }
+  /**
+   * Validate length of received captchas array matches length of captchas found in database
+   * Validate that the datasetId is the same for all captchas and is equal to the datasetId on the stored captchas
+   */
+  async validateReceivedCaptchasAgainstStoredCaptchas(captchas) {
+    const receivedCaptchas = parseAndSortCaptchaSolutions(captchas);
+    const captchaIds = receivedCaptchas.map((captcha) => captcha.captchaId);
+    const storedCaptchas = await this.db.getCaptchaById(captchaIds);
+    if (!storedCaptchas || receivedCaptchas.length !== storedCaptchas.length) {
+      throw new ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_ID", {
+        context: {
+          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+          captchas
         }
-        return { storedCaptchas, receivedCaptchas, captchaIds };
+      });
     }
-    async validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds) {
-        const currentTime = Date.now();
-        if (!pendingRecord) {
-            this.logger.info(() => ({
-                msg: "No pending record found",
-            }));
-            return false;
-        }
-        if (pendingRecord.deadlineTimestamp < currentTime) {
-            this.logger.info(() => ({
-                msg: "Deadline for responding to captcha has expired",
-            }));
-            return false;
-        }
-        if (pendingRecord) {
-            const pendingHashComputed = computePendingRequestHash(captchaIds, userAccount, pendingRecord.salt);
-            return requestHash === pendingHashComputed;
+    if (!storedCaptchas.every(
+      (captcha) => captcha.datasetId === at(storedCaptchas, 0).datasetId
+    )) {
+      throw new ProsopoEnvError("CAPTCHA.DIFFERENT_DATASET_IDS", {
+        context: {
+          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+          captchas
         }
-        return false;
+      });
     }
-    async getDappUserCommitmentById(commitmentId) {
-        const dappUserSolution = await this.db.getDappUserCommitmentById(commitmentId);
-        if (!dappUserSolution) {
-            throw new ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-                context: {
-                    failedFuncName: this.getDappUserCommitmentById.name,
-                    commitmentId: commitmentId,
-                },
-            });
-        }
-        return dappUserSolution;
+    return { storedCaptchas, receivedCaptchas, captchaIds };
+  }
+  /**
+   * Validate that a Dapp User is responding to their own pending captcha request
+   * @param {string} requestHash
+   * @param {PendingCaptchaRequest} pendingRecord
+   * @param {string} userAccount
+   * @param {string[]} captchaIds
+   */
+  async validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds) {
+    const currentTime = Date.now();
+    if (!pendingRecord) {
+      this.logger.info(() => ({
+        msg: "No pending record found"
+      }));
+      return false;
     }
-    async getDappUserCommitmentByAccount(userAccount, dappAccount) {
-        const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(userAccount, dappAccount);
-        if (dappUserSolutions.length > 0) {
-            for (const dappUserSolution of dappUserSolutions) {
-                if (dappUserSolution.result.status === CaptchaStatus.approved) {
-                    return dappUserSolution;
-                }
-            }
-        }
-        return undefined;
+    if (pendingRecord.deadlineTimestamp < currentTime) {
+      this.logger.info(() => ({
+        msg: "Deadline for responding to captcha has expired"
+      }));
+      return false;
     }
-    async verifyImageCaptchaSolution(user, dapp, commitmentId, maxVerifiedTime, ip) {
-        const solution = await (commitmentId
-            ? this.getDappUserCommitmentById(commitmentId)
-            : this.getDappUserCommitmentByAccount(user, dapp));
-        if (!solution) {
-            this.logger.debug(() => ({
-                msg: "Not verified - no solution found",
-            }));
-            return { status: "API.USER_NOT_VERIFIED_NO_SOLUTION", verified: false };
-        }
-        const ipValidation = validateIpAddress(ip, solution.ipAddress, this.logger);
-        if (!ipValidation.isValid) {
-            return { status: "API.USER_NOT_VERIFIED", verified: false };
-        }
-        if (solution.serverChecked) {
-            return { status: "API.USER_ALREADY_VERIFIED", verified: false };
-        }
-        await this.db.markDappUserCommitmentsChecked([solution.id]);
-        if (solution.result.status === CaptchaStatus.disapproved) {
-            return { status: "API.USER_NOT_VERIFIED", verified: false };
-        }
-        maxVerifiedTime = maxVerifiedTime || 60 * 1000;
-        if (maxVerifiedTime) {
-            const currentTime = Date.now();
-            const timeSinceCompletion = currentTime - solution.requestedAtTimestamp;
-            if (timeSinceCompletion > maxVerifiedTime) {
-                this.logger.debug(() => ({
-                    msg: "Not verified - timed out",
-                }));
-                return {
-                    status: "API.USER_NOT_VERIFIED_TIME_EXPIRED",
-                    verified: false,
-                };
-            }
+    if (pendingRecord) {
+      const pendingHashComputed = computePendingRequestHash(
+        captchaIds,
+        userAccount,
+        pendingRecord.salt
+      );
+      return requestHash === pendingHashComputed;
+    }
+    return false;
+  }
+  /*
+   * Get dapp user solution from database
+   */
+  async getDappUserCommitmentById(commitmentId) {
+    const dappUserSolution = await this.db.getDappUserCommitmentById(commitmentId);
+    if (!dappUserSolution) {
+      throw new ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
+        context: {
+          failedFuncName: this.getDappUserCommitmentById.name,
+          commitmentId
         }
-        const isApproved = solution.result.status === CaptchaStatus.approved;
-        let score;
-        if (solution.frictionlessTokenId) {
-            const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(solution.frictionlessTokenId);
-            if (tokenRecord) {
-                score = computeFrictionlessScore(tokenRecord?.scoreComponents);
-                this.logger.info(() => ({
-                    data: {
-                        tscoreComponents: tokenRecord?.scoreComponents,
-                        score: score,
-                    },
-                }));
-            }
+      });
+    }
+    return dappUserSolution;
+  }
+  /* Check if dapp user has verified solution in cache */
+  async getDappUserCommitmentByAccount(userAccount, dappAccount) {
+    const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(
+      userAccount,
+      dappAccount
+    );
+    if (dappUserSolutions.length > 0) {
+      for (const dappUserSolution of dappUserSolutions) {
+        if (dappUserSolution.result.status === CaptchaStatus.approved) {
+          return dappUserSolution;
         }
-        return {
-            status: isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED",
-            verified: isApproved,
-            commitmentId: solution.id.toString(),
-            ...(score && { score }),
-        };
+      }
     }
-    checkLangRules(acceptLanguage) {
-        return checkLangRules(this.config, acceptLanguage);
+    return void 0;
+  }
+  async verifyImageCaptchaSolution(user, dapp, commitmentId, maxVerifiedTime, ip) {
+    const solution = await (commitmentId ? this.getDappUserCommitmentById(commitmentId) : this.getDappUserCommitmentByAccount(user, dapp));
+    if (!solution) {
+      this.logger.debug(() => ({
+        msg: "Not verified - no solution found"
+      }));
+      return { status: "API.USER_NOT_VERIFIED_NO_SOLUTION", verified: false };
     }
-    getVerificationResponse(verified, clientRecord, translateFn, score, commitmentId) {
+    const ipValidation = validateIpAddress(ip, solution.ipAddress, this.logger);
+    if (!ipValidation.isValid) {
+      return { status: "API.USER_NOT_VERIFIED", verified: false };
+    }
+    if (solution.serverChecked) {
+      return { status: "API.USER_ALREADY_VERIFIED", verified: false };
+    }
+    await this.db.markDappUserCommitmentsChecked([solution.id]);
+    if (solution.result.status === CaptchaStatus.disapproved) {
+      return { status: "API.USER_NOT_VERIFIED", verified: false };
+    }
+    maxVerifiedTime = maxVerifiedTime || 60 * 1e3;
+    if (maxVerifiedTime) {
+      const currentTime = Date.now();
+      const timeSinceCompletion = currentTime - solution.requestedAtTimestamp;
+      if (timeSinceCompletion > maxVerifiedTime) {
+        this.logger.debug(() => ({
+          msg: "Not verified - timed out"
+        }));
         return {
-            ...super.getVerificationResponse(verified, clientRecord, translateFn, score),
-            ...(commitmentId && {
-                [ApiParams.commitmentId]: commitmentId,
-            }),
+          status: "API.USER_NOT_VERIFIED_TIME_EXPIRED",
+          verified: false
         };
+      }
+    }
+    const isApproved = solution.result.status === CaptchaStatus.approved;
+    let score;
+    if (solution.frictionlessTokenId) {
+      const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(
+        solution.frictionlessTokenId
+      );
+      if (tokenRecord) {
+        score = computeFrictionlessScore(tokenRecord?.scoreComponents);
+        this.logger.info(() => ({
+          data: {
+            tscoreComponents: tokenRecord?.scoreComponents,
+            score
+          }
+        }));
+      }
     }
+    return {
+      status: isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED",
+      verified: isApproved,
+      commitmentId: solution.id.toString(),
+      ...score && { score }
+    };
+  }
+  checkLangRules(acceptLanguage) {
+    return checkLangRules(this.config, acceptLanguage);
+  }
+  getVerificationResponse(verified, clientRecord, translateFn, score, commitmentId) {
+    return {
+      ...super.getVerificationResponse(
+        verified,
+        clientRecord,
+        translateFn,
+        score
+      ),
+      ...commitmentId && {
+        [ApiParams.commitmentId]: commitmentId
+      }
+    };
+  }
 }
-//# sourceMappingURL=imgCaptchaTasks.js.map
+export {
+  ImgCaptchaManager
+};