@prosopo/provider 3.12.3 → 3.13.0

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");
@@ -100,44 +100,11 @@ class ClientTaskManager {
         async (skip) => await this.providerDB.getUnstoredSessionRecords(BATCH_SIZE, skip),
         async (batch) => {
           const filteredBatch = lastTask?.updated ? batch.filter((record) => this.isRecordUpdated(record)) : batch;
-          const frictionlessTokenRecords = await this.providerDB.getFrictionlessTokenRecordsByTokenIds(
-            filteredBatch.map((record) => record.tokenId)
-          );
-          this.logger.info(() => ({
-            msg: `Frictionless token records: ${frictionlessTokenRecords.length}`
-          }));
-          const filteredBatchWithScores = filteredBatch.map((record) => {
-            const tokenRecord = frictionlessTokenRecords.find(
-              (tokenRecord2) => tokenRecord2._id?.toString() === record.tokenId.toString()
-            );
-            if (!tokenRecord) {
-              this.logger.error(() => ({
-                msg: "No token record found",
-                data: { tokenId: record.tokenId }
-              }));
-              return {
-                ...record,
-                score: 0,
-                scoreComponents: {
-                  baseScore: 0
-                },
-                threshold: 0
-              };
-            }
-            const { _id, token, ...tokenRecordWithoutId } = tokenRecord;
-            return {
-              ...record,
-              ...tokenRecordWithoutId
-            };
-          });
           if (filteredBatch.length > 0) {
-            await captchaDB.saveCaptchas(filteredBatchWithScores, [], []);
+            await captchaDB.saveCaptchas(filteredBatch, [], []);
             await this.providerDB.markSessionRecordsStored(
               filteredBatch.map((record) => record.sessionId)
             );
-            await this.providerDB.markFrictionlessTokenRecordsStored(
-              filteredBatch.map((record) => record.tokenId).filter((id) => !!id)
-            );
           }
           processedSessionRecords += filteredBatch.length;
         }
@@ -194,7 +161,7 @@ class ClientTaskManager {
         this.logger
       );
       const tenMinuteWindow = 10 * 60 * 1e3;
-      const updatedAtTimestamp = lastTask?.updated ? lastTask.updated - tenMinuteWindow || 0 : 0;
+      const updatedAtTimestamp = lastTask?.updated ? lastTask.updated.getTime() - tenMinuteWindow || 0 : 0;
       this.logger.info(() => ({
         msg: `Getting updated client records since ${new Date(updatedAtTimestamp).toDateString()}`
       }));
@@ -227,6 +194,21 @@ class ClientTaskManager {
       );
     }
   }
+  /**
+   * @description Calculate client entropy scores and update in db
+   * @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 avgEntropy = majorityAverage(sampleEntropies);
+      await this.providerDB.setClientEntropy(client.account, avgEntropy);
+    }
+  }
   async registerSiteKey(siteKey, tier, settings) {
     validateSiteKey(siteKey);
     await this.providerDB.updateClientRecords([
@@ -293,7 +275,7 @@ class ClientTaskManager {
   }
   isRecordUpdated(record) {
     const { lastUpdatedTimestamp, storedAtTimestamp } = record;
-    return !lastUpdatedTimestamp || !storedAtTimestamp || lastUpdatedTimestamp > storedAtTimestamp;
+    return !lastUpdatedTimestamp || !storedAtTimestamp || lastUpdatedTimestamp.getTime() > storedAtTimestamp.getTime();
   }
   async processBatchesWithCursor(fetchBatch, processBatch) {
     let skip = 0;