@prosopo/provider 2.5.5 → 2.7.1

package/dist/cjs/tasks/client/clientTasks.cjs

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_crypto = require("node:crypto");
+const common = require("@prosopo/common");
+const database = require("@prosopo/database");
+const types = require("@prosopo/types");
+const util = require("@prosopo/util");
+const validateAddress = require("../../api/validateAddress.cjs");
+const isValidPrivateKey = (privateKeyString) => {
+  const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
+  try {
+    node_crypto.createPrivateKey({
+      key: privateKey,
+      format: "pem",
+      type: "pkcs8"
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+class ClientTaskManager {
+  constructor(config, logger, db) {
+    this.config = config;
+    this.logger = logger;
+    this.providerDB = db;
+  }
+  /**
+   * @description Get the captcha database connection or create a new one
+   * @returns CaptchaDatabase
+   */
+  getCaptchaDB(mongoCaptchaUri) {
+    if (this.captchaDB) {
+      return this.captchaDB;
+    }
+    if (!this.captchaDB) {
+      this.captchaDB = new database.CaptchaDatabase(
+        mongoCaptchaUri,
+        void 0,
+        void 0,
+        this.logger
+      );
+    }
+    return this.captchaDB;
+  }
+  /**
+   * @description Store commitments externally in the database (Sends image captcha data to the big Mongo Cloud DB)
+   * @returns Promise<void>
+   */
+  async storeCommitmentsExternal() {
+    if (!this.config.mongoCaptchaUri) {
+      this.logger.info("Mongo env not set");
+      return;
+    }
+    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
+      types.ScheduledTaskNames.StoreCommitmentsExternal,
+      types.ScheduledTaskStatus.Completed
+    );
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      types.ScheduledTaskNames.StoreCommitmentsExternal,
+      types.ScheduledTaskStatus.Running
+    );
+    try {
+      const BATCH_SIZE = 1e3;
+      const captchaDB = this.getCaptchaDB(this.config.mongoCaptchaUri);
+      let processedCommitments = 0;
+      await this.processBatchesWithCursor(
+        async (skip) => await this.providerDB.getUnstoredDappUserCommitments(
+          BATCH_SIZE,
+          skip
+        ),
+        async (batch) => {
+          const filteredBatch = lastTask?.updated ? batch.filter((commitment) => this.isRecordUpdated(commitment)) : batch;
+          if (filteredBatch.length > 0) {
+            await captchaDB.saveCaptchas([], filteredBatch, []);
+            await this.providerDB.markDappUserCommitmentsStored(
+              filteredBatch.map((commitment) => commitment.id)
+            );
+          }
+          processedCommitments += filteredBatch.length;
+        }
+      );
+      let processedPowRecords = 0;
+      await this.processBatchesWithCursor(
+        async (skip) => await this.providerDB.getUnstoredDappUserPoWCommitments(
+          BATCH_SIZE,
+          skip
+        ),
+        async (batch) => {
+          const filteredBatch = lastTask?.updated ? batch.filter((record) => this.isRecordUpdated(record)) : batch;
+          if (filteredBatch.length > 0) {
+            await captchaDB.saveCaptchas([], [], filteredBatch);
+            await this.providerDB.markDappUserPoWCommitmentsStored(
+              filteredBatch.map((record) => record.challenge)
+            );
+          }
+          processedPowRecords += filteredBatch.length;
+        }
+      );
+      let processedSessionRecords = 0;
+      await this.processBatchesWithCursor(
+        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(
+            `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({
+                message: "No token record found",
+                context: { tokenId: record.tokenId }
+              });
+              return {
+                ...record,
+                score: 0,
+                scoreComponents: {
+                  baseScore: 0
+                },
+                threshold: 0
+              };
+            }
+            return {
+              ...record,
+              score: tokenRecord?.score || 0,
+              scoreComponents: tokenRecord?.scoreComponents,
+              threshold: tokenRecord?.threshold || 0
+            };
+          });
+          if (filteredBatch.length > 0) {
+            await captchaDB.saveCaptchas(filteredBatchWithScores, [], []);
+            await this.providerDB.markSessionRecordsStored(
+              filteredBatch.map((record) => record.sessionId)
+            );
+          }
+          processedSessionRecords += filteredBatch.length;
+        }
+      );
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Completed,
+        {
+          data: {
+            processedSessionRecords,
+            processedCommitments,
+            processedPowRecords
+          }
+        }
+      );
+      this.captchaDB?.close();
+    } catch (e) {
+      this.logger.error(e);
+      this.captchaDB?.close();
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
+    }
+  }
+  /**
+   * @description Get a list of client accounts and their settings from the client database
+   * @returns Promise<void>
+   */
+  async getClientList() {
+    if (!this.config.mongoClientUri) {
+      this.logger.info("Mongo env not set");
+      return;
+    }
+    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
+      types.ScheduledTaskNames.GetClientList,
+      types.ScheduledTaskStatus.Completed
+    );
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      types.ScheduledTaskNames.GetClientList,
+      types.ScheduledTaskStatus.Running
+    );
+    try {
+      const clientDB = new database.ClientDatabase(
+        this.config.mongoClientUri,
+        void 0,
+        // expected to come from URI
+        void 0,
+        // expected to come from URI
+        this.logger
+      );
+      const tenMinuteWindow = 10 * 60 * 1e3;
+      const updatedAtTimestamp = lastTask?.updated ? lastTask.updated - tenMinuteWindow || 0 : 0;
+      this.logger.info({
+        message: `Getting updated client records since ${new Date(updatedAtTimestamp).toDateString()}`
+      });
+      const newClientRecords = await clientDB.getUpdatedClients(updatedAtTimestamp);
+      if (newClientRecords) {
+        await this.providerDB.updateClientRecords(newClientRecords);
+      }
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Completed,
+        {
+          data: {
+            clientRecords: newClientRecords.length
+          }
+        }
+      );
+    } catch (e) {
+      const getClientListError = new common.ProsopoApiError("DATABASE.UNKNOWN", {
+        context: { error: e },
+        logger: this.logger
+      });
+      this.logger.error(getClientListError, { context: { error: e } });
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
+    }
+  }
+  async registerSiteKey(siteKey, tier, settings) {
+    validateAddress.validiateSiteKey(siteKey);
+    await this.providerDB.updateClientRecords([
+      {
+        account: siteKey,
+        tier,
+        settings
+      }
+    ]);
+  }
+  async updateDetectorKey(detectorKey) {
+    if (!isValidPrivateKey(detectorKey)) {
+      throw new common.ProsopoApiError("INVALID_DETECTOR_KEY", {
+        context: { detectorKey },
+        logger: this.logger
+      });
+    }
+    await this.providerDB.storeDetectorKey(detectorKey);
+  }
+  async removeDetectorKey(detectorKey) {
+    if (!isValidPrivateKey(detectorKey)) {
+      throw new common.ProsopoApiError("INVALID_DETECTOR_KEY", {
+        context: { detectorKey },
+        logger: this.logger
+      });
+    }
+    await this.providerDB.removeDetectorKey(detectorKey);
+  }
+  isSubdomainOrExactMatch(referrer, clientDomain) {
+    if (!referrer || !clientDomain) return false;
+    if (clientDomain === "*") return true;
+    try {
+      const referrerDomain = util.parseUrl(referrer).hostname.replace(/\.$/, "");
+      const allowedDomain = util.parseUrl(clientDomain).hostname.replace(/\.$/, "");
+      return referrerDomain === allowedDomain || referrerDomain.endsWith(`.${allowedDomain}`);
+    } catch {
+      this.logger.error({
+        message: "Error in isSubdomainOrExactMatch",
+        context: { referrer, clientDomain }
+      });
+      return false;
+    }
+  }
+  isRecordUpdated(record) {
+    const { lastUpdatedTimestamp, storedAtTimestamp } = record;
+    return !lastUpdatedTimestamp || !storedAtTimestamp || lastUpdatedTimestamp > storedAtTimestamp;
+  }
+  async processBatchesWithCursor(fetchBatch, processBatch) {
+    let skip = 0;
+    while (true) {
+      const batch = await fetchBatch(skip);
+      if (!batch.length) break;
+      await processBatch(batch);
+      skip += batch.length;
+    }
+  }
+}
+exports.ClientTaskManager = ClientTaskManager;

package/dist/cjs/tasks/dataset/datasetTasks.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const datasets = require("@prosopo/datasets");
+const datasetTasksUtils = require("./datasetTasksUtils.cjs");
+class DatasetManager {
+  constructor(config, logger, captchaConfig, db) {
+    this.config = config;
+    this.logger = logger;
+    this.captchaConfig = captchaConfig;
+    this.db = db;
+  }
+  /**
+   * @description Set the provider dataset from a file
+   *
+   * @param file JSON of the captcha dataset
+   */
+  async providerSetDatasetFromFile(file) {
+    const datasetRaw = datasets.parseCaptchaDataset(file);
+    return await this.providerSetDataset(datasetRaw);
+  }
+  async providerSetDataset(datasetRaw) {
+    const dataset = await datasetTasksUtils.providerValidateDataset(
+      datasetRaw,
+      this.captchaConfig.solved.count,
+      this.captchaConfig.unsolved.count
+    );
+    await this.db?.storeDataset(dataset);
+  }
+}
+exports.DatasetManager = DatasetManager;

package/dist/cjs/tasks/dataset/datasetTasksUtils.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const datasets = require("@prosopo/datasets");
+const providerValidateDataset = async (datasetRaw, minSolvedCaptchas, minUnsolvedCaptchas) => {
+  if (datasetRaw.captchas.length < minSolvedCaptchas + minUnsolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const solutions = datasetRaw.captchas.map((captcha) => captcha.solution ? 1 : 0).reduce((partialSum, b) => partialSum + b, 0);
+  if (solutions < minSolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  if (solutions < minUnsolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const dataset = await datasets.buildDataset(datasetRaw);
+  if (!dataset.datasetId || !dataset.datasetContentId) {
+    throw new common.ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
+      context: {
+        failedFuncName: providerValidateDataset.name,
+        datasetId: dataset.datasetId,
+        datasetContentId: dataset.datasetContentId
+      }
+    });
+  }
+  return dataset;
+};
+exports.providerValidateDataset = providerValidateDataset;