@prosopo/provider 3.12.14 → 3.13.6

package/dist/cjs/tasks/frictionless/frictionlessTasks.cjs

@@ -17,9 +17,18 @@ const getDefaultEntropy = () => {
 };
 const DEFAULT_MAX_TIMESTAMP_AGE = 60 * 10 * 1e3;
 const DEFAULT_ENTROPY = getDefaultEntropy();
+var FrictionlessReason = /* @__PURE__ */ ((FrictionlessReason2) => {
+  FrictionlessReason2["CONTEXT_AWARE_VALIDATION_FAILED"] = "CONTEXT_AWARE_VALIDATION_FAILED";
+  FrictionlessReason2["USER_ACCESS_POLICY"] = "USER_ACCESS_POLICY";
+  FrictionlessReason2["USER_AGENT_MISMATCH"] = "USER_AGENT_MISMATCH";
+  FrictionlessReason2["OLD_TIMESTAMP"] = "OLD_TIMESTAMP";
+  FrictionlessReason2["BOT_SCORE_ABOVE_THRESHOLD"] = "BOT_SCORE_ABOVE_THRESHOLD";
+  FrictionlessReason2["WEBVIEW_DETECTED"] = "WEBVIEW_DETECTED";
+  return FrictionlessReason2;
+})(FrictionlessReason || {});
 class FrictionlessManager extends captchaManager.CaptchaManager {
   constructor(db, pair, config, logger) {
-    super(db, pair, logger);
+    super(db, pair, config, logger);
     this.config = config;
   }
   setSessionParams(params) {
@@ -44,7 +53,7 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
   checkLangRules(acceptLanguage) {
     return lang.checkLangRules(this.config, acceptLanguage);
   }
-  async createSession(token, score, threshold, scoreComponents, providerSelectEntropy, ipAddress, captchaType, solvedImagesCount, powDifficulty, webView = false, iFrame = false, decryptedHeadHash = "") {
+  async createSession(token, score, threshold, scoreComponents, providerSelectEntropy, ipAddress, captchaType, solvedImagesCount, powDifficulty, userSitekeyIpHash, webView = false, iFrame = false, decryptedHeadHash = "", reason) {
     const sessionRecord = {
       sessionId: uuid.v4(),
       createdAt: /* @__PURE__ */ new Date(),
@@ -57,9 +66,11 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       captchaType,
       solvedImagesCount,
       powDifficulty,
+      userSitekeyIpHash,
       webView,
       iFrame,
-      decryptedHeadHash
+      decryptedHeadHash,
+      reason
     };
     await this.db.storeSessionRecord(sessionRecord);
     return sessionRecord;
@@ -97,11 +108,13 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       effectiveParams.providerSelectEntropy,
       effectiveParams.ipAddress,
       types.CaptchaType.image,
-      params?.solvedImagesCount,
+      effectiveParams.solvedImagesCount,
       void 0,
+      effectiveParams.userSitekeyIpHash,
       effectiveParams.webView ?? false,
       effectiveParams.iFrame ?? false,
-      effectiveParams.decryptedHeadHash
+      effectiveParams.decryptedHeadHash,
+      effectiveParams.reason
     );
     return {
       [types.ApiParams.captchaType]: types.CaptchaType.image,
@@ -125,10 +138,12 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       effectiveParams.ipAddress,
       types.CaptchaType.pow,
       void 0,
-      params?.powDifficulty,
+      effectiveParams.powDifficulty,
+      effectiveParams.userSitekeyIpHash,
       effectiveParams.webView ?? false,
       effectiveParams.iFrame ?? false,
-      effectiveParams.decryptedHeadHash
+      effectiveParams.decryptedHeadHash,
+      effectiveParams.reason
     );
     return {
       [types.ApiParams.captchaType]: types.CaptchaType.pow,
@@ -234,6 +249,7 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
     let webView;
     let iFrame;
     let decryptedHeadHash = "";
+    let decryptionFailed = false;
     for (const [keyIndex, key] of decryptKeys.entries()) {
       try {
         this.logger.info(() => ({
@@ -281,6 +297,7 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
           timestamp = 0;
           providerSelectEntropy = DEFAULT_ENTROPY + 1;
           decryptedHeadHash = "";
+          decryptionFailed = true;
         }
       }
     }
@@ -296,6 +313,7 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       timestamp = 0;
       providerSelectEntropy = DEFAULT_ENTROPY - undefinedCount;
       decryptedHeadHash = "";
+      decryptionFailed = true;
     }
     this.logger.info(() => ({
       msg: "decryptPayload result",
@@ -307,7 +325,8 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
         userAgent,
         webView,
         iFrame,
-        decryptedHeadHash
+        decryptedHeadHash,
+        decryptionFailed
       }
     }));
     return {
@@ -316,11 +335,16 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       providerSelectEntropy: Number(providerSelectEntropy),
       userId,
       userAgent,
-      webView,
-      iFrame,
-      decryptedHeadHash
+      webView: webView || false,
+      iFrame: iFrame || false,
+      decryptedHeadHash,
+      decryptionFailed
     };
   }
+  async getClientEntropy(siteKey) {
+    return this.db.getClientEntropy(siteKey);
+  }
 }
 exports.DEFAULT_ENTROPY = DEFAULT_ENTROPY;
 exports.FrictionlessManager = FrictionlessManager;
+exports.FrictionlessReason = FrictionlessReason;

package/dist/cjs/tasks/frictionless/frictionlessTasksUtils.cjs

@@ -8,7 +8,10 @@ const computeFrictionlessScore = (scoreComponents) => {
     ).toFixed(2)
   );
 };
