@prosopo/provider 4.15.13 → 4.15.15

package/dist/cjs/tasks/puzzleCaptcha/puzzleTasks.cjs

@@ -1,592 +1,423 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const common = require("@prosopo/common");
-const types = require("@prosopo/types");
-const util$1 = require("@prosopo/util");
-const compositeIpAddress = require("../../compositeIpAddress.cjs");
-const util$2 = require("../../util.cjs");
-const usageCounters = require("../../util/usageCounters.cjs");
-const captchaManager = require("../captchaManager.cjs");
-const decisionMachineRunner = require("../decisionMachine/decisionMachineRunner.cjs");
-const enrichDnsEvent = require("../dnsEvent/enrichDnsEvent.cjs");
-const frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.cjs");
-const powTasksUtils = require("../powCaptcha/powTasksUtils.cjs");
-const puzzleTasksUtils = require("./puzzleTasksUtils.cjs");
-class PuzzleCaptchaManager extends captchaManager.CaptchaManager {
-  constructor(db, pair, config, logger, usageCounters2) {
-    super(db, pair, config, logger);
-    this.POW_SEPARATOR = types.POW_SEPARATOR;
-    this.decisionMachineRunner = new decisionMachineRunner.DecisionMachineRunner(db);
-    this.usageCounters = usageCounters2 ?? null;
-  }
-  /**
-   * @description Generates a Puzzle Captcha challenge for a given user and dapp
-   *
-   * @param {string} userAccount - user that is solving the captcha
-   * @param {string} dappAccount - dapp that is requesting the captcha
-   * @param origin - not currently used
-   * @param tolerance
-   */
-  async getPuzzleCaptchaChallenge(userAccount, dappAccount, origin, tolerance) {
-    const resolvedTolerance = tolerance ?? types.puzzleToleranceDefault;
-    const requestedAtTimestamp = Date.now();
-    const nonce = Math.floor(Math.random() * 1e6);
-    const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}___${nonce}`;
-    const challengeSignature = util.u8aToHex(this.pair.sign(util.stringToHex(challenge)));
-    const targetX = Math.floor(Math.random() * (280 - 150 + 1)) + 150;
-    const targetY = Math.floor(Math.random() * (170 - 30 + 1)) + 30;
-    const originX = Math.floor(Math.random() * (130 - 20 + 1)) + 20;
-    const originY = Math.floor(Math.random() * (170 - 30 + 1)) + 30;
-    return {
-      challenge,
-      targetX,
-      targetY,
-      originX,
-      originY,
-      tolerance: resolvedTolerance,
-      providerSignature: challengeSignature,
-      requestedAtTimestamp
-    };
-  }
-  /**
-   * @description Verifies a Puzzle Captcha solution for a given user and dapp
-   *
-   * @param {string} challenge - the challenge string
-   * @param {string} providerChallengeSignature - proof that the Provider provided the challenge
-   * @param {number} finalX - the final X coordinate of the puzzle
-   * @param {number} finalY - the final Y coordinate of the puzzle
-   * @param {PuzzleEvent[]} puzzleEvents - the puzzle event trail
-   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the captcha
-   * @param {string} userTimestampSignature
-   * @param ipAddress
-   * @param headers
-   * @param behavioralData
-   */
-  async verifyPuzzleCaptchaSolution(challenge, providerChallengeSignature, finalX, finalY, puzzleEvents, timeout, userTimestampSignature, ipAddress, headers, behavioralData, salt, simdReadings, clientMetaData) {
-    powTasksUtils.checkPowSignature(
-      challenge,
-      providerChallengeSignature,
-      this.pair.address,
-      types.ApiParams.challenge
-    );
-    const challengeSplit = challenge.split(this.POW_SEPARATOR);
-    const timestamp = Number.parseInt(util$1.at(challengeSplit, 0));
-    const userAccount = util$1.at(challengeSplit, 1);
-    powTasksUtils.checkPowSignature(
-      timestamp.toString(),
-      userTimestampSignature,
-      userAccount,
-      types.ApiParams.timestamp
-    );
-    const challengeRecord = await this.db.getPuzzleCaptchaRecordByChallenge(challenge);
-    if (!challengeRecord) {
-      this.logger.debug(() => ({
-        msg: `No record of this challenge: ${challenge}`
-      }));
-      return false;
-    }
-    let coords;
-    let saltDecodeError;
-    if (salt) {
-      try {
-        const extractedData = util$1.extractData(salt);
-        if (extractedData.length >= 2) {
-          const built = [
-            [[extractedData[0], extractedData[1]]]
-          ];
-          util$1.assertCoordsSafe(built, "coords");
-          coords = built;
-        }
-      } catch (error) {
-        saltDecodeError = error;
-        this.logger.warn(() => ({
-          msg: "Failed to extract coordinates from salt",
-          error,
-          salt
-        }));
-      }
-    }
-    if (challengeRecord.userSubmitted) {
-      this.logger.debug(() => ({
-        msg: `Challenge already submitted: ${challenge}`
-      }));
-      return false;
-    }
-    if (saltDecodeError) {
-      const badSaltResult = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.CAPTCHA_INVALID_SALT
-      };
-      await this.db.updatePuzzleCaptchaRecordResult(
-        challenge,
-        badSaltResult,
-        false,
-        // serverChecked
-        true,
-        // userSubmitted
-        userTimestampSignature,
-        void 0
-        // never persist the bad coords
-      );
-      if (challengeRecord.sessionId) {
-        await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-          userSubmitted: true,
-          result: badSaltResult
-        });
-      }
-      return false;
-    }
-    if (!util$1.verifyRecency(challenge, timeout)) {
-      const timeoutResult = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.CAPTCHA_INVALID_TIMESTAMP
-      };
-      await this.db.updatePuzzleCaptchaRecordResult(
-        challenge,
-        timeoutResult,
-        false,
-        //serverchecked
-        true,
-        // usersubmitted
-        userTimestampSignature,
-        coords
-      );
-      if (challengeRecord.sessionId) {
-        await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-          userSubmitted: true,
-          result: timeoutResult
-        });
-      }
-      return false;
-    }
-    const correct = puzzleTasksUtils.validatePuzzleSolution(
-      finalX,
-      finalY,
-      challengeRecord.targetX,
-      challengeRecord.targetY,
-      challengeRecord.tolerance
-    );
-    let result = { status: types.CaptchaStatus.approved };
-    if (!correct) {
-      result = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.CAPTCHA_INVALID_SOLUTION
-      };
-    }
-    if (correct && this.usageCounters) {
-      const dappAccount = util$1.at(challengeSplit, 2);
-      this.usageCounters.incrManyAsync(
-        dappAccount,
-        usageCounters.buildAllWindowIncrements(
-          "solved",
-          types.CaptchaType.puzzle,
-          ipAddress.address,
-          userAccount
-        )
-      );
-    }
-    if (behavioralData) {
-      try {
-        const decryptKeys = [
-          // Process DB keys first, then env var key last as env key will likely be invalid
-          ...await this.getDetectorKeys(),
-          process.env.BOT_DECRYPTION_KEY
-        ];
-        const decryptedData = await this.decryptBehavioralData(
-          behavioralData,
-          decryptKeys
-        );
-        if (decryptedData) {
-          const dappAccount = util$1.at(challengeSplit, 2);
-          this.logger?.info(() => ({
-            msg: "Behavioral analysis completed",
-            data: {
-              userAccount,
-              dappAccount,
-              challenge,
-              mouseEventsCount: decryptedData.collector1?.length || 0,
-              touchEventsCount: decryptedData.collector2?.length || 0,
-              clickEventsCount: decryptedData.collector3?.length || 0,
-              deviceCapability: decryptedData.deviceCapability,
-              captchaResult: correct ? "passed" : "failed"
-            }
-          }));
-          const packedData = {
-            c1: decryptedData.collector1 || [],
-            c2: decryptedData.collector2 || [],
-            c3: decryptedData.collector3 || [],
-            d: decryptedData.deviceCapability
-          };
-          await this.db.updatePuzzleCaptchaRecord(challenge, {
-            behavioralDataPacked: packedData,
-            deviceCapability: decryptedData.deviceCapability,
-            puzzleEvents
-          });
-        }
-      } catch (error) {
-        this.logger?.error(() => ({
-          msg: "Failed to process behavioral data",
-          err: error
-        }));
-      }
-    } else {
-      await this.db.updatePuzzleCaptchaRecord(challenge, {
-        puzzleEvents
-      });
-    }
-    if (clientMetaData?.hp) {
-      await this.db.updatePuzzleCaptchaRecord(challenge, {
-        clientMetaData: { hp: clientMetaData.hp }
-      });
-    }
-    await this.db.updatePuzzleCaptchaRecordResult(
-      challenge,
-      result,
-      false,
-      true,
-      userTimestampSignature,
-      coords
-    );
-    if (challengeRecord.sessionId) {
-      const linkedSessionId = challengeRecord.sessionId;
-      await this.updateSessionRecordWithCache(linkedSessionId, {
-        userSubmitted: true,
-        result
-      });
-      if (simdReadings) {
-        await this.decryptAndAttachSimdReadingsIfAbsent(
-          linkedSessionId,
-          simdReadings,
-          types.SimdReadingsStage.submit
-        );
-      }
-    }
-    return correct;
-  }
-  /**
-   * @description Verifies a Puzzle Captcha for a given user and dapp. This is called by the server to verify the user's solution
-   * and update the record in the database to show that the user has solved the captcha
-   *
-   * @param {string} dappAccount - the dapp that is requesting the captcha
-   * @param {string} challenge - the challenge string
-   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the captcha
-   * @param env - provider environment
-   * @param ip - optional IP address for validation
-   * @param userAccessRulesStorage - storage for querying user access policies
-   * @param email
-   * @param spamEmailDomainCheckingEnabled
-   * @param trafficFilter
-   * @param storeMetadata - when true, persists the dapp-server-provided
-   *   `email` on the captcha record for spam-rate analysis.
-   */
-  async serverVerifyPuzzleCaptchaSolution(dappAccount, challenge, timeout, env, ip, userAccessRulesStorage, email, spamEmailDomainCheckingEnabled = false, trafficFilter, storeMetadata = false) {
-    const notVerifiedResponse = { verified: false };
-    const logger = this.logger.with({ challenge, dappAccount });
-    const challengeRecord = await this.db.getPuzzleCaptchaRecordByChallenge(challenge);
-    if (!challengeRecord) {
-      logger.debug(() => ({
-        msg: `No record of this challenge: ${challenge}`
-      }));
-      return notVerifiedResponse;
-    }
-    if (challengeRecord.result.status !== types.CaptchaStatus.approved) {
-      throw new common.ProsopoApiError("CAPTCHA.INVALID_SOLUTION", {
-        context: {
-          failedFuncName: this.serverVerifyPuzzleCaptchaSolution.name,
-          challenge
-        }
-      });
-    }
-    if (challengeRecord.serverChecked) return notVerifiedResponse;
-    const challengeDappAccount = challengeRecord.dappAccount;
-    if (dappAccount !== challengeDappAccount) {
-      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-        context: {
-          failedFuncName: this.serverVerifyPuzzleCaptchaSolution.name,
-          dappAccount,
-          challengeDappAccount
-        }
-      });
-    }
-    await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-      serverChecked: true,
-      lastUpdatedTimestamp: /* @__PURE__ */ new Date()
-    });
-    const submittedAt = challengeRecord.submittedAtTimestamp;
-    const submitToVerifyMs = submittedAt instanceof Date ? Date.now() - submittedAt.getTime() : Number.POSITIVE_INFINITY;
-    if (submitToVerifyMs > timeout) {
-      const disapprovedResult = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.TIMESTAMP_TOO_OLD
-      };
-      await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-        result: disapprovedResult
-      });
-      if (challengeRecord.sessionId) {
-        await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-          serverChecked: true,
-          result: disapprovedResult
-        });
-      }
-      return notVerifiedResponse;
-    }
-    if (userAccessRulesStorage) {
-      try {
-        const blockPolicy = await this.checkForHardBlock(
-          userAccessRulesStorage,
-          challengeRecord,
-          challengeRecord.userAccount,
-          challengeRecord.headers,
-          challengeRecord.coords,
-          challengeRecord.ipInfo?.isValid ? challengeRecord.ipInfo.countryCode : void 0,
-          challengeRecord.ipInfo?.isValid ? challengeRecord.ipInfo.asnNumber : void 0
-        );
-        if (blockPolicy) {
-          logger.info(() => ({
-            msg: "User blocked by access policy in server puzzle verification",
-            data: {
-              userAccount: challengeRecord.userAccount,
-              policy: blockPolicy
-            }
-          }));
-          const blockedResult = {
-            status: types.CaptchaStatus.disapproved,
-            reason: types.ResultReason.ACCESS_POLICY_BLOCK
-          };
-          await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-            result: blockedResult
-          });
-          if (challengeRecord.sessionId) {
-            await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-              serverChecked: true,
-              result: blockedResult
-            });
-          }
-          return notVerifiedResponse;
-        }
-      } catch (error) {
-        logger.warn(() => ({
-          msg: "Failed to check user access policies in server puzzle verification",
-          error
-        }));
-      }
-    }
-    if (email && spamEmailDomainCheckingEnabled) {
-      try {
-        const isSpam = await this.checkSpamEmail(email);
-        if (isSpam) {
-          const emailDomain = email.split("@")[1] || "unknown";
-          logger.info(() => ({
-            msg: "Spam email domain detected in server puzzle verification",
-            data: { emailDomain }
-          }));
-          await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-            result: {
-              status: types.CaptchaStatus.disapproved,
-              reason: types.ResultReason.SPAM_EMAIL_DOMAIN
-            }
-          });
-          return notVerifiedResponse;
-        }
-      } catch (error) {
-        logger.warn(() => ({
-          msg: "Failed to check spam email domain in server puzzle verification",
-          error
-        }));
-      }
-    }
-    const sessionRecord = challengeRecord.sessionId ? await this.db.getSessionRecordBySessionId(challengeRecord.sessionId) : void 0;
-    const enrichedDnsEvent = await enrichDnsEvent.enrichDnsEvent(
-      sessionRecord?.dnsEvent,
-      env.ipInfoService,
-      ip ?? challengeRecord.ipInfo?.ip
-    );
-    {
-      const check = await this.resolveTrafficFilterCheck(
-        env,
-        challengeRecord.ipInfo,
-        trafficFilter,
-        ip,
-        enrichedDnsEvent
-      );
-      if (check.isBlocked) {
-        logger.info(() => ({
-          msg: "Traffic filter rejected request in puzzle verification",
-          data: {
-            ip,
-            reason: check.reason,
-            dnsPeerIp: enrichedDnsEvent?.peerIp,
-            dnsResolverIp: enrichedDnsEvent?.resolverIp,
-            dnsPeerAsn: enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.peerIpInfo),
-            dnsResolverAsn: enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.resolverIpInfo),
-            dnsPathValid: enrichedDnsEvent?.pathValid
-          }
-        }));
-        const blockedResult = {
-          status: types.CaptchaStatus.disapproved,
-          reason: check.reason
-        };
-        await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-          result: blockedResult
-        });
-        if (challengeRecord.sessionId) {
-          await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-            serverChecked: true,
-            result: blockedResult
-          });
-        }
-        return notVerifiedResponse;
-      }
-    }
-    if (storeMetadata && email) {
-      await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-        metadata: { email }
-      });
-    }
-    if (ip) {
-      const challengeIpAddress = compositeIpAddress.getIpAddressFromComposite(
-        challengeRecord.ipAddress
-      );
-      const clientRecord = await this.db.getClientRecord(dappAccount);
-      const ipValidationRules = clientRecord?.settings?.ipValidationRules;
-      await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-        providedIp: compositeIpAddress.getCompositeIpAddress(ip)
-      });
-      if (ipValidationRules?.enabled === true) {
-        const ipValidation = await util$2.deepValidateIpAddress(
-          ip,
-          challengeIpAddress,
-          logger,
-          env.ipInfoService,
-          ipValidationRules,
-          enrichedDnsEvent?.peerIp
-        );
-        if (!ipValidation.isValid) {
-          logger.error(() => ({
-            msg: "IP validation failed for puzzle captcha",
-            data: {
-              ip,
-              challengeIp: challengeIpAddress.address,
-              error: ipValidation.errorMessage,
-              distanceKm: ipValidation.distanceKm
-            }
-          }));
-          const ipFailResult = {
-            status: types.CaptchaStatus.disapproved,
-            reason: types.ResultReason.FAILED_IP_VALIDATION
-          };
-          await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-            result: ipFailResult
-          });
-          if (challengeRecord.sessionId) {
-            await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-              serverChecked: true,
-              result: ipFailResult
-            });
-          }
-          return notVerifiedResponse;
-        }
-      }
-    }
-    let score;
-    if (sessionRecord) {
-      const dnsAsymmetry = enrichDnsEvent.computeDnsAsymmetry(
-        enrichedDnsEvent,
-        challengeRecord.ipInfo,
-        trafficFilter
-      );
-      if (dnsAsymmetry > 0) {
-        sessionRecord.scoreComponents = {
-          ...sessionRecord.scoreComponents,
-          dnsAsymmetry
-        };
-      }
-      score = frictionlessTasksUtils.computeFrictionlessScore(sessionRecord?.scoreComponents);
-      logger.info(() => ({
-        data: {
-          scoreComponents: { ...sessionRecord?.scoreComponents || {} },
-          score,
-          dnsPeerAsn: enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.peerIpInfo),
-          dnsResolverAsn: enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.resolverIpInfo)
-        }
-      }));
-    }
-    try {
-      const decisionInput = {
-        userAccount: challengeRecord.userAccount,
-        dappAccount: challengeRecord.dappAccount,
-        captchaResult: "passed",
-        headers: challengeRecord.headers,
-        captchaType: types.CaptchaType.puzzle,
-        behavioralDataPacked: challengeRecord.behavioralDataPacked,
-        deviceCapability: challengeRecord.deviceCapability,
-        countryCode: challengeRecord.ipInfo?.isValid ? challengeRecord.ipInfo.countryCode : void 0,
-        ipInfo: challengeRecord.ipInfo,
-        dnsEvent: enrichedDnsEvent,
-        score,
-        threshold: sessionRecord?.threshold,
-        scoreComponents: sessionRecord?.scoreComponents,
-        decryptedHeadHash: sessionRecord?.decryptedHeadHash,
-        userSitekeyIpHash: sessionRecord?.userSitekeyIpHash,
-        simdReadings: sessionRecord?.simdReadings,
-        frictionlessReason: sessionRecord?.reason,
-        ruleType: sessionRecord?.ruleType,
-        webView: sessionRecord?.webView,
-        iFrame: sessionRecord?.iFrame,
-        coords: challengeRecord.coords,
-        puzzleEvents: challengeRecord.puzzleEvents
-      };
-      const decision = await this.decisionMachineRunner.decide(
-        decisionInput,
-        logger
-      );
-      if (decision.decision === types.DecisionMachineDecision.Deny) {
-        logger.info(() => ({
-          msg: "Decision machine denied puzzle captcha in server verification",
-          data: {
-            userAccount: challengeRecord.userAccount,
-            reason: decision.reason,
-            score: decision.score,
-            tags: decision.tags
-          }
-        }));
-        const dmResult = {
-          status: types.CaptchaStatus.disapproved,
-          reason: decision.reason || types.ResultReason.CAPTCHA_DECISION_MACHINE_DENIED
-        };
-        await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
-          result: dmResult
-        });
-        if (challengeRecord.sessionId) {
-          await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-            serverChecked: true,
-            result: dmResult
-          });
-        }
-        return notVerifiedResponse;
-      }
-      logger.debug(() => ({
-        msg: "Decision machine allowed puzzle captcha",
-        data: {
-          reason: decision.reason,
-          score: decision.score,
-          tags: decision.tags
-        }
-      }));
-    } catch (error) {
-      logger.error(() => ({
-        msg: "Failed to run decision machine in server puzzle verification",
-        err: error
-      }));
-    }
-    if (challengeRecord.sessionId) {
-      await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-        serverChecked: true,
-        result: { status: types.CaptchaStatus.approved }
-      });
-    }
-    return { verified: true, ...score ? { score } : {} };
-  }
-}
+const require_usageCounters = require("../../util/usageCounters.cjs");
+const require_decisionMachineRunner = require("../decisionMachine/decisionMachineRunner.cjs");
+const require_compositeIpAddress = require("../../compositeIpAddress.cjs");
+const require_enrichDnsEvent = require("../dnsEvent/enrichDnsEvent.cjs");
+const require_captchaManager = require("../captchaManager.cjs");
+const require_util = require("../../util.cjs");
+const require_frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.cjs");
+const require_powTasksUtils = require("../powCaptcha/powTasksUtils.cjs");
+const require_puzzleTasksUtils = require("./puzzleTasksUtils.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_util = require("@prosopo/util");
+let _polkadot_util = require("@polkadot/util");
+//#region src/tasks/puzzleCaptcha/puzzleTasks.ts
+var PuzzleCaptchaManager = class extends require_captchaManager.CaptchaManager {
+	constructor(db, pair, config, logger, usageCounters) {
+		super(db, pair, config, logger);
+		this.POW_SEPARATOR = _prosopo_types.POW_SEPARATOR;
+		this.decisionMachineRunner = new require_decisionMachineRunner.DecisionMachineRunner(db);
+		this.usageCounters = usageCounters ?? null;
+	}
+	/**
+	* @description Generates a Puzzle Captcha challenge for a given user and dapp
+	*
+	* @param {string} userAccount - user that is solving the captcha
+	* @param {string} dappAccount - dapp that is requesting the captcha
+	* @param origin - not currently used
+	* @param tolerance
+	*/
+	async getPuzzleCaptchaChallenge(userAccount, dappAccount, origin, tolerance) {
+		const resolvedTolerance = tolerance ?? _prosopo_types.puzzleToleranceDefault;
+		const requestedAtTimestamp = Date.now();
+		const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}___${Math.floor(Math.random() * 1e6)}`;
+		const challengeSignature = (0, _polkadot_util.u8aToHex)(this.pair.sign((0, _polkadot_util.stringToHex)(challenge)));
+		return {
+			challenge,
+			targetX: Math.floor(Math.random() * 131) + 150,
+			targetY: Math.floor(Math.random() * 141) + 30,
+			originX: Math.floor(Math.random() * 111) + 20,
+			originY: Math.floor(Math.random() * 141) + 30,
+			tolerance: resolvedTolerance,
+			providerSignature: challengeSignature,
+			requestedAtTimestamp
+		};
+	}
+	/**
+	* @description Verifies a Puzzle Captcha solution for a given user and dapp
+	*
+	* @param {string} challenge - the challenge string
+	* @param {string} providerChallengeSignature - proof that the Provider provided the challenge
+	* @param {number} finalX - the final X coordinate of the puzzle
+	* @param {number} finalY - the final Y coordinate of the puzzle
+	* @param {PuzzleEvent[]} puzzleEvents - the puzzle event trail
+	* @param {number} timeout - the time in milliseconds since the Provider was selected to provide the captcha
+	* @param {string} userTimestampSignature
+	* @param ipAddress
+	* @param headers
+	* @param behavioralData
+	*/
+	async verifyPuzzleCaptchaSolution(challenge, providerChallengeSignature, finalX, finalY, puzzleEvents, timeout, userTimestampSignature, ipAddress, headers, behavioralData, salt, simdReadings, clientMetaData) {
+		require_powTasksUtils.checkPowSignature(challenge, providerChallengeSignature, this.pair.address, _prosopo_types.ApiParams.challenge);
+		const challengeSplit = challenge.split(this.POW_SEPARATOR);
+		const timestamp = Number.parseInt((0, _prosopo_util.at)(challengeSplit, 0));
+		const userAccount = (0, _prosopo_util.at)(challengeSplit, 1);
+		require_powTasksUtils.checkPowSignature(timestamp.toString(), userTimestampSignature, userAccount, _prosopo_types.ApiParams.timestamp);
+		const challengeRecord = await this.db.getPuzzleCaptchaRecordByChallenge(challenge);
+		if (!challengeRecord) {
+			this.logger.debug(() => ({ msg: `No record of this challenge: ${challenge}` }));
+			return false;
+		}
+		let coords;
+		let saltDecodeError;
+		if (salt) try {
+			const extractedData = (0, _prosopo_util.extractData)(salt);
+			if (extractedData.length >= 2) {
+				const built = [[[extractedData[0], extractedData[1]]]];
+				(0, _prosopo_util.assertCoordsSafe)(built, "coords");
+				coords = built;
+			}
+		} catch (error) {
+			saltDecodeError = error;
+			this.logger.warn(() => ({
+				msg: "Failed to extract coordinates from salt",
+				error,
+				salt
+			}));
+		}
+		if (challengeRecord.userSubmitted) {
+			this.logger.debug(() => ({ msg: `Challenge already submitted: ${challenge}` }));
+			return false;
+		}
+		if (saltDecodeError) {
+			const badSaltResult = {
+				status: _prosopo_types.CaptchaStatus.disapproved,
+				reason: _prosopo_types.ResultReason.CAPTCHA_INVALID_SALT
+			};
+			await this.db.updatePuzzleCaptchaRecordResult(challenge, badSaltResult, false, true, userTimestampSignature, void 0);
+			if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+				userSubmitted: true,
+				result: badSaltResult
+			});
+			return false;
+		}
+		if (!(0, _prosopo_util.verifyRecency)(challenge, timeout)) {
+			const timeoutResult = {
+				status: _prosopo_types.CaptchaStatus.disapproved,
+				reason: _prosopo_types.ResultReason.CAPTCHA_INVALID_TIMESTAMP
+			};
+			await this.db.updatePuzzleCaptchaRecordResult(challenge, timeoutResult, false, true, userTimestampSignature, coords);
+			if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+				userSubmitted: true,
+				result: timeoutResult
+			});
+			return false;
+		}
+		const correct = require_puzzleTasksUtils.validatePuzzleSolution(finalX, finalY, challengeRecord.targetX, challengeRecord.targetY, challengeRecord.tolerance);
+		let result = { status: _prosopo_types.CaptchaStatus.approved };
+		if (!correct) result = {
+			status: _prosopo_types.CaptchaStatus.disapproved,
+			reason: _prosopo_types.ResultReason.CAPTCHA_INVALID_SOLUTION
+		};
+		if (correct && this.usageCounters) {
+			const dappAccount = (0, _prosopo_util.at)(challengeSplit, 2);
+			this.usageCounters.incrManyAsync(dappAccount, require_usageCounters.buildAllWindowIncrements("solved", _prosopo_types.CaptchaType.puzzle, ipAddress.address, userAccount));
+		}
+		if (behavioralData) try {
+			const decryptKeys = [...await this.getDetectorKeys(), process.env.BOT_DECRYPTION_KEY];
+			const decryptedData = await this.decryptBehavioralData(behavioralData, decryptKeys);
+			if (decryptedData) {
+				const dappAccount = (0, _prosopo_util.at)(challengeSplit, 2);
+				this.logger?.info(() => ({
+					msg: "Behavioral analysis completed",
+					data: {
+						userAccount,
+						dappAccount,
+						challenge,
+						mouseEventsCount: decryptedData.collector1?.length || 0,
+						touchEventsCount: decryptedData.collector2?.length || 0,
+						clickEventsCount: decryptedData.collector3?.length || 0,
+						deviceCapability: decryptedData.deviceCapability,
+						captchaResult: correct ? "passed" : "failed"
+					}
+				}));
+				const packedData = {
+					c1: decryptedData.collector1 || [],
+					c2: decryptedData.collector2 || [],
+					c3: decryptedData.collector3 || [],
+					d: decryptedData.deviceCapability
+				};
+				await this.db.updatePuzzleCaptchaRecord(challenge, {
+					behavioralDataPacked: packedData,
+					deviceCapability: decryptedData.deviceCapability,
+					puzzleEvents
+				});
+			}
+		} catch (error) {
+			this.logger?.error(() => ({
+				msg: "Failed to process behavioral data",
+				err: error
+			}));
+		}
+		else await this.db.updatePuzzleCaptchaRecord(challenge, { puzzleEvents });
+		if (clientMetaData?.hp) await this.db.updatePuzzleCaptchaRecord(challenge, { clientMetaData: { hp: clientMetaData.hp } });
+		await this.db.updatePuzzleCaptchaRecordResult(challenge, result, false, true, userTimestampSignature, coords);
+		if (challengeRecord.sessionId) {
+			const linkedSessionId = challengeRecord.sessionId;
+			await this.updateSessionRecordWithCache(linkedSessionId, {
+				userSubmitted: true,
+				result
+			});
+			if (simdReadings) await this.decryptAndAttachSimdReadingsIfAbsent(linkedSessionId, simdReadings, _prosopo_types.SimdReadingsStage.submit);
+		}
+		return correct;
+	}
+	/**
+	* @description Verifies a Puzzle Captcha for a given user and dapp. This is called by the server to verify the user's solution
+	* and update the record in the database to show that the user has solved the captcha
+	*
+	* @param {string} dappAccount - the dapp that is requesting the captcha
+	* @param {string} challenge - the challenge string
+	* @param {number} timeout - the time in milliseconds since the Provider was selected to provide the captcha
+	* @param env - provider environment
+	* @param ip - optional IP address for validation
+	* @param userAccessRulesStorage - storage for querying user access policies
+	* @param email
+	* @param spamEmailDomainCheckingEnabled
+	* @param trafficFilter
+	* @param storeMetadata - when true, persists the dapp-server-provided
+	*   `email` on the captcha record for spam-rate analysis.
+	*/
+	async serverVerifyPuzzleCaptchaSolution(dappAccount, challenge, timeout, env, ip, userAccessRulesStorage, email, spamEmailDomainCheckingEnabled = false, trafficFilter, storeMetadata = false) {
+		const notVerifiedResponse = { verified: false };
+		const logger = this.logger.with({
+			challenge,
+			dappAccount
+		});
+		const challengeRecord = await this.db.getPuzzleCaptchaRecordByChallenge(challenge);
+		if (!challengeRecord) {
+			logger.debug(() => ({ msg: `No record of this challenge: ${challenge}` }));
+			return notVerifiedResponse;
+		}
+		if (challengeRecord.result.status !== _prosopo_types.CaptchaStatus.approved) throw new _prosopo_common.ProsopoApiError("CAPTCHA.INVALID_SOLUTION", { context: {
+			code: 400,
+			failedFuncName: this.serverVerifyPuzzleCaptchaSolution.name,
+			challenge
+		} });
+		if (challengeRecord.serverChecked) return notVerifiedResponse;
+		const challengeDappAccount = challengeRecord.dappAccount;
+		if (dappAccount !== challengeDappAccount) throw new _prosopo_common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", { context: {
+			failedFuncName: this.serverVerifyPuzzleCaptchaSolution.name,
+			dappAccount,
+			challengeDappAccount
+		} });
+		await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, {
+			serverChecked: true,
+			lastUpdatedTimestamp: /* @__PURE__ */ new Date()
+		});
+		const submittedAt = challengeRecord.submittedAtTimestamp;
+		if ((submittedAt instanceof Date ? Date.now() - submittedAt.getTime() : Number.POSITIVE_INFINITY) > timeout) {
+			const disapprovedResult = {
+				status: _prosopo_types.CaptchaStatus.disapproved,
+				reason: _prosopo_types.ResultReason.TIMESTAMP_TOO_OLD
+			};
+			await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { result: disapprovedResult });
+			if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+				serverChecked: true,
+				result: disapprovedResult
+			});
+			return notVerifiedResponse;
+		}
+		if (userAccessRulesStorage) try {
+			const blockPolicy = await this.checkForHardBlock(userAccessRulesStorage, challengeRecord, challengeRecord.userAccount, challengeRecord.headers, challengeRecord.coords, challengeRecord.ipInfo?.isValid ? challengeRecord.ipInfo.countryCode : void 0, challengeRecord.ipInfo?.isValid ? challengeRecord.ipInfo.asnNumber : void 0);
+			if (blockPolicy) {
+				logger.info(() => ({
+					msg: "User blocked by access policy in server puzzle verification",
+					data: {
+						userAccount: challengeRecord.userAccount,
+						policy: blockPolicy
+					}
+				}));
+				const blockedResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: _prosopo_types.ResultReason.ACCESS_POLICY_BLOCK
+				};
+				await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { result: blockedResult });
+				if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+					serverChecked: true,
+					result: blockedResult
+				});
+				return notVerifiedResponse;
+			}
+		} catch (error) {
+			logger.warn(() => ({
+				msg: "Failed to check user access policies in server puzzle verification",
+				error
+			}));
+		}
+		if (email && spamEmailDomainCheckingEnabled) try {
+			if (await this.checkSpamEmail(email)) {
+				const emailDomain = email.split("@")[1] || "unknown";
+				logger.info(() => ({
+					msg: "Spam email domain detected in server puzzle verification",
+					data: { emailDomain }
+				}));
+				await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { result: {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: _prosopo_types.ResultReason.SPAM_EMAIL_DOMAIN
+				} });
+				return notVerifiedResponse;
+			}
+		} catch (error) {
+			logger.warn(() => ({
+				msg: "Failed to check spam email domain in server puzzle verification",
+				error
+			}));
+		}
+		const sessionRecord = challengeRecord.sessionId ? await this.db.getSessionRecordBySessionId(challengeRecord.sessionId) : void 0;
+		const enrichedDnsEvent = await require_enrichDnsEvent.enrichDnsEvent(sessionRecord?.dnsEvent, env.ipInfoService, ip ?? challengeRecord.ipInfo?.ip);
+		{
+			const check = await this.resolveTrafficFilterCheck(env, challengeRecord.ipInfo, trafficFilter, ip, enrichedDnsEvent);
+			if (check.isBlocked) {
+				logger.info(() => ({
+					msg: "Traffic filter rejected request in puzzle verification",
+					data: {
+						ip,
+						reason: check.reason,
+						dnsPeerIp: enrichedDnsEvent?.peerIp,
+						dnsResolverIp: enrichedDnsEvent?.resolverIp,
+						dnsPeerAsn: require_enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.peerIpInfo),
+						dnsResolverAsn: require_enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.resolverIpInfo),
+						dnsPathValid: enrichedDnsEvent?.pathValid
+					}
+				}));
+				const blockedResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: check.reason
+				};
+				await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { result: blockedResult });
+				if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+					serverChecked: true,
+					result: blockedResult
+				});
+				return notVerifiedResponse;
+			}
+		}
+		if (storeMetadata && email) await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { metadata: { email } });
+		if (ip) {
+			const challengeIpAddress = require_compositeIpAddress.getIpAddressFromComposite(challengeRecord.ipAddress);
+			const ipValidationRules = (await this.db.getClientRecord(dappAccount))?.settings?.ipValidationRules;
+			await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { providedIp: require_compositeIpAddress.getCompositeIpAddress(ip) });
+			if (ipValidationRules?.enabled === true) {
+				const ipValidation = await require_util.deepValidateIpAddress(ip, challengeIpAddress, logger, env.ipInfoService, ipValidationRules, enrichedDnsEvent?.peerIp);
+				if (!ipValidation.isValid) {
+					logger.error(() => ({
+						msg: "IP validation failed for puzzle captcha",
+						data: {
+							ip,
+							challengeIp: challengeIpAddress.address,
+							error: ipValidation.errorMessage,
+							distanceKm: ipValidation.distanceKm
+						}
+					}));
+					const ipFailResult = {
+						status: _prosopo_types.CaptchaStatus.disapproved,
+						reason: _prosopo_types.ResultReason.FAILED_IP_VALIDATION
+					};
+					await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { result: ipFailResult });
+					if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+						serverChecked: true,
+						result: ipFailResult
+					});
+					return notVerifiedResponse;
+				}
+			}
+		}
+		let score;
+		if (sessionRecord) {
+			const dnsAsymmetry = require_enrichDnsEvent.computeDnsAsymmetry(enrichedDnsEvent, challengeRecord.ipInfo, trafficFilter);
+			if (dnsAsymmetry > 0) sessionRecord.scoreComponents = {
+				...sessionRecord.scoreComponents,
+				dnsAsymmetry
+			};
+			score = require_frictionlessTasksUtils.computeFrictionlessScore(sessionRecord?.scoreComponents);
+			logger.info(() => ({ data: {
+				scoreComponents: { ...sessionRecord?.scoreComponents || {} },
+				score,
+				dnsPeerAsn: require_enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.peerIpInfo),
+				dnsResolverAsn: require_enrichDnsEvent.getIpInfoAsn(enrichedDnsEvent?.resolverIpInfo)
+			} }));
+		}
+		try {
+			const decisionInput = {
+				userAccount: challengeRecord.userAccount,
+				dappAccount: challengeRecord.dappAccount,
+				captchaResult: "passed",
+				headers: challengeRecord.headers,
+				captchaType: _prosopo_types.CaptchaType.puzzle,
+				behavioralDataPacked: challengeRecord.behavioralDataPacked,
+				deviceCapability: challengeRecord.deviceCapability,
+				countryCode: challengeRecord.ipInfo?.isValid ? challengeRecord.ipInfo.countryCode : void 0,
+				ipInfo: challengeRecord.ipInfo,
+				dnsEvent: enrichedDnsEvent,
+				score,
+				threshold: sessionRecord?.threshold,
+				scoreComponents: sessionRecord?.scoreComponents,
+				decryptedHeadHash: sessionRecord?.decryptedHeadHash,
+				userSitekeyIpHash: sessionRecord?.userSitekeyIpHash,
+				simdReadings: sessionRecord?.simdReadings,
+				frictionlessReason: sessionRecord?.reason,
+				ruleType: sessionRecord?.ruleType,
+				webView: sessionRecord?.webView,
+				iFrame: sessionRecord?.iFrame,
+				coords: challengeRecord.coords,
+				puzzleEvents: challengeRecord.puzzleEvents
+			};
+			const decision = await this.decisionMachineRunner.decide(decisionInput, logger);
+			if (decision.decision === _prosopo_types.DecisionMachineDecision.Deny) {
+				logger.info(() => ({
+					msg: "Decision machine denied puzzle captcha in server verification",
+					data: {
+						userAccount: challengeRecord.userAccount,
+						reason: decision.reason,
+						score: decision.score,
+						tags: decision.tags
+					}
+				}));
+				const dmResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: decision.reason || _prosopo_types.ResultReason.CAPTCHA_DECISION_MACHINE_DENIED
+				};
+				await this.db.updatePuzzleCaptchaRecord(challengeRecord.challenge, { result: dmResult });
+				if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+					serverChecked: true,
+					result: dmResult
+				});
+				return notVerifiedResponse;
+			}
+			logger.debug(() => ({
+				msg: "Decision machine allowed puzzle captcha",
+				data: {
+					reason: decision.reason,
+					score: decision.score,
+					tags: decision.tags
+				}
+			}));
+		} catch (error) {
+			logger.error(() => ({
+				msg: "Failed to run decision machine in server puzzle verification",
+				err: error
+			}));
+		}
+		if (challengeRecord.sessionId) await this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+			serverChecked: true,
+			result: { status: _prosopo_types.CaptchaStatus.approved }
+		});
+		return {
+			verified: true,
+			...score ? { score } : {}
+		};
+	}
+};
+//#endregion
 exports.PuzzleCaptchaManager = PuzzleCaptchaManager;