@prosopo/provider 3.13.7 → 4.7.1

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

@@ -6,7 +6,7 @@ const database = require("@prosopo/database");
 const types = require("@prosopo/types");
 const util = require("@prosopo/util");
 const validateAddress = require("../../api/validateAddress.cjs");
-const SAMPLE_SIZE = 100;
+const SAMPLE_SIZE = 75;
 const isValidPrivateKey = (privateKeyString) => {
   const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
   try {
@@ -64,6 +64,7 @@ class ClientTaskManager {
     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(
@@ -71,11 +72,12 @@ class ClientTaskManager {
           skip
         ),
         async (batch) => {
-          const filteredBatch = lastTask?.updated ? batch.filter((commitment) => this.isRecordUpdated(commitment)) : 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)
+              filteredBatch.map((commitment) => commitment.id),
+              sweepStartedAt
             );
           }
           processedCommitments += filteredBatch.length;
@@ -92,7 +94,8 @@ class ClientTaskManager {
           if (filteredBatch.length > 0) {
             await captchaDB.saveCaptchas([], [], filteredBatch);
             await this.providerDB.markDappUserPoWCommitmentsStored(
-              filteredBatch.map((record) => record.challenge)
+              filteredBatch.map((record) => record.challenge),
+              sweepStartedAt
             );
           }
           processedPowRecords += filteredBatch.length;
@@ -106,7 +109,8 @@ class ClientTaskManager {
           if (filteredBatch.length > 0) {
             await captchaDB.saveCaptchas(filteredBatch, [], []);
             await this.providerDB.markSessionRecordsStored(
-              filteredBatch.map((record) => record.sessionId)
+              filteredBatch.map((record) => record.sessionId),
+              sweepStartedAt
             );
           }
           processedSessionRecords += filteredBatch.length;
@@ -285,6 +289,30 @@ class ClientTaskManager {
       }
     ]);
   }
+  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", {
@@ -305,6 +333,89 @@ class ClientTaskManager {
     }
     await this.providerDB.removeDetectorKey(detectorKey, expirationInSeconds);
   }
