@prosopo/provider 3.2.0 → 3.2.2

package/dist/tasks/detection/getBotScore.js

@@ -1,11 +1,13 @@
-import getBotScoreFromPayload from "./decodePayload.js";
-export const getBotScore = async (payload, privateKeyString) => {
-    const result = (await getBotScoreFromPayload(payload, privateKeyString));
-    const baseBotScore = result.score;
-    const timestamp = result.timestamp;
-    if (baseBotScore === undefined) {
-        return { baseBotScore: 1, timestamp: 0 };
-    }
-    return { baseBotScore, timestamp };
+import uTahDN from "./decodePayload.js";
+const getBotScore = async (payload, privateKeyString) => {
+  const result = await uTahDN(payload, privateKeyString);
+  const baseBotScore = result.score;
+  const timestamp = result.timestamp;
+  if (baseBotScore === void 0) {
+    return { baseBotScore: 1, timestamp: 0 };
+  }
+  return { baseBotScore, timestamp };
+};
+export {
+  getBotScore
 };
-//# sourceMappingURL=getBotScore.js.map

package/dist/tasks/frictionless/frictionlessTasks.js

@@ -1,127 +1,128 @@
-import { CaptchaType, } from "@prosopo/types";
-import { ApiParams } from "@prosopo/types";
-import { v4 as uuidv4 } from "uuid";
+import { CaptchaType, ApiParams } from "@prosopo/types";
+import { v4 } from "uuid";
 import { checkLangRules } from "../../rules/lang.js";
 import { CaptchaManager } from "../captchaManager.js";
 import { getBotScore } from "../detection/getBotScore.js";
-const DEFAULT_MAX_TIMESTAMP_AGE = 60 * 10 * 1000;
-export class FrictionlessManager extends CaptchaManager {
-    constructor(db, pair, config, logger) {
-        super(db, pair, logger);
-        this.config = config;
-    }
-    checkLangRules(acceptLanguage) {
-        return checkLangRules(this.config, acceptLanguage);
-    }
-    async createSession(tokenId, captchaType) {
-        const sessionRecord = {
-            sessionId: uuidv4(),
-            createdAt: new Date(),
-            tokenId: tokenId,
-            captchaType,
-        };
-        await this.db.storeSessionRecord(sessionRecord);
-        return sessionRecord;
-    }
-    async sendImageCaptcha(tokenId) {
-        const sessionRecord = await this.createSession(tokenId, CaptchaType.image);
-        return {
-            [ApiParams.captchaType]: CaptchaType.image,
-            [ApiParams.sessionId]: sessionRecord.sessionId,
-            [ApiParams.status]: "ok",
-        };
-    }
-    async sendPowCaptcha(tokenId) {
-        const sessionRecord = await this.createSession(tokenId, CaptchaType.pow);
-        return {
-            [ApiParams.captchaType]: CaptchaType.pow,
-            [ApiParams.sessionId]: sessionRecord.sessionId,
-            [ApiParams.status]: "ok",
-        };
-    }
-    async scoreIncreaseAccessPolicy(accessPolicy, baseBotScore, botScore, tokenId) {
-        const accessPolicyPenalty = accessPolicy?.frictionlessScore ||
-            this.config.penalties.PENALTY_ACCESS_RULE;
-        botScore += accessPolicyPenalty;
-        this.logger.info(() => ({
-            msg: "Address has an image captcha config defined",
-        }));
-        await this.db.updateFrictionlessTokenRecord(tokenId, {
-            score: botScore,
-            scoreComponents: {
-                baseScore: baseBotScore,
-                accessPolicy: accessPolicyPenalty,
-            },
-        });
-        return botScore;
-    }
-    async scoreIncreaseTimestamp(timestamp, baseBotScore, botScore, tokenId) {
+const DEFAULT_MAX_TIMESTAMP_AGE = 60 * 10 * 1e3;
+class FrictionlessManager extends CaptchaManager {
+  constructor(db, pair, config, logger) {
+    super(db, pair, logger);
+    this.config = config;
+  }
+  checkLangRules(acceptLanguage) {
+    return checkLangRules(this.config, acceptLanguage);
+  }
+  async createSession(tokenId, captchaType) {
+    const sessionRecord = {
+      sessionId: v4(),
+      createdAt: /* @__PURE__ */ new Date(),
+      tokenId,
+      captchaType
+    };
+    await this.db.storeSessionRecord(sessionRecord);
+    return sessionRecord;
+  }
+  async sendImageCaptcha(tokenId) {
+    const sessionRecord = await this.createSession(tokenId, CaptchaType.image);
+    return {
+      [ApiParams.captchaType]: CaptchaType.image,
+      [ApiParams.sessionId]: sessionRecord.sessionId,
+      [ApiParams.status]: "ok"
+    };
+  }
+  async sendPowCaptcha(tokenId) {
+    const sessionRecord = await this.createSession(tokenId, CaptchaType.pow);
+    return {
+      [ApiParams.captchaType]: CaptchaType.pow,
+      [ApiParams.sessionId]: sessionRecord.sessionId,
+      [ApiParams.status]: "ok"
+    };
+  }
+  async scoreIncreaseAccessPolicy(accessPolicy, baseBotScore, botScore, tokenId) {
+    const accessPolicyPenalty = accessPolicy?.frictionlessScore || this.config.penalties.PENALTY_ACCESS_RULE;
+    botScore += accessPolicyPenalty;
+    await this.db.updateFrictionlessTokenRecord(tokenId, {
+      score: botScore,
+      scoreComponents: {
+        baseScore: baseBotScore,
+        accessPolicy: accessPolicyPenalty
+      }
+    });
+    return botScore;
+  }
+  async scoreIncreaseTimestamp(timestamp, baseBotScore, botScore, tokenId) {
+    this.logger.info(() => ({
+      msg: "Timestamp is older than 10 minutes",
+      data: { timestamp: new Date(timestamp) }
+    }));
+    botScore += this.config.penalties.PENALTY_OLD_TIMESTAMP;
+    await this.db.updateFrictionlessTokenRecord(tokenId, {
+      score: botScore,
+      scoreComponents: {
+        baseScore: baseBotScore,
+        timeout: this.config.penalties.PENALTY_OLD_TIMESTAMP
+      }
+    });
+    return botScore;
+  }
+  static timestampTooOld(timestamp) {
+    const now = Date.now();
+    const diff = now - timestamp;
+    return diff > DEFAULT_MAX_TIMESTAMP_AGE;
+  }
+  async decryptPayload(token) {
+    const decryptKeys = [
+      process.env.BOT_DECRYPTION_KEY,
+      ...await this.getDetectorKeys()
+    ].filter((k) => k);
+    this.logger.debug(() => {
+      const loggedKey = decryptKeys.map(
+        (k) => k ? `${k.slice(0, 5)}... ${k.slice(k.length - 5, k.length + 5)} ... ${k.slice(-5)}` || "" : ""
+      );
+      return {
+        msg: "Decrypting score",
+        data: {
+          keysLength: decryptKeys.length,
+          keys: loggedKey
+        }
+      };
+    });
+    let baseBotScore;
+    let timestamp;
+    for (const [keyIndex, key] of decryptKeys.entries()) {
+      try {
+        const { baseBotScore: s, timestamp: t } = await getBotScore(token, key);
         this.logger.info(() => ({
-            msg: "Timestamp is older than 10 minutes",
-            data: { timestamp: new Date(timestamp) },
+          msg: "Successfully decrypted score",
+          data: {
+            key: key ? `${key.slice(0, 5)}...${key.slice(-5)}` : "",
+            baseBotScore: s,
+            timestamp: t
+          }
         }));
-        botScore += this.config.penalties.PENALTY_OLD_TIMESTAMP;
-        await this.db.updateFrictionlessTokenRecord(tokenId, {
-            score: botScore,
-            scoreComponents: {
-                baseScore: baseBotScore,
-                timeout: this.config.penalties.PENALTY_OLD_TIMESTAMP,
-            },
-        });
-        return botScore;
-    }
-    static timestampTooOld(timestamp) {
-        const now = Date.now();
-        const diff = now - timestamp;
-        return diff > DEFAULT_MAX_TIMESTAMP_AGE;
-    }
-    async decryptPayload(token) {
-        const decryptKeys = [
-            process.env.BOT_DECRYPTION_KEY,
-            ...(await this.getDetectorKeys()),
-        ].filter((k) => k);
-        this.logger.debug(() => ({
-            msg: "Decrypting score",
-            data: {
-                keysLength: decryptKeys.length,
-                keys: decryptKeys.map((k) => k ? `${k.slice(0, 5)}...${k.slice(-5)}` || "" : ""),
-            },
-        }));
-        let baseBotScore;
-        let timestamp;
-        for (const [keyIndex, key] of decryptKeys.entries()) {
-            try {
-                const { baseBotScore: s, timestamp: t } = await getBotScore(token, key);
-                this.logger.info(() => ({
-                    msg: "Successfully decrypted score",
-                    data: {
-                        key: key ? `${key.slice(0, 5)}...${key.slice(-5)}` : "",
-                        baseBotScore: s,
-                        timestamp: t,
-                    },
-                }));
-                baseBotScore = s;
-                timestamp = t;
-                break;
-            }
-            catch (err) {
-                if (keyIndex === decryptKeys.length - 1) {
-                    this.logger.warn(() => ({
-                        msg: "Error decrypting score: no more keys to try",
-                    }));
-                    baseBotScore = 1;
-                    timestamp = 0;
-                }
-            }
-        }
-        if (baseBotScore === undefined || timestamp === undefined) {
-            this.logger.error(() => ({
-                msg: "Error decrypting score: baseBotScore or timestamp is undefined",
-            }));
-            baseBotScore = 1;
-            timestamp = 0;
+        baseBotScore = s;
+        timestamp = t;
+        break;
+      } catch (err) {
+        if (keyIndex === decryptKeys.length - 1) {
+          this.logger.warn(() => ({
+            msg: "Error decrypting score: no more keys to try"
+          }));
+          baseBotScore = 1;
+          timestamp = 0;
         }
-        return { baseBotScore, timestamp };
+      }
+    }
+    if (baseBotScore === void 0 || timestamp === void 0) {
+      this.logger.error(() => ({
+        msg: "Error decrypting score: baseBotScore or timestamp is undefined"
+      }));
+      baseBotScore = 1;
+      timestamp = 0;
     }
+    return { baseBotScore, timestamp };
+  }
 }
-//# sourceMappingURL=frictionlessTasks.js.map
+export {
+  FrictionlessManager
+};

package/dist/tasks/frictionless/frictionlessTasksUtils.js

@@ -1,6 +1,11 @@
-export const computeFrictionlessScore = (scoreComponents) => {
-    return Number(Math.min(1, Object.values(scoreComponents)
-        .filter((x) => x !== undefined)
-        .reduce((acc, val) => acc + val, 0)).toFixed(2));
+const computeFrictionlessScore = (scoreComponents) => {
+  return Number(
+    Math.min(
+      1,
+      Object.values(scoreComponents).filter((x) => x !== void 0).reduce((acc, val) => acc + val, 0)
+    ).toFixed(2)
+  );
+};
+export {
+  computeFrictionlessScore
 };
-//# sourceMappingURL=frictionlessTasksUtils.js.map