-const timestampDecayFunction = (timestamp) => {
+const timestampDecayFunction = (timestamp, decryptionFailed) => {
+  if (decryptionFailed) {
+    return 6;
+  }
   const max = (/* @__PURE__ */ new Date()).getTime();
   if (max - timestamp > 36e5) {
     return 12;

package/dist/cjs/tasks/imgCaptcha/imgCaptchaTasks.cjs

@@ -11,11 +11,12 @@ const pairs = require("../../pairs.cjs");
 const lang = require("../../rules/lang.cjs");
 const util = require("../../util.cjs");
 const captchaManager = require("../captchaManager.cjs");
+const frictionlessTasks = require("../frictionless/frictionlessTasks.cjs");
 const frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.cjs");
 const imgCaptchaTasksUtils = require("./imgCaptchaTasksUtils.cjs");
 class ImgCaptchaManager extends captchaManager.CaptchaManager {
   constructor(db, pair, config, logger) {
-    super(db, pair, logger);
+    super(db, pair, config, logger);
     this.config = config;
   }
   async getCaptchaWithProof(datasetId, solved, size) {
@@ -334,7 +335,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
     }
     return void 0;
   }
-  async verifyImageCaptchaSolution(user, dapp, commitmentId, env, maxVerifiedTime, ip, disallowWebView) {
+  async verifyImageCaptchaSolution(user, dapp, commitmentId, env, maxVerifiedTime, ip, disallowWebView, contextAwareEnabled = false) {
     const solution = await (commitmentId ? this.getDappUserCommitmentById(commitmentId) : this.getDappUserCommitmentByAccount(user, dapp));
     if (!solution) {
       this.logger.debug(() => ({
@@ -409,6 +410,11 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
           }));
           return { status: "API.USER_NOT_VERIFIED", verified: false };
         }
+        if (contextAwareEnabled && sessionRecord.reason === frictionlessTasks.FrictionlessReason.CONTEXT_AWARE_VALIDATION_FAILED) {
+          this.logger.info(() => ({
+            msg: "Context aware validation failed"
+          }));
+        }
       }
     }
     return {

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

@@ -11,8 +11,8 @@ const frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.c
 const powTasksUtils = require("./powTasksUtils.cjs");
 const DEFAULT_POW_DIFFICULTY = 4;
 class PowCaptchaManager extends captchaManager.CaptchaManager {
-  constructor(db, pair, logger) {
-    super(db, pair, logger);
+  constructor(db, pair, config, logger) {
+    super(db, pair, config, logger);
     this.POW_SEPARATOR = types.POW_SEPARATOR;
   }
   /**

package/dist/cjs/tasks/tasks.cjs

@@ -21,6 +21,7 @@ class Tasks {
     this.powCaptchaManager = new powTasks.PowCaptchaManager(
       this.db,
       this.pair,
+      this.config,
       this.logger
     );
     this.datasetManager = new datasetTasks.DatasetManager(

package/dist/cjs/utils/hashUserIp.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_crypto = require("node:crypto");
+function hashUserIp(user, ip, sitekey) {
+  const hash = node_crypto.createHash("sha256");
+  hash.update(`${user}:${ip}:${sitekey}`, "utf8");
+  return hash.digest("hex");
+}
+exports.hashUserIp = hashUserIp;

package/dist/index.js

@@ -8,6 +8,7 @@ import { publicRouter } from "./api/public.js";
 import { domainMiddleware } from "./api/domainMiddleware.js";
 import { storeCaptchasExternally } from "./schedulers/captchaScheduler.js";
 import { getClientList } from "./schedulers/getClientList.js";
+import { setClientEntropy } from "./schedulers/setClientEntropy.js";
 import { headerCheckMiddleware } from "./api/headerCheckMiddleware.js";
 import { createApiAdminRoutesProvider } from "./api/admin/createApiAdminRoutesProvider.js";
 import { ignoreMiddleware } from "./api/ignoreMiddleware.js";
@@ -39,6 +40,7 @@ export {
   prosopoVerifyRouter,
   publicRouter,
   robotsMiddleware,
+  setClientEntropy,
   shuffleArray,
   storeCaptchasExternally,
   validateIpAddress

package/dist/schedulers/setClientEntropy.js

@@ -3,29 +3,34 @@ import { ScheduledTaskNames } from "@prosopo/types";
 import { CronJob } from "cron";
 import { Tasks } from "../tasks/tasks.js";
 import { checkIfTaskIsRunning } from "../util.js";
-export async function setClientEntropy(pair, cronSchedule, config) {
-    const env = new ProviderEnvironment(config, pair);
-    await env.isReady();
-    const tasks = new Tasks(env);
-    const job = new CronJob(cronSchedule, async () => {
-        const taskRunning = await checkIfTaskIsRunning(ScheduledTaskNames.SetClientEntropy, env.getDb());
-        env.logger.info(() => ({
-            msg: `${ScheduledTaskNames.SetClientEntropy} task running: ${taskRunning}`,
-            data: { taskRunning },
+async function setClientEntropy(pair, cronSchedule, config) {
+  const env = new ProviderEnvironment(config, pair);
+  await env.isReady();
+  const tasks = new Tasks(env);
+  const job = new CronJob(cronSchedule, async () => {
+    const taskRunning = await checkIfTaskIsRunning(
+      ScheduledTaskNames.SetClientEntropy,
+      env.getDb()
+    );
+    env.logger.info(() => ({
+      msg: `${ScheduledTaskNames.SetClientEntropy} task running: ${taskRunning}`,
+      data: { taskRunning }
+    }));
+    if (!taskRunning) {
+      env.logger.info(() => ({
+        msg: `${ScheduledTaskNames.SetClientEntropy} task....`,
+        data: {}
+      }));
+      await tasks.clientTaskManager.calculateClientEntropy().catch((err) => {
+        env.logger.error(() => ({
+          err,
+          msg: "Error setting client entropy"
         }));
-        if (!taskRunning) {
-            env.logger.info(() => ({
-                msg: `${ScheduledTaskNames.SetClientEntropy} task....`,
-                data: {},
-            }));
-            await tasks.clientTaskManager.calculateClientEntropy().catch((err) => {
-                env.logger.error(() => ({
-                    err,
-                    msg: "Error setting client entropy",
-                }));
-            });
-        }
-    });
-    job.start();
+      });
+    }
+  });
+  job.start();
 }
-//# sourceMappingURL=setClientEntropy.js.map
+export {
+  setClientEntropy
+};

package/dist/tasks/captchaManager.js

@@ -2,9 +2,10 @@ import { getLogger } from "@prosopo/common";
 import { CaptchaType, ApiParams, Tier } from "@prosopo/types";
 import { getPrioritisedAccessRule } from "../api/blacklistRequestInspector.js";
 class CaptchaManager {
-  constructor(db, pair, logger) {
+  constructor(db, pair, config, logger) {
     this.pair = pair;
     this.db = db;
+    this.config = config;
     this.logger = logger || getLogger("info", import.meta.url);
   }
   async validateSessionIP(sessionRecord, currentIP, env) {

package/dist/tasks/client/clientTasks.js

@@ -2,7 +2,7 @@ import { createPrivateKey } from "node:crypto";
 import { ProsopoApiError } from "@prosopo/common";
 import { CaptchaDatabase, ClientDatabase } from "@prosopo/database";
 import { ScheduledTaskNames, ScheduledTaskStatus } from "@prosopo/types";
-import { parseUrl } from "@prosopo/util";
+import { majorityAverage, parseUrl } from "@prosopo/util";
 import { validateSiteKey } from "../../api/validateAddress.js";
 const isValidPrivateKey = (privateKeyString) => {
   const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
@@ -161,7 +161,13 @@ class ClientTaskManager {
         this.logger
       );
       const tenMinuteWindow = 10 * 60 * 1e3;
-      const updatedAtTimestamp = lastTask?.updated ? lastTask.updated.getTime() - tenMinuteWindow || 0 : 0;
+      const updatedAtTimestamp = (() => {
+        const raw = lastTask?.updated;
+        if (!raw) return 0;
+        const ts = raw instanceof Date ? raw.getTime() : Date.parse(String(raw));
+        if (Number.isNaN(ts)) return 0;
+        return Math.max(ts - tenMinuteWindow, 0);
+      })();
       this.logger.info(() => ({
         msg: `Getting updated client records since ${new Date(updatedAtTimestamp).toDateString()}`
       }));
@@ -194,6 +200,53 @@ class ClientTaskManager {
       );
     }
   }
+  /**
+   * @description Calculate client entropy scores and update in db
+   * @returns Promise<void>
+   */
+  async calculateClientEntropy() {
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      ScheduledTaskNames.SetClientEntropy,
+      ScheduledTaskStatus.Running
+    );
+    try {
+      const clients = await this.providerDB.getAllClientRecords();
+      for (const client of clients) {
+        const sampleEntropies = await this.providerDB.sampleEntropy(
+          100,
+          client.account
+        );
+        const avgEntropy = majorityAverage(sampleEntropies);
+        await this.providerDB.setClientEntropy(client.account, avgEntropy);
+      }
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        ScheduledTaskStatus.Completed,
+        {
+          data: {
+            clientRecords: clients.length
+          }
+        }
+      );
+    } catch (e) {
+      const calculateClientEntropiesError = new ProsopoApiError(
+        "DATABASE.UNKNOWN",
+        {
+          context: { error: e },
+          logger: this.logger
+        }
+      );
+      this.logger.error(() => ({
+        err: calculateClientEntropiesError,
+        msg: "Error calculating client entropy"
+      }));
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
+    }
+  }
   async registerSiteKey(siteKey, tier, settings) {
     validateSiteKey(siteKey);
     await this.providerDB.updateClientRecords([