@prosopo/provider 4.15.13 → 4.15.15

package/dist/cjs/tasks/powCaptcha/powTasks.cjs

@@ -1,688 +1,492 @@
-"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 routingMachine = require("../frictionless/routingMachine.cjs");
-const evaluateEmailSpamRules = require("../spam/evaluateEmailSpamRules.cjs");
-const powTasksUtils = require("./powTasksUtils.cjs");
-const DEFAULT_POW_DIFFICULTY = 4;
-class PowCaptchaManager extends captchaManager.CaptchaManager {
-  constructor(db, pair, config, logger, writeQueue, usageCounters2) {
-    super(db, pair, config, logger, writeQueue);
-    this.POW_SEPARATOR = types.POW_SEPARATOR;
-    this.decisionMachineRunner = new decisionMachineRunner.DecisionMachineRunner(db);
-    this.usageCounters = usageCounters2 ?? null;
-  }
-  /**
-   * Provide the request-side data needed to run the post-pow routing pass
-   * inside `verifyPowCaptchaSolution`. When unset, the routing pass is
-   * skipped and verification behaves exactly as before.
-   */
-  setPostPowContext(ctx) {
-    this.postPowContext = ctx;
-  }
-  /**
-   * @description Generates a PoW Captcha 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 powDifficulty
-   */
-  async getPowCaptchaChallenge(userAccount, dappAccount, origin, powDifficulty) {
-    const difficulty = powDifficulty || DEFAULT_POW_DIFFICULTY;
-    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)));
-    return {
-      challenge,
-      difficulty,
-      providerSignature: challengeSignature,
-      requestedAtTimestamp
-    };
-  }
-  /**
-   * @description Verifies a PoW Captcha for a given user and dapp
-   *
-   * @param {string} challenge - the starting string for the PoW challenge
-   * @param {string} providerChallengeSignature - proof that the Provider provided the challenge
-   * @param {string} nonce - the string that the user has found that satisfies the PoW challenge
-   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
-   * @param {string} userTimestampSignature
-   * @param ipAddress
-   * @param headers
-   * @param behavioralData
-   * @param salt
-   */
-  async verifyPowCaptchaSolution(challenge, providerChallengeSignature, nonce, 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.getPowCaptchaRecordByChallenge(challenge);
-    if (!challengeRecord) {
-      this.logger.debug(() => ({
-        msg: `No record of this challenge: ${challenge}`
-      }));
-      return { verified: false };
-    }
-    const difficulty = challengeRecord.difficulty;
-    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 (saltDecodeError) {
-      const badSaltResult = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.CAPTCHA_INVALID_SALT
-      };
-      const writePromises2 = [
-        this.db.updatePowCaptchaRecordResult(
-          challenge,
-          badSaltResult,
-          false,
-          // serverChecked
-          true,
-          // userSubmitted
-          userTimestampSignature,
-          void 0
-          // never persist the bad coords
-        )
-      ];
-      if (challengeRecord.sessionId) {
-        writePromises2.push(
-          this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-            userSubmitted: true,
-            result: badSaltResult
-          })
-        );
-      }
-      await Promise.all(writePromises2);
-      return { verified: false };
-    }
-    if (!util$1.verifyRecency(challenge, timeout)) {
-      const timeoutResult = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.CAPTCHA_INVALID_TIMESTAMP
-      };
-      const writePromises2 = [
-        this.db.updatePowCaptchaRecordResult(
-          challenge,
-          timeoutResult,
-          false,
-          //serverchecked
-          true,
-          // usersubmitted
-          userTimestampSignature,
-          coords
-        )
-      ];
-      if (challengeRecord.sessionId) {
-        writePromises2.push(
-          this.updateSessionRecordWithCache(challengeRecord.sessionId, {
-            userSubmitted: true,
-            result: timeoutResult
-          })
-        );
-      }
-      await Promise.all(writePromises2);
-      return { verified: false };
-    }
-    const correct = powTasksUtils.validateSolution(nonce, challenge, difficulty);
-    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.pow,
-          ipAddress.address,
-          userAccount
-        )
-      );
-    }
-    let behavioralUpdates = {};
-    let decryptedBehavioralDataPacked;
-    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
-          };
-          behavioralUpdates = {
-            behavioralDataPacked: packedData,
-            deviceCapability: decryptedData.deviceCapability
-          };
-          decryptedBehavioralDataPacked = packedData;
-        }
-      } catch (error) {
-        this.logger?.error(() => ({
-          msg: "Failed to process behavioral data",
-          err: error
-        }));
-      }
-    }
-    const recordUpdates = { ...behavioralUpdates };
-    if (clientMetaData?.hp) {
-      recordUpdates.clientMetaData = { hp: clientMetaData.hp };
-    }
-    if (Object.keys(recordUpdates).length > 0) {
-      await this.db.updatePowCaptchaRecord(challenge, recordUpdates);
-    }
-    const writePromises = [
-      this.db.updatePowCaptchaRecordResult(
-        challenge,
-        result,
-        false,
-        true,
-        userTimestampSignature,
-        coords
-      )
-    ];
-    if (challengeRecord.sessionId) {
-      const linkedSessionId = challengeRecord.sessionId;
-      writePromises.push(
-        this.updateSessionRecordWithCache(linkedSessionId, {
-          userSubmitted: true,
-          result
-        })
-      );
-      if (simdReadings) {
-        writePromises.push(
-          this.decryptAndAttachSimdReadingsIfAbsent(
-            linkedSessionId,
-            simdReadings,
-            types.SimdReadingsStage.submit
-          )
-        );
-      }
-    }
-    await Promise.all(writePromises);
-    if (!correct) {
-      return { verified: correct };
-    }
-    const escalateForMissingCoords = !coords && Boolean(challengeRecord.sessionId);
-    let routingOutput = this.postPowContext ? await this.runPostPowRouting({
-      challengeRecord,
-      challengeSplit,
-      behavioralDataPacked: decryptedBehavioralDataPacked
-    }) : void 0;
-    if (escalateForMissingCoords && routingOutput?.captchaType !== types.CaptchaType.image && routingOutput?.captchaType !== types.CaptchaType.puzzle) {
-      routingOutput = {
-        captchaType: types.CaptchaType.image,
-        reason: types.FrictionlessReason.MISSING_COORDINATES
-      };
-    }
-    return { verified: correct, routingOutput };
-  }
-  /**
-   * Resolve the originating session, build a full RoutingContext, and run the
-   * post-pow phase of the routing machine. Returns the machine's output, or
-   * undefined when prerequisites are missing (no session, no score) — in
-   * which case the caller treats the result as "no escalation".
-   */
-  async runPostPowRouting(args) {
-    if (!this.postPowContext) return void 0;
-    const { challengeRecord, challengeSplit, behavioralDataPacked } = args;
-    if (!challengeRecord.sessionId) {
-      this.logger.debug(() => ({
-        msg: "Skipping post-pow routing: PoW record has no linked session"
-      }));
-      return void 0;
-    }
-    const sessionRecord = await this.db.getSessionRecordBySessionId(
-      challengeRecord.sessionId
-    );
-    if (!sessionRecord) {
-      this.logger.debug(() => ({
-        msg: "Skipping post-pow routing: session record not found",
-        data: { sessionId: challengeRecord.sessionId }
-      }));
-      return void 0;
-    }
-    const score = frictionlessTasksUtils.computeFrictionlessScore(sessionRecord.scoreComponents);
-    const dappAccount = util$1.at(challengeSplit, 2);
-    const userAccount = util$1.at(challengeSplit, 1);
-    const platform = {
-      ...this.postPowContext.platform,
-      isWebView: sessionRecord.webView
-    };
-    const ctx = {
-      dappAccount,
-      userAccount,
-      ip: this.postPowContext.ip,
-      countryCode: this.postPowContext.countryCode,
-      score,
-      platform,
-      raw: {
-        ...this.postPowContext.raw,
-        ...behavioralDataPacked && { behavioralDataPacked },
-        // SIMD readings are decrypted and attached to the session above
-        // (decryptAndAttachSimdReadingsIfAbsent) before this re-fetch, so
-        // they are available here in decoded form for the routing machine.
-        ...sessionRecord.simdReadings && { simd: sessionRecord.simdReadings },
-        // currentUrl / iframeUrl were captured at frictionless time
-        // from the widget's payload — the submit request has no
-        // equivalent signal (its Referer is the captcha iframe, not
-        // the host page) so we surface them from the persisted
-        // session. iframeUrl is only present when the widget was
-        // embedded at frictionless time.
-        ...sessionRecord.currentUrl && {
-          currentUrl: sessionRecord.currentUrl
-        },
-        ...sessionRecord.iframeUrl && {
-          iframeUrl: sessionRecord.iframeUrl
-        }
-      }
-    };
-    const baseline = {
-      captchaType: types.CaptchaType.pow,
-      powDifficulty: challengeRecord.difficulty
-    };
-    return routingMachine.applyRouter(
-      this.decisionMachineRunner,
-      this.usageCounters,
-      baseline,
-      ctx,
-      this.logger,
-      "postPow"
-    );
-  }
-  /**
-   * @description Verifies a PoW 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 starting string for the PoW challenge
-   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW 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 spamFilter
-   * @param trafficFilter
-   * @param storeMetadata - when true, persists the dapp-server-provided
-   *   `email` (and any future metadata fields) on the captcha record so
-   *   it can be inspected for spam-rate analysis.
-   */
-  async serverVerifyPowCaptchaSolution(dappAccount, challenge, timeout, env, ip, userAccessRulesStorage, email, spamEmailDomainCheckingEnabled = false, spamFilter, trafficFilter, storeMetadata = false) {
-    const notVerified = (reason) => ({
-      verified: false,
-      reason
-    });
-    const logger = this.logger.with({ challenge, dappAccount });
-    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
-    if (!challengeRecord) {
-      logger.debug(() => ({
-        msg: `No record of this challenge: ${challenge}`
-      }));
-      return notVerified("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND");
-    }
-    if (challengeRecord.result.status !== types.CaptchaStatus.approved) {
-      throw new common.ProsopoApiError("CAPTCHA.INVALID_SOLUTION", {
-        context: {
-          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-          challenge
-        }
-      });
-    }
-    if (challengeRecord.serverChecked)
-      return notVerified("API.USER_ALREADY_VERIFIED");
-    const challengeDappAccount = challengeRecord.dappAccount;
-    if (dappAccount !== challengeDappAccount) {
-      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-        context: {
-          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-          dappAccount,
-          challengeDappAccount
-        }
-      });
-    }
-    await this.db.markDappUserPoWCommitmentsChecked([
-      challengeRecord.challenge
-    ]);
-    const powRecordUpdates = {};
-    let failResult;
-    let failReason;
-    const submittedAt = challengeRecord.submittedAtTimestamp;
-    const submitToVerifyMs = submittedAt instanceof Date ? Date.now() - submittedAt.getTime() : Number.POSITIVE_INFINITY;
-    if (submitToVerifyMs > timeout) {
-      failResult = {
-        status: types.CaptchaStatus.disapproved,
-        reason: types.ResultReason.TIMESTAMP_TOO_OLD
-      };
-      failReason = "API.TIMESTAMP_TOO_OLD";
-    }
-    if (!failResult && 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 PoW verification",
-            data: {
-              userAccount: challengeRecord.userAccount,
-              policy: blockPolicy
-            }
-          }));
-          failResult = {
-            status: types.CaptchaStatus.disapproved,
-            reason: types.ResultReason.ACCESS_POLICY_BLOCK
-          };
-          failReason = "API.ACCESS_POLICY_BLOCK";
-        }
-      } catch (error) {
-        logger.warn(() => ({
-          msg: "Failed to check user access policies in server PoW verification",
-          error
-        }));
-      }
-    }
-    if (!failResult && 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 PoW verification",
-            data: { emailDomain }
-          }));
-          failResult = {
-            status: types.CaptchaStatus.disapproved,
-            reason: types.ResultReason.SPAM_EMAIL_DOMAIN
-          };
-          failReason = "API.SPAM_EMAIL_DOMAIN";
-        }
-      } catch (error) {
-        logger.warn(() => ({
-          msg: "Failed to check spam email domain in server PoW verification",
-          error
-        }));
-      }
-    }
-    if (!failResult && spamFilter?.enabled && spamFilter.emailRules?.enabled && email) {
-      const result = evaluateEmailSpamRules.evaluateEmailSpamRules(email, spamFilter.emailRules);
-      if (result.isSpam) {
-        logger.info(() => ({
-          msg: "Spam filter rejected email in PoW verification",
-          data: { reason: result.reason }
-        }));
-        failResult = {
-          status: types.CaptchaStatus.disapproved,
-          reason: types.ResultReason.SPAM_EMAIL_RULE
-        };
-        failReason = "API.SPAM_EMAIL_RULE";
-      }
-    }
-    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
-    );
-    if (!failResult) {
-      const check = await this.resolveTrafficFilterCheck(
-        env,
-        challengeRecord.ipInfo,
-        trafficFilter,
-        ip,
-        enrichedDnsEvent
-      );
-      if (check.isBlocked) {
-        logger.info(() => ({
-          msg: "Traffic filter rejected request in PoW 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
-          }
-        }));
-        failResult = {
-          status: types.CaptchaStatus.disapproved,
-          reason: check.reason
-        };
-        failReason = check.reason;
-      }
-    }
-    if (storeMetadata && email) {
-      powRecordUpdates.metadata = { email };
-    }
-    if (!failResult && ip) {
-      const challengeIpAddress = compositeIpAddress.getIpAddressFromComposite(
-        challengeRecord.ipAddress
-      );
-      const clientRecord = await this.db.getClientRecord(dappAccount);
-      const ipValidationRules = clientRecord?.settings?.ipValidationRules;
-      powRecordUpdates.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 PoW captcha",
-            data: {
-              ip,
-              challengeIp: challengeIpAddress.address,
-              error: ipValidation.errorMessage,
-              distanceKm: ipValidation.distanceKm
-            }
-          }));
-          failResult = {
-            status: types.CaptchaStatus.disapproved,
-            reason: types.ResultReason.FAILED_IP_VALIDATION
-          };
-          failReason = "API.FAILED_IP_VALIDATION";
-        }
-      }
-    }
-    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)
-        }
-      }));
-    }
-    if (!failResult) {
-      try {
-        const decisionInput = {
-          userAccount: challengeRecord.userAccount,
-          dappAccount: challengeRecord.dappAccount,
-          captchaResult: "passed",
-          headers: challengeRecord.headers,
-          captchaType: types.CaptchaType.pow,
-          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
-        };
-        const decision = await this.decisionMachineRunner.decide(
-          decisionInput,
-          logger
-        );
-        if (decision.decision === types.DecisionMachineDecision.Deny) {
-          logger.info(() => ({
-            msg: "Decision machine denied PoW captcha in server verification",
-            data: {
-              userAccount: challengeRecord.userAccount,
-              reason: decision.reason,
-              score: decision.score,
-              tags: decision.tags
-            }
-          }));
-          const dmReason = decision.reason || types.ResultReason.CAPTCHA_DECISION_MACHINE_DENIED;
-          failResult = {
-            status: types.CaptchaStatus.disapproved,
-            reason: dmReason
-          };
-          failReason = dmReason;
-        } else {
-          logger.debug(() => ({
-            msg: "Decision machine allowed PoW captcha",
-            data: {
-              reason: decision.reason,
-              score: decision.score,
-              tags: decision.tags
-            }
-          }));
-        }
-      } catch (error) {
-        logger.error(() => ({
-          msg: "Failed to run decision machine in server PoW verification",
-          err: error
-        }));
-      }
-    }
-    const finalResult = failResult || {
-      status: types.CaptchaStatus.approved
-    };
-    if (failResult) {
-      powRecordUpdates.result = failResult;
-    }
-    const writePromises = [];
-    if (Object.keys(powRecordUpdates).length > 0) {
-      writePromises.push(
-        this.db.updatePowCaptchaRecord(
-          challengeRecord.challenge,
-          powRecordUpdates
-        )
-      );
-    }
-    if (challengeRecord.sessionId) {
-      writePromises.push(
-        this.updateSessionRecordWithCache(
-          challengeRecord.sessionId,
-          {
-            serverChecked: true,
-            result: finalResult
-          },
-          true
-        )
-      );
-    }
-    if (writePromises.length > 0) {
-      await Promise.all(writePromises);
-    }
-    if (failReason) {
-      return notVerified(failReason);
-    }
-    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_routingMachine = require("../frictionless/routingMachine.cjs");
+const require_util = require("../../util.cjs");
+const require_frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.cjs");
+const require_evaluateEmailSpamRules = require("../spam/evaluateEmailSpamRules.cjs");
+const require_powTasksUtils = require("./powTasksUtils.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/powCaptcha/powTasks.ts
+var DEFAULT_POW_DIFFICULTY = 4;
+var PowCaptchaManager = class extends require_captchaManager.CaptchaManager {
+	constructor(db, pair, config, logger, writeQueue, usageCounters) {
+		super(db, pair, config, logger, writeQueue);
+		this.POW_SEPARATOR = _prosopo_types.POW_SEPARATOR;
+		this.decisionMachineRunner = new require_decisionMachineRunner.DecisionMachineRunner(db);
+		this.usageCounters = usageCounters ?? null;
+	}
+	/**
+	* Provide the request-side data needed to run the post-pow routing pass
+	* inside `verifyPowCaptchaSolution`. When unset, the routing pass is
+	* skipped and verification behaves exactly as before.
+	*/
+	setPostPowContext(ctx) {
+		this.postPowContext = ctx;
+	}
+	/**
+	* @description Generates a PoW Captcha 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 powDifficulty
+	*/
+	async getPowCaptchaChallenge(userAccount, dappAccount, origin, powDifficulty) {
+		const difficulty = powDifficulty || DEFAULT_POW_DIFFICULTY;
+		const requestedAtTimestamp = Date.now();
+		const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}___${Math.floor(Math.random() * 1e6)}`;
+		return {
+			challenge,
+			difficulty,
+			providerSignature: (0, _polkadot_util.u8aToHex)(this.pair.sign((0, _polkadot_util.stringToHex)(challenge))),
+			requestedAtTimestamp
+		};
+	}
+	/**
+	* @description Verifies a PoW Captcha for a given user and dapp
+	*
+	* @param {string} challenge - the starting string for the PoW challenge
+	* @param {string} providerChallengeSignature - proof that the Provider provided the challenge
+	* @param {string} nonce - the string that the user has found that satisfies the PoW challenge
+	* @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
+	* @param {string} userTimestampSignature
+	* @param ipAddress
+	* @param headers
+	* @param behavioralData
+	* @param salt
+	*/
+	async verifyPowCaptchaSolution(challenge, providerChallengeSignature, nonce, 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.getPowCaptchaRecordByChallenge(challenge);
+		if (!challengeRecord) {
+			this.logger.debug(() => ({ msg: `No record of this challenge: ${challenge}` }));
+			return { verified: false };
+		}
+		const difficulty = challengeRecord.difficulty;
+		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 (saltDecodeError) {
+			const badSaltResult = {
+				status: _prosopo_types.CaptchaStatus.disapproved,
+				reason: _prosopo_types.ResultReason.CAPTCHA_INVALID_SALT
+			};
+			const writePromises = [this.db.updatePowCaptchaRecordResult(challenge, badSaltResult, false, true, userTimestampSignature, void 0)];
+			if (challengeRecord.sessionId) writePromises.push(this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+				userSubmitted: true,
+				result: badSaltResult
+			}));
+			await Promise.all(writePromises);
+			return { verified: false };
+		}
+		if (!(0, _prosopo_util.verifyRecency)(challenge, timeout)) {
+			const timeoutResult = {
+				status: _prosopo_types.CaptchaStatus.disapproved,
+				reason: _prosopo_types.ResultReason.CAPTCHA_INVALID_TIMESTAMP
+			};
+			const writePromises = [this.db.updatePowCaptchaRecordResult(challenge, timeoutResult, false, true, userTimestampSignature, coords)];
+			if (challengeRecord.sessionId) writePromises.push(this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+				userSubmitted: true,
+				result: timeoutResult
+			}));
+			await Promise.all(writePromises);
+			return { verified: false };
+		}
+		const correct = require_powTasksUtils.validateSolution(nonce, challenge, difficulty);
+		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.pow, ipAddress.address, userAccount));
+		}
+		let behavioralUpdates = {};
+		let decryptedBehavioralDataPacked;
+		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
+				};
+				behavioralUpdates = {
+					behavioralDataPacked: packedData,
+					deviceCapability: decryptedData.deviceCapability
+				};
+				decryptedBehavioralDataPacked = packedData;
+			}
+		} catch (error) {
+			this.logger?.error(() => ({
+				msg: "Failed to process behavioral data",
+				err: error
+			}));
+		}
+		const recordUpdates = { ...behavioralUpdates };
+		if (clientMetaData?.hp) recordUpdates.clientMetaData = { hp: clientMetaData.hp };
+		if (Object.keys(recordUpdates).length > 0) await this.db.updatePowCaptchaRecord(challenge, recordUpdates);
+		const writePromises = [this.db.updatePowCaptchaRecordResult(challenge, result, false, true, userTimestampSignature, coords)];
+		if (challengeRecord.sessionId) {
+			const linkedSessionId = challengeRecord.sessionId;
+			writePromises.push(this.updateSessionRecordWithCache(linkedSessionId, {
+				userSubmitted: true,
+				result
+			}));
+			if (simdReadings) writePromises.push(this.decryptAndAttachSimdReadingsIfAbsent(linkedSessionId, simdReadings, _prosopo_types.SimdReadingsStage.submit));
+		}
+		await Promise.all(writePromises);
+		if (!correct) return { verified: correct };
+		const escalateForMissingCoords = !coords && Boolean(challengeRecord.sessionId);
+		let routingOutput = this.postPowContext ? await this.runPostPowRouting({
+			challengeRecord,
+			challengeSplit,
+			behavioralDataPacked: decryptedBehavioralDataPacked
+		}) : void 0;
+		if (escalateForMissingCoords && routingOutput?.captchaType !== _prosopo_types.CaptchaType.image && routingOutput?.captchaType !== _prosopo_types.CaptchaType.puzzle) routingOutput = {
+			captchaType: _prosopo_types.CaptchaType.image,
+			reason: _prosopo_types.FrictionlessReason.MISSING_COORDINATES
+		};
+		return {
+			verified: correct,
+			routingOutput
+		};
+	}
+	/**
+	* Resolve the originating session, build a full RoutingContext, and run the
+	* post-pow phase of the routing machine. Returns the machine's output, or
+	* undefined when prerequisites are missing (no session, no score) — in
+	* which case the caller treats the result as "no escalation".
+	*/
+	async runPostPowRouting(args) {
+		if (!this.postPowContext) return void 0;
+		const { challengeRecord, challengeSplit, behavioralDataPacked } = args;
+		if (!challengeRecord.sessionId) {
+			this.logger.debug(() => ({ msg: "Skipping post-pow routing: PoW record has no linked session" }));
+			return;
+		}
+		const sessionRecord = await this.db.getSessionRecordBySessionId(challengeRecord.sessionId);
+		if (!sessionRecord) {
+			this.logger.debug(() => ({
+				msg: "Skipping post-pow routing: session record not found",
+				data: { sessionId: challengeRecord.sessionId }
+			}));
+			return;
+		}
+		const score = require_frictionlessTasksUtils.computeFrictionlessScore(sessionRecord.scoreComponents);
+		const dappAccount = (0, _prosopo_util.at)(challengeSplit, 2);
+		const userAccount = (0, _prosopo_util.at)(challengeSplit, 1);
+		const platform = {
+			...this.postPowContext.platform,
+			isWebView: sessionRecord.webView
+		};
+		const ctx = {
+			dappAccount,
+			userAccount,
+			ip: this.postPowContext.ip,
+			countryCode: this.postPowContext.countryCode,
+			score,
+			platform,
+			raw: {
+				...this.postPowContext.raw,
+				...behavioralDataPacked && { behavioralDataPacked },
+				...sessionRecord.simdReadings && { simd: sessionRecord.simdReadings },
+				...sessionRecord.currentUrl && { currentUrl: sessionRecord.currentUrl },
+				...sessionRecord.iframeUrl && { iframeUrl: sessionRecord.iframeUrl }
+			}
+		};
+		const baseline = {
+			captchaType: _prosopo_types.CaptchaType.pow,
+			powDifficulty: challengeRecord.difficulty
+		};
+		return require_routingMachine.applyRouter(this.decisionMachineRunner, this.usageCounters, baseline, ctx, this.logger, "postPow");
+	}
+	/**
+	* @description Verifies a PoW 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 starting string for the PoW challenge
+	* @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW 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 spamFilter
+	* @param trafficFilter
+	* @param storeMetadata - when true, persists the dapp-server-provided
+	*   `email` (and any future metadata fields) on the captcha record so
+	*   it can be inspected for spam-rate analysis.
+	*/
+	async serverVerifyPowCaptchaSolution(dappAccount, challenge, timeout, env, ip, userAccessRulesStorage, email, spamEmailDomainCheckingEnabled = false, spamFilter, trafficFilter, storeMetadata = false) {
+		const notVerified = (reason) => ({
+			verified: false,
+			reason
+		});
+		const logger = this.logger.with({
+			challenge,
+			dappAccount
+		});
+		const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
+		if (!challengeRecord) {
+			logger.debug(() => ({ msg: `No record of this challenge: ${challenge}` }));
+			return notVerified("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND");
+		}
+		if (challengeRecord.result.status !== _prosopo_types.CaptchaStatus.approved) throw new _prosopo_common.ProsopoApiError("CAPTCHA.INVALID_SOLUTION", { context: {
+			code: 400,
+			failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+			challenge
+		} });
+		if (challengeRecord.serverChecked) return notVerified("API.USER_ALREADY_VERIFIED");
+		const challengeDappAccount = challengeRecord.dappAccount;
+		if (dappAccount !== challengeDappAccount) throw new _prosopo_common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", { context: {
+			failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+			dappAccount,
+			challengeDappAccount
+		} });
+		await this.db.markDappUserPoWCommitmentsChecked([challengeRecord.challenge]);
+		const powRecordUpdates = {};
+		let failResult;
+		let failReason;
+		const submittedAt = challengeRecord.submittedAtTimestamp;
+		if ((submittedAt instanceof Date ? Date.now() - submittedAt.getTime() : Number.POSITIVE_INFINITY) > timeout) {
+			failResult = {
+				status: _prosopo_types.CaptchaStatus.disapproved,
+				reason: _prosopo_types.ResultReason.TIMESTAMP_TOO_OLD
+			};
+			failReason = "API.TIMESTAMP_TOO_OLD";
+		}
+		if (!failResult && 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 PoW verification",
+					data: {
+						userAccount: challengeRecord.userAccount,
+						policy: blockPolicy
+					}
+				}));
+				failResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: _prosopo_types.ResultReason.ACCESS_POLICY_BLOCK
+				};
+				failReason = "API.ACCESS_POLICY_BLOCK";
+			}
+		} catch (error) {
+			logger.warn(() => ({
+				msg: "Failed to check user access policies in server PoW verification",
+				error
+			}));
+		}
+		if (!failResult && email && spamEmailDomainCheckingEnabled) try {
+			if (await this.checkSpamEmail(email)) {
+				const emailDomain = email.split("@")[1] || "unknown";
+				logger.info(() => ({
+					msg: "Spam email domain detected in server PoW verification",
+					data: { emailDomain }
+				}));
+				failResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: _prosopo_types.ResultReason.SPAM_EMAIL_DOMAIN
+				};
+				failReason = "API.SPAM_EMAIL_DOMAIN";
+			}
+		} catch (error) {
+			logger.warn(() => ({
+				msg: "Failed to check spam email domain in server PoW verification",
+				error
+			}));
+		}
+		if (!failResult && spamFilter?.enabled && spamFilter.emailRules?.enabled && email) {
+			const result = require_evaluateEmailSpamRules.evaluateEmailSpamRules(email, spamFilter.emailRules);
+			if (result.isSpam) {
+				logger.info(() => ({
+					msg: "Spam filter rejected email in PoW verification",
+					data: { reason: result.reason }
+				}));
+				failResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: _prosopo_types.ResultReason.SPAM_EMAIL_RULE
+				};
+				failReason = "API.SPAM_EMAIL_RULE";
+			}
+		}
+		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);
+		if (!failResult) {
+			const check = await this.resolveTrafficFilterCheck(env, challengeRecord.ipInfo, trafficFilter, ip, enrichedDnsEvent);
+			if (check.isBlocked) {
+				logger.info(() => ({
+					msg: "Traffic filter rejected request in PoW 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
+					}
+				}));
+				failResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: check.reason
+				};
+				failReason = check.reason;
+			}
+		}
+		if (storeMetadata && email) powRecordUpdates.metadata = { email };
+		if (!failResult && ip) {
+			const challengeIpAddress = require_compositeIpAddress.getIpAddressFromComposite(challengeRecord.ipAddress);
+			const ipValidationRules = (await this.db.getClientRecord(dappAccount))?.settings?.ipValidationRules;
+			powRecordUpdates.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 PoW captcha",
+						data: {
+							ip,
+							challengeIp: challengeIpAddress.address,
+							error: ipValidation.errorMessage,
+							distanceKm: ipValidation.distanceKm
+						}
+					}));
+					failResult = {
+						status: _prosopo_types.CaptchaStatus.disapproved,
+						reason: _prosopo_types.ResultReason.FAILED_IP_VALIDATION
+					};
+					failReason = "API.FAILED_IP_VALIDATION";
+				}
+			}
+		}
+		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)
+			} }));
+		}
+		if (!failResult) try {
+			const decisionInput = {
+				userAccount: challengeRecord.userAccount,
+				dappAccount: challengeRecord.dappAccount,
+				captchaResult: "passed",
+				headers: challengeRecord.headers,
+				captchaType: _prosopo_types.CaptchaType.pow,
+				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
+			};
+			const decision = await this.decisionMachineRunner.decide(decisionInput, logger);
+			if (decision.decision === _prosopo_types.DecisionMachineDecision.Deny) {
+				logger.info(() => ({
+					msg: "Decision machine denied PoW captcha in server verification",
+					data: {
+						userAccount: challengeRecord.userAccount,
+						reason: decision.reason,
+						score: decision.score,
+						tags: decision.tags
+					}
+				}));
+				const dmReason = decision.reason || _prosopo_types.ResultReason.CAPTCHA_DECISION_MACHINE_DENIED;
+				failResult = {
+					status: _prosopo_types.CaptchaStatus.disapproved,
+					reason: dmReason
+				};
+				failReason = dmReason;
+			} else logger.debug(() => ({
+				msg: "Decision machine allowed PoW captcha",
+				data: {
+					reason: decision.reason,
+					score: decision.score,
+					tags: decision.tags
+				}
+			}));
+		} catch (error) {
+			logger.error(() => ({
+				msg: "Failed to run decision machine in server PoW verification",
+				err: error
+			}));
+		}
+		const finalResult = failResult || { status: _prosopo_types.CaptchaStatus.approved };
+		if (failResult) powRecordUpdates.result = failResult;
+		const writePromises = [];
+		if (Object.keys(powRecordUpdates).length > 0) writePromises.push(this.db.updatePowCaptchaRecord(challengeRecord.challenge, powRecordUpdates));
+		if (challengeRecord.sessionId) writePromises.push(this.updateSessionRecordWithCache(challengeRecord.sessionId, {
+			serverChecked: true,
+			result: finalResult
+		}, true));
+		if (writePromises.length > 0) await Promise.all(writePromises);
+		if (failReason) return notVerified(failReason);
+		return {
+			verified: true,
+			...score ? { score } : {}
+		};
+	}
+};
+//#endregion
 exports.PowCaptchaManager = PowCaptchaManager;