+  async updateDecisionMachine(scope, runtime, source, dappAccount, language, name, version, captchaType) {
+    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,
+      runtime,
+      language,
+      source,
+      name,
+      version,
+      captchaType,
+      createdAt: now,
+      updatedAt: now
+    });
+    return {
+      scope,
+      dappAccount,
+      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,
+      runtime: artifact.runtime,
+      language: artifact.language,
+      name: artifact.name,
+      version: artifact.version,
+      captchaType: artifact.captchaType,
+      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,
+      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*',

package/dist/cjs/tasks/decisionMachine/decisionMachineRunner.cjs

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vm = require("node:vm");
+const types = require("@prosopo/types");
+const zod = require("zod");
+const LOAD_TIMEOUT_MS = Number.parseInt(process.env.DECISION_MACHINE_LOAD_TIMEOUT_MS ?? "", 10) || 1e3;
+const EXEC_TIMEOUT_MS = Number.parseInt(process.env.DECISION_MACHINE_EXEC_TIMEOUT_MS ?? "", 10) || 2e3;
+const ARTIFACT_CACHE_TTL_MS = Number.parseInt(
+  process.env.DECISION_MACHINE_ARTIFACT_CACHE_TTL_MS ?? "",
+  10
+) || 5 * 60 * 1e3;
+const DEFAULT_DECISION = {
+  decision: types.DecisionMachineDecision.Allow
+};
+const RequiredCountersSchema = zod.z.array(types.CounterSpecSchema);
+class DecisionMachineRunner {
+  constructor(db) {
+    this.db = db;
+    this.artifactCache = /* @__PURE__ */ new Map();
+  }
+  /** Build a cache key for a given scope + dappAccount pair. */
+  static cacheKey(scope, dappAccount) {
+    return `${scope}:${dappAccount ?? ""}`;
+  }
+  /** Return a cached artifact if still fresh, or undefined. */
+  getCachedArtifact(scope, dappAccount) {
+    const entry = this.artifactCache.get(
+      DecisionMachineRunner.cacheKey(scope, dappAccount)
+    );
+    if (!entry) return null;
+    if (Date.now() - entry.cachedAt > ARTIFACT_CACHE_TTL_MS) {
+      this.artifactCache.delete(
+        DecisionMachineRunner.cacheKey(scope, dappAccount)
+      );
+      return null;
+    }
+    return entry.artifact;
+  }
+  /** Store an artifact (or undefined for negative cache) in the cache. */
+  setCachedArtifact(scope, dappAccount, artifact) {
+    this.artifactCache.set(DecisionMachineRunner.cacheKey(scope, dappAccount), {
+      artifact,
+      cachedAt: Date.now()
+    });
+  }
+  /**
+   * Evaluates a single decision machine artifact and returns a decision.
+   * Only one decision machine is selected and executed per request based on scope priority.
+   *
+   * @param input - The decision machine input containing user, dapp, and behavioral data
+   * @param logger - Optional logger for warnings and errors
+   * @returns A decision (allow/deny) with optional metadata
+   */
+  async decide(input, logger) {
+    try {
+      const artifact = await this.selectArtifact(
+        input.dappAccount,
+        input.captchaType
+      );
+      if (!artifact) {
+        return DEFAULT_DECISION;
+      }
+      if (artifact.runtime !== types.DecisionMachineRuntime.Node) {
+        logger?.warn?.(() => ({
+          msg: "Unsupported decision machine runtime, defaulting to allow",
+          data: { runtime: artifact.runtime }
+        }));
+        return DEFAULT_DECISION;
+      }
+      const decision = await this.runArtifactExport(
+        artifact,
+        ["decide", "default"],
+        { input: { ...input, phase: input.phase ?? "verify" } },
+        types.DecisionMachineOutputSchema
+      );
+      return decision ?? DEFAULT_DECISION;
+    } catch (error) {
+      logger?.error?.(() => ({
+        msg: "Decision machine failed, defaulting to allow",
+        err: error,
+        data: { dappAccount: input.dappAccount }
+      }));
+      return DEFAULT_DECISION;
+    }
+  }
+  /**
+   * Routing phase: ask the configured machine which concrete captcha type to
+   * serve. Returns undefined when no machine is configured, the machine has
+   * no route export, the machine throws or times out, or the output fails
+   * schema validation — caller should fall back to its baseline in any of
+   * these cases.
+   */
+  async route(input, logger) {
+    try {
+      const artifact = await this.selectArtifact(input.dappAccount);
+      if (!artifact) return void 0;
+      if (artifact.runtime !== types.DecisionMachineRuntime.Node) {
+        logger?.warn?.(() => ({
+          msg: "Unsupported routing machine runtime, falling back to baseline",
+          data: { runtime: artifact.runtime }
+        }));
+        return void 0;
+      }
+      return await this.runArtifactExport(
+        artifact,
+        ["route"],
+        { input, optional: true },
+        types.RoutingMachineOutputSchema
+      );
+    } catch (error) {
+      logger?.error?.(() => ({
+        msg: "Routing machine failed, falling back to baseline",
+        err: error,
+        data: { dappAccount: input.dappAccount }
+      }));
+      return void 0;
+    }
+  }
+  /**
+   * Pre-fetch hook: ask the configured machine which counters it needs read
+   * into its input before {@link route} is invoked. Returns [] when no machine
+   * is configured or it doesn't declare any.
+   */
+  async getRequiredCounters(input, logger) {
+    try {
+      const artifact = await this.selectArtifact(input.dappAccount);
+      if (!artifact) return [];
+      if (artifact.runtime !== types.DecisionMachineRuntime.Node) return [];
+      const specs = await this.runArtifactExport(
+        artifact,
+        ["requiredCounters"],
+        { input, optional: true },
+        RequiredCountersSchema
+      );
+      return specs ?? [];
+    } catch (error) {
+      logger?.warn?.(() => ({
+        msg: "requiredCounters() failed, proceeding with no counters",
+        err: error,
+        data: { dappAccount: input.dappAccount }
+      }));
+      return [];
+    }
+  }
+  /**
+   * Selects a single decision machine artifact based on scope priority.
+   * Currently supports two scopes with the following priority:
+   *   1. Dapp-specific: Custom decision machine for a specific dapp account
+   *   2. Global: Default decision machine applied to all dapps
+   *
+   * Decision machines can optionally specify a captchaType filter:
+   *   - If artifact has no captchaType: runs on all captcha types
+   *   - If artifact has captchaType: only runs on matching captcha type
+   *
+   * @param dappAccount - The dapp account identifier to check for dapp-specific artifacts
+   * @param captchaType - The captcha type to filter by (optional)
+   * @returns The single highest-priority artifact, or undefined if none exists
+   */
+  async selectArtifact(dappAccount, captchaType) {
+    const cachedDapp = this.getCachedArtifact(
+      types.DecisionMachineScope.Dapp,
+      dappAccount
+    );
+    const cachedGlobal = this.getCachedArtifact(types.DecisionMachineScope.Global);
+    if (cachedDapp !== null && cachedGlobal !== null) {
+      if (cachedDapp && this.matchesCaptchaType(cachedDapp, captchaType)) {
+        return cachedDapp;
+      }
+      if (cachedGlobal && this.matchesCaptchaType(cachedGlobal, captchaType)) {
+        return cachedGlobal;
+      }
+      return void 0;
+    }
+    const [dappArtifact, globalArtifact] = await Promise.all([
+      cachedDapp !== null ? Promise.resolve(cachedDapp) : this.db.getDecisionMachineArtifact(types.DecisionMachineScope.Dapp, dappAccount).then((a) => {
+        this.setCachedArtifact(
+          types.DecisionMachineScope.Dapp,
+          dappAccount,
+          a ?? void 0
+        );
+        return a ?? void 0;
+      }),
+      cachedGlobal !== null ? Promise.resolve(cachedGlobal) : this.db.getDecisionMachineArtifact(types.DecisionMachineScope.Global).then((a) => {
+        this.setCachedArtifact(
+          types.DecisionMachineScope.Global,
+          void 0,
+          a ?? void 0
+        );
+        return a ?? void 0;
+      })
+    ]);
+    if (dappArtifact && this.matchesCaptchaType(dappArtifact, captchaType)) {
+      return dappArtifact;
+    }
+    if (globalArtifact && this.matchesCaptchaType(globalArtifact, captchaType)) {
+      return globalArtifact;
+    }
+    return void 0;
+  }
+  /**
+   * Checks if a decision machine artifact matches the requested captcha type.
+   * - If artifact has no captchaType filter: matches all captcha types
+   * - If artifact has captchaType filter: only matches if types are equal
+   *
+   * @param artifact - The decision machine artifact to check
+   * @param captchaType - The captcha type to match against (optional)
+   * @returns True if the artifact should run for this captcha type
+   */
+  matchesCaptchaType(artifact, captchaType) {
+    if (!artifact.captchaType) {
+      return true;
+    }
+    return artifact.captchaType === captchaType;
+  }
+  /**
+   * Load the artifact source into a fresh vm sandbox, locate a callable
+   * matching one of {exportNames} (or `module.exports` itself if it's a
+   * function), invoke it with {input}, and validate the result with
+   * {schema}. Returns undefined when {options.optional} is true and no
+   * matching export exists. Otherwise throws on missing export, invalid
+   * output, or sandbox failure.
+   */
+  async runArtifactExport(artifact, exportNames, options, schema) {
+    const sandbox = {
+      module: { exports: {} },
+      exports: {}
+    };
+    const context = vm.createContext(sandbox);
+    const script = new vm.Script(artifact.source, {
+      filename: "decision-machine.js"
+    });
+    script.runInContext(context, { timeout: LOAD_TIMEOUT_MS });
+    const exported = sandbox.module.exports;
+    const named = this.findExport(exported, exportNames);
+    if (!named) {
+      if (options.optional) return void 0;
+      throw new Error(
+        `Decision machine must export one of: ${exportNames.join(", ")}`
+      );
+    }
+    const result = await this.withTimeout(
+      Promise.resolve(named.fn(options.input)),
+      EXEC_TIMEOUT_MS
+    );
+    const parsed = schema.safeParse(result);
+    if (!parsed.success) {
+      throw new Error(
+        `Decision machine '${named.name}' output failed validation`
+      );
+    }
+    return parsed.data;
+  }
+  findExport(exported, exportNames) {
+    if (typeof exported === "function" && (exportNames.includes("default") || exportNames.includes("decide"))) {
+      return {
+        name: "default",
+        fn: exported
+      };
+    }
+    for (const name of exportNames) {
+      const candidate = exported?.[name];
+      if (typeof candidate === "function") {
+        return { name, fn: candidate };
+      }
+    }
+    return void 0;
+  }
+  async withTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error("Decision machine timeout")),
+        timeoutMs
+      );
+    });
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+}
+exports.DecisionMachineRunner = DecisionMachineRunner;