@prosopo/provider 3.13.0 → 3.13.7

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

@@ -249,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(() => ({
@@ -296,6 +297,7 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
           timestamp = 0;
           providerSelectEntropy = DEFAULT_ENTROPY + 1;
           decryptedHeadHash = "";
+          decryptionFailed = true;
         }
       }
     }
@@ -311,6 +313,7 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       timestamp = 0;
       providerSelectEntropy = DEFAULT_ENTROPY - undefinedCount;
       decryptedHeadHash = "";
+      decryptionFailed = true;
     }
     this.logger.info(() => ({
       msg: "decryptPayload result",
@@ -322,7 +325,8 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
         userAgent,
         webView,
         iFrame,
-        decryptedHeadHash
+        decryptedHeadHash,
+        decryptionFailed
       }
     }));
     return {
@@ -333,11 +337,12 @@ class FrictionlessManager extends captchaManager.CaptchaManager {
       userAgent,
       webView: webView || false,
       iFrame: iFrame || false,
-      decryptedHeadHash
+      decryptedHeadHash,
+      decryptionFailed
     };
   }
-  async getClientEntropy(siteKey) {
-    return this.db.getClientEntropy(siteKey);
+  async getClientContextEntropy(siteKey, contextType) {
+    return this.db.getClientContextEntropy(siteKey, contextType);
   }
 }
 exports.DEFAULT_ENTROPY = DEFAULT_ENTROPY;

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/tasks/client/clientTasks.js

@@ -1,9 +1,10 @@
 import { createPrivateKey } from "node:crypto";
 import { ProsopoApiError } from "@prosopo/common";
 import { CaptchaDatabase, ClientDatabase } from "@prosopo/database";
-import { ScheduledTaskNames, ScheduledTaskStatus } from "@prosopo/types";
+import { ScheduledTaskNames, ScheduledTaskStatus, Tier } from "@prosopo/types";
 import { majorityAverage, parseUrl } from "@prosopo/util";
 import { validateSiteKey } from "../../api/validateAddress.js";
+const SAMPLE_SIZE = 100;
 const isValidPrivateKey = (privateKeyString) => {
   const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
   try {
@@ -161,7 +162,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()}`
       }));
@@ -199,14 +206,71 @@ class ClientTaskManager {
    * @returns Promise<void>
    */
   async calculateClientEntropy() {
-    const clients = await this.providerDB.getAllClientRecords();
-    for (const client of clients) {
-      const sampleEntropies = await this.providerDB.sampleEntropy(
-        100,
-        client.account
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      ScheduledTaskNames.SetClientEntropy,
+      ScheduledTaskStatus.Running
+    );
+    try {
+      let clients = await this.providerDB.getAllClientRecords();
+      clients = clients.filter((client) => client.tier !== Tier.Free);
+      this.logger.info(() => ({
+        msg: `Calculating entropies for ${clients.length} clients`
+      }));
+      for (const client of clients) {
+        if (client.settings?.contextAware?.enabled) {
+          const contextTypes = Object.keys(
+            client.settings.contextAware.contexts ?? {}
+          );
+          for (const contextType of contextTypes) {
+            const contextSamples = await this.providerDB.sampleContextEntropy(
+              SAMPLE_SIZE,
+              client.account,
+              contextType
+            );
+            if (contextSamples.length < SAMPLE_SIZE) {
+              this.logger.info(() => ({
+                msg: `Skipping ${contextType} entropy calculation for client ${client.account} due to insufficient samples (${contextSamples.length}/${SAMPLE_SIZE})`
+              }));
+              continue;
+            }
+            const contextAvgEntropy = majorityAverage(contextSamples);
+            this.logger.info(() => ({
+              msg: `Calculated ${contextType} entropy for client ${client.account}: ${contextAvgEntropy}`
+            }));
+            await this.providerDB.setClientContextEntropy(
+              client.account,
+              contextType,
+              contextAvgEntropy
+            );
+          }
+        }
+      }
+      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) }
       );
-      const avgEntropy = majorityAverage(sampleEntropies);
-      await this.providerDB.setClientEntropy(client.account, avgEntropy);
     }
   }
   async registerSiteKey(siteKey, tier, settings) {