@prosopo/provider 4.15.14 → 4.15.15

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

@@ -1,472 +1,349 @@
-"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 SAMPLE_SIZE = 75;
-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;
-  }
+const require_validateAddress = require("../../api/validateAddress.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_database = require("@prosopo/database");
+let _prosopo_types = require("@prosopo/types");
+let node_crypto = require("node:crypto");
+let _prosopo_util = require("@prosopo/util");
+//#region src/tasks/client/clientTasks.ts
+var SAMPLE_SIZE = 75;
+var isValidPrivateKey = (privateKeyString) => {
+	const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
+	try {
+		(0, 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(() => ({ msg: "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);
-      const sweepStartedAt = /* @__PURE__ */ new Date();
-      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).filter((commitment) => commitment.id !== "");
-          if (filteredBatch.length > 0) {
-            await captchaDB.saveCaptchas([], filteredBatch, []);
-            await this.providerDB.markDappUserCommitmentsStored(
-              filteredBatch.map((commitment) => commitment.id),
-              sweepStartedAt
-            );
-          }
-          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),
-              sweepStartedAt
-            );
-          }
-          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;
-          if (filteredBatch.length > 0) {
-            await captchaDB.saveCaptchas(filteredBatch, [], []);
-            await this.providerDB.markSessionRecordsStored(
-              filteredBatch.map((record) => record.sessionId),
-              sweepStartedAt
-            );
-          }
-          processedSessionRecords += filteredBatch.length;
-        }
-      );
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Completed,
-        {
-          data: {
-            processedSessionRecords,
-            processedCommitments,
-            processedPowRecords
-          }
-        }
-      );
-      this.captchaDB?.close();
-    } catch (e) {
-      this.logger.error(() => ({
-        err: e,
-        msg: "Error processing client tasks"
-      }));
-      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(() => ({ msg: "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 = (() => {
-        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()}`
-      }));
-      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(() => ({
-        err: getClientListError,
-        msg: "Error getting client list"
-      }));
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Failed,
-        { error: String(e) }
-      );
-    }
-  }
-  /**
-   * @description Calculate client entropy scores and update in db
-   * @returns Promise<void>
-   */
-  async calculateClientEntropy() {
-    const taskID = await this.providerDB.createScheduledTaskStatus(
-      types.ScheduledTaskNames.SetClientEntropy,
-      types.ScheduledTaskStatus.Running
-    );
-    try {
-      let clients = await this.providerDB.getAllClientRecords();
-      clients = clients.filter((client) => client.tier !== types.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 = util.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,
-        types.ScheduledTaskStatus.Completed,
-        {
-          data: {
-            clientRecords: clients.length
-          }
-        }
-      );
-    } catch (e) {
-      const calculateClientEntropiesError = new common.ProsopoApiError(
-        "DATABASE.UNKNOWN",
-        {
-          context: { error: e },
-          logger: this.logger
-        }
-      );
-      this.logger.error(() => ({
-        err: calculateClientEntropiesError,
-        msg: "Error calculating client entropy"
-      }));
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Failed,
-        { error: String(e) }
-      );
-    }
-  }
-  async registerSiteKey(siteKey, tier, settings) {
-    validateAddress.validateSiteKey(siteKey);
-    await this.providerDB.updateClientRecords([
-      {
-        account: siteKey,
-        tier,
-        settings
-      }
-    ]);
-  }
-  async registerSiteKeys(siteKeys) {
-    const records = [];
-    for (const { siteKey, tier, settings } of siteKeys) {
-      validateAddress.validateSiteKey(siteKey);
-      records.push({
-        account: siteKey,
-        tier,
-        settings
-      });
-    }
-    await this.providerDB.updateClientRecords(records);
-  }
-  async removeSiteKey(siteKey) {
-    validateAddress.validateSiteKey(siteKey);
-    await this.providerDB.removeClientRecords([siteKey]);
-  }
-  async removeSiteKeys(siteKeys) {
-    const accounts = [];
-    for (const { siteKey } of siteKeys) {
-      validateAddress.validateSiteKey(siteKey);
-      accounts.push(siteKey);
-    }
-    await this.providerDB.removeClientRecords(accounts);
-  }
-  async updateDetectorKey(detectorKey) {
-    if (!isValidPrivateKey(detectorKey)) {
-      throw new common.ProsopoApiError("INVALID_DETECTOR_KEY", {
-        context: { detectorKey },
-        logger: this.logger
-      });
-    }
-    await this.providerDB.storeDetectorKey(detectorKey);
-    const activeDetectorKeys = await this.providerDB.getDetectorKeys();
-    return activeDetectorKeys;
-  }
-  async removeDetectorKey(detectorKey, expirationInSeconds) {
-    if (!isValidPrivateKey(detectorKey)) {
-      throw new common.ProsopoApiError("INVALID_DETECTOR_KEY", {
-        context: { detectorKey },
-        logger: this.logger
-      });
-    }
-    await this.providerDB.removeDetectorKey(detectorKey, expirationInSeconds);
-  }
-  async updateDecisionMachine(scope, runtime, source, dappAccount, language, name, version, captchaType, kind) {
-    if (scope === types.DecisionMachineScope.Dapp && !dappAccount) {
-      throw new common.ProsopoApiError("API.BAD_REQUEST", {
-        context: { scope, dappAccount },
-        logger: this.logger
-      });
-    }
-    const now = /* @__PURE__ */ new Date();
-    await this.providerDB.upsertDecisionMachineArtifact({
-      scope,
-      dappAccount,
-      kind,
-      runtime,
-      language,
-      source,
-      name,
-      version,
-      captchaType,
-      createdAt: now,
-      updatedAt: now
-    });
-    return {
-      scope,
-      dappAccount,
-      kind,
-      updatedAt: now.toISOString()
-    };
-  }
-  async getAllDecisionMachines() {
-    const artifacts = await this.providerDB.getAllDecisionMachineArtifacts();
-    return artifacts.map((artifact) => ({
-      _id: artifact._id.toString(),
-      scope: artifact.scope,
-      dappAccount: artifact.dappAccount,
-      kind: artifact.kind,
-      runtime: artifact.runtime,
-      language: artifact.language,
-      name: artifact.name,
-      version: artifact.version,
-      captchaType: artifact.captchaType,
-      source: artifact.source,
-      createdAt: artifact.createdAt.toISOString(),
-      updatedAt: artifact.updatedAt.toISOString()
-    }));
-  }
-  async getDecisionMachine(id) {
-    const artifact = await this.providerDB.getDecisionMachineArtifactById(id);
-    if (!artifact) {
-      throw new common.ProsopoApiError("API.BAD_REQUEST", {
-        context: { id },
-        logger: this.logger
-      });
-    }
-    return {
-      _id: artifact._id.toString(),
-      scope: artifact.scope,
-      dappAccount: artifact.dappAccount,
-      kind: artifact.kind,
-      runtime: artifact.runtime,
-      language: artifact.language,
-      source: artifact.source,
-      name: artifact.name,
-      version: artifact.version,
-      captchaType: artifact.captchaType,
-      createdAt: artifact.createdAt.toISOString(),
-      updatedAt: artifact.updatedAt.toISOString()
-    };
-  }
-  async removeDecisionMachine(id) {
-    const success = await this.providerDB.removeDecisionMachineArtifact(id);
-    if (!success) {
-      throw new common.ProsopoApiError("API.BAD_REQUEST", {
-        context: { id, message: "Decision machine not found" },
-        logger: this.logger
-      });
-    }
-    return {
-      success,
-      deletedId: id
-    };
-  }
-  async removeAllDecisionMachines() {
-    const deletedCount = await this.providerDB.removeAllDecisionMachineArtifacts();
-    return {
-      success: true,
-      deletedCount
-    };
-  }
-  /**
-   * Matches a request referrer against an allowed domain pattern.
-   * Supports global '*', subdomain '*.example.com', glob '*example*',
-   * plain domains (exact or subdomain), and 'localhost'.
-   */
-  domainPatternMatcher(referrer, clientDomain) {
-    if (!referrer || !clientDomain) return false;
-    try {
-      const referrerHost = util.parseUrl(referrer).hostname.replace(/\.$/, "");
-      const pattern = clientDomain.trim().toLowerCase();
-      if (pattern === "*") return true;
-      if (pattern === "localhost") {
-        return referrerHost === "localhost" || referrerHost.startsWith("localhost:");
-      }
-      if (pattern.startsWith("*.")) {
-        const suffix = pattern.slice(2);
-        const allowed = util.parseUrl(suffix).hostname.replace(/\.$/, "");
-        return referrerHost.endsWith(`.${allowed}`) || referrerHost === allowed;
-      }
-      if (pattern.includes("*")) {
-        const escaped = pattern.replace(/[.+?^${}()|\[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-        const regex = new RegExp(`^${escaped}$`, "i");
-        return regex.test(referrerHost);
-      }
-      const allowedHost = util.parseUrl(pattern).hostname.replace(/\.$/, "");
-      return referrerHost === allowedHost || referrerHost.endsWith(`.${allowedHost}`);
-    } catch (e) {
-      this.logger.error(() => ({
-        msg: "Error in domainPatternMatcher",
-        data: { referrer, clientDomain }
-      }));
-      return false;
-    }
-  }
-  isRecordUpdated(record) {
-    const { lastUpdatedTimestamp, storedAtTimestamp } = record;
-    return !lastUpdatedTimestamp || !storedAtTimestamp || lastUpdatedTimestamp.getTime() > storedAtTimestamp.getTime();
-  }
-  async processBatchesWithCursor(fetchBatch, processBatch) {
-    let skip = 0;
-    while (true) {
-      const batch = await fetchBatch(skip);
-      if (!batch.length) break;
-      await processBatch(batch);
-      skip += batch.length;
-    }
-  }
-}
+var ClientTaskManager = class {
+	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 _prosopo_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(() => ({ msg: "Mongo env not set" }));
+			return;
+		}
+		const lastTask = await this.providerDB.getLastScheduledTaskStatus(_prosopo_types.ScheduledTaskNames.StoreCommitmentsExternal, _prosopo_types.ScheduledTaskStatus.Completed);
+		const taskID = await this.providerDB.createScheduledTaskStatus(_prosopo_types.ScheduledTaskNames.StoreCommitmentsExternal, _prosopo_types.ScheduledTaskStatus.Running);
+		try {
+			const BATCH_SIZE = 1e3;
+			const captchaDB = this.getCaptchaDB(this.config.mongoCaptchaUri);
+			const sweepStartedAt = /* @__PURE__ */ new Date();
+			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).filter((commitment) => commitment.id !== "");
+				if (filteredBatch.length > 0) {
+					await captchaDB.saveCaptchas([], filteredBatch, []);
+					await this.providerDB.markDappUserCommitmentsStored(filteredBatch.map((commitment) => commitment.id), sweepStartedAt);
+				}
+				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), sweepStartedAt);
+				}
+				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;
+				if (filteredBatch.length > 0) {
+					await captchaDB.saveCaptchas(filteredBatch, [], []);
+					await this.providerDB.markSessionRecordsStored(filteredBatch.map((record) => record.sessionId), sweepStartedAt);
+				}
+				processedSessionRecords += filteredBatch.length;
+			});
+			await this.providerDB.updateScheduledTaskStatus(taskID, _prosopo_types.ScheduledTaskStatus.Completed, { data: {
+				processedSessionRecords,
+				processedCommitments,
+				processedPowRecords
+			} });
+			this.captchaDB?.close();
+		} catch (e) {
+			this.logger.error(() => ({
+				err: e,
+				msg: "Error processing client tasks"
+			}));
+			this.captchaDB?.close();
+			await this.providerDB.updateScheduledTaskStatus(taskID, _prosopo_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(() => ({ msg: "Mongo env not set" }));
+			return;
+		}
+		const lastTask = await this.providerDB.getLastScheduledTaskStatus(_prosopo_types.ScheduledTaskNames.GetClientList, _prosopo_types.ScheduledTaskStatus.Completed);
+		const taskID = await this.providerDB.createScheduledTaskStatus(_prosopo_types.ScheduledTaskNames.GetClientList, _prosopo_types.ScheduledTaskStatus.Running);
+		try {
+			const clientDB = new _prosopo_database.ClientDatabase(this.config.mongoClientUri, void 0, void 0, this.logger);
+			const tenMinuteWindow = 600 * 1e3;
+			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()}` }));
+			const newClientRecords = await clientDB.getUpdatedClients(updatedAtTimestamp);
+			if (newClientRecords) await this.providerDB.updateClientRecords(newClientRecords);
+			await this.providerDB.updateScheduledTaskStatus(taskID, _prosopo_types.ScheduledTaskStatus.Completed, { data: { clientRecords: newClientRecords.length } });
+		} catch (e) {
+			const getClientListError = new _prosopo_common.ProsopoApiError("DATABASE.UNKNOWN", {
+				context: { error: e },
+				logger: this.logger
+			});
+			this.logger.error(() => ({
+				err: getClientListError,
+				msg: "Error getting client list"
+			}));
+			await this.providerDB.updateScheduledTaskStatus(taskID, _prosopo_types.ScheduledTaskStatus.Failed, { error: String(e) });
+		}
+	}
+	/**
+	* @description Calculate client entropy scores and update in db
+	* @returns Promise<void>
+	*/
+	async calculateClientEntropy() {
+		const taskID = await this.providerDB.createScheduledTaskStatus(_prosopo_types.ScheduledTaskNames.SetClientEntropy, _prosopo_types.ScheduledTaskStatus.Running);
+		try {
+			let clients = await this.providerDB.getAllClientRecords();
+			clients = clients.filter((client) => client.tier !== _prosopo_types.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 = (0, _prosopo_util.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, _prosopo_types.ScheduledTaskStatus.Completed, { data: { clientRecords: clients.length } });
+		} catch (e) {
+			const calculateClientEntropiesError = new _prosopo_common.ProsopoApiError("DATABASE.UNKNOWN", {
+				context: { error: e },
+				logger: this.logger
+			});
+			this.logger.error(() => ({
+				err: calculateClientEntropiesError,
+				msg: "Error calculating client entropy"
+			}));
+			await this.providerDB.updateScheduledTaskStatus(taskID, _prosopo_types.ScheduledTaskStatus.Failed, { error: String(e) });
+		}
+	}
+	async registerSiteKey(siteKey, tier, settings) {
+		require_validateAddress.validateSiteKey(siteKey);
+		await this.providerDB.updateClientRecords([{
+			account: siteKey,
+			tier,
+			settings
+		}]);
+	}
+	async registerSiteKeys(siteKeys) {
+		const records = [];
+		for (const { siteKey, tier, settings } of siteKeys) {
+			require_validateAddress.validateSiteKey(siteKey);
+			records.push({
+				account: siteKey,
+				tier,
+				settings
+			});
+		}
+		await this.providerDB.updateClientRecords(records);
+	}
+	async removeSiteKey(siteKey) {
+		require_validateAddress.validateSiteKey(siteKey);
+		await this.providerDB.removeClientRecords([siteKey]);
+	}
+	async removeSiteKeys(siteKeys) {
+		const accounts = [];
+		for (const { siteKey } of siteKeys) {
+			require_validateAddress.validateSiteKey(siteKey);
+			accounts.push(siteKey);
+		}
+		await this.providerDB.removeClientRecords(accounts);
+	}
+	async updateDetectorKey(detectorKey) {
+		if (!isValidPrivateKey(detectorKey)) throw new _prosopo_common.ProsopoApiError("INVALID_DETECTOR_KEY", {
+			context: { detectorKey },
+			logger: this.logger
+		});
+		await this.providerDB.storeDetectorKey(detectorKey);
+		return await this.providerDB.getDetectorKeys();
+	}
+	async removeDetectorKey(detectorKey, expirationInSeconds) {
+		if (!isValidPrivateKey(detectorKey)) throw new _prosopo_common.ProsopoApiError("INVALID_DETECTOR_KEY", {
+			context: { detectorKey },
+			logger: this.logger
+		});
+		await this.providerDB.removeDetectorKey(detectorKey, expirationInSeconds);
+	}
+	async updateDecisionMachine(scope, runtime, source, dappAccount, language, name, version, captchaType, kind) {
+		if (scope === _prosopo_types.DecisionMachineScope.Dapp && !dappAccount) throw new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+			context: {
+				scope,
+				dappAccount
+			},
+			logger: this.logger
+		});
+		const now = /* @__PURE__ */ new Date();
+		await this.providerDB.upsertDecisionMachineArtifact({
+			scope,
+			dappAccount,
+			kind,
+			runtime,
+			language,
+			source,
+			name,
+			version,
+			captchaType,
+			createdAt: now,
+			updatedAt: now
+		});
+		return {
+			scope,
+			dappAccount,
+			kind,
+			updatedAt: now.toISOString()
+		};
+	}
+	async getAllDecisionMachines() {
+		return (await this.providerDB.getAllDecisionMachineArtifacts()).map((artifact) => ({
+			_id: artifact._id.toString(),
+			scope: artifact.scope,
+			dappAccount: artifact.dappAccount,
+			kind: artifact.kind,
+			runtime: artifact.runtime,
+			language: artifact.language,
+			name: artifact.name,
+			version: artifact.version,
+			captchaType: artifact.captchaType,
+			source: artifact.source,
+			createdAt: artifact.createdAt.toISOString(),
+			updatedAt: artifact.updatedAt.toISOString()
+		}));
+	}
+	async getDecisionMachine(id) {
+		const artifact = await this.providerDB.getDecisionMachineArtifactById(id);
+		if (!artifact) throw new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+			context: { id },
+			logger: this.logger
+		});
+		return {
+			_id: artifact._id.toString(),
+			scope: artifact.scope,
+			dappAccount: artifact.dappAccount,
+			kind: artifact.kind,
+			runtime: artifact.runtime,
+			language: artifact.language,
+			source: artifact.source,
+			name: artifact.name,
+			version: artifact.version,
+			captchaType: artifact.captchaType,
+			createdAt: artifact.createdAt.toISOString(),
+			updatedAt: artifact.updatedAt.toISOString()
+		};
+	}
+	async removeDecisionMachine(id) {
+		const success = await this.providerDB.removeDecisionMachineArtifact(id);
+		if (!success) throw new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+			context: {
+				id,
+				message: "Decision machine not found"
+			},
+			logger: this.logger
+		});
+		return {
+			success,
+			deletedId: id
+		};
+	}
+	async removeAllDecisionMachines() {
+		return {
+			success: true,
+			deletedCount: await this.providerDB.removeAllDecisionMachineArtifacts()
+		};
+	}
+	/**
+	* Matches a request referrer against an allowed domain pattern.
+	* Supports global '*', subdomain '*.example.com', glob '*example*',
+	* plain domains (exact or subdomain), and 'localhost'.
+	*/
+	domainPatternMatcher(referrer, clientDomain) {
+		if (!referrer || !clientDomain) return false;
+		try {
+			const referrerHost = (0, _prosopo_util.parseUrl)(referrer).hostname.replace(/\.$/, "");
+			const pattern = clientDomain.trim().toLowerCase();
+			if (pattern === "*") return true;
+			if (pattern === "localhost") return referrerHost === "localhost" || referrerHost.startsWith("localhost:");
+			if (pattern.startsWith("*.")) {
+				const suffix = pattern.slice(2);
+				const allowed = (0, _prosopo_util.parseUrl)(suffix).hostname.replace(/\.$/, "");
+				return referrerHost.endsWith(`.${allowed}`) || referrerHost === allowed;
+			}
+			if (pattern.includes("*")) {
+				const escaped = pattern.replace(/[.+?^${}()|\[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+				return new RegExp(`^${escaped}$`, "i").test(referrerHost);
+			}
+			const allowedHost = (0, _prosopo_util.parseUrl)(pattern).hostname.replace(/\.$/, "");
+			return referrerHost === allowedHost || referrerHost.endsWith(`.${allowedHost}`);
+		} catch (e) {
+			this.logger.error(() => ({
+				msg: "Error in domainPatternMatcher",
+				data: {
+					referrer,
+					clientDomain
+				}
+			}));
+			return false;
+		}
+	}
+	isRecordUpdated(record) {
+		const { lastUpdatedTimestamp, storedAtTimestamp } = record;
+		return !lastUpdatedTimestamp || !storedAtTimestamp || lastUpdatedTimestamp.getTime() > storedAtTimestamp.getTime();
+	}
+	async processBatchesWithCursor(fetchBatch, processBatch) {
+		let skip = 0;
+		while (true) {
+			const batch = await fetchBatch(skip);
+			if (!batch.length) break;
+			await processBatch(batch);
+			skip += batch.length;
+		}
+	}
+};
+//#endregion
 exports.ClientTaskManager = ClientTaskManager;