@prosopo/provider 3.15.0 → 4.7.2

package/dist/cjs/api/ipInfoMiddleware.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ipInfoMiddleware = (env) => {
+  return async (req, _res, next) => {
+    try {
+      const ip = req.ip;
+      if (ip && env.ipInfoService.isAvailable()) {
+        req.ipInfo = await env.ipInfoService.lookup(ip);
+      }
+      next();
+    } catch (err) {
+      req.logger?.warn?.(() => ({
+        msg: "IP info middleware failed",
+        err
+      }));
+      next();
+    }
+  };
+};
+exports.ipInfoMiddleware = ipInfoMiddleware;

package/dist/cjs/api/ja4Middleware.cjs

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const node_stream = require("node:stream");
 const apiExpressRouter = require("@prosopo/api-express-router");
-const common = require("@prosopo/common");
+const logger = require("@prosopo/logger");
 const utilCrypto = require("@prosopo/util-crypto");
 const readTlsClientHello = require("read-tls-client-hello");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 const DEFAULT_JA4 = "ja4";
-const getJA4 = async (headers, logger) => {
-  logger = logger || common.getLogger("info", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("api/ja4Middleware.cjs", document.baseURI).href);
+const getJA4 = async (headers, logger$1) => {
+  logger$1 = logger$1 || logger.getLogger("info", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("api/ja4Middleware.cjs", document.baseURI).href);
   if (process.env.NODE_ENV === "development") {
     return {
       ja4PlusFingerprint: `${DEFAULT_JA4}${utilCrypto.randomAsHex().slice(28, 32)}`
@@ -18,17 +18,17 @@ const getJA4 = async (headers, logger) => {
     const xTlsClientHello = (headers["x-tls-clienthello"] || "").toString();
     const xTlsVersion = (headers["x-tls-version"] || "").toString().toLowerCase();
     const clientHelloBuffer = Buffer.from(xTlsClientHello, "base64");
-    logger.debug(() => ({
+    logger$1.debug(() => ({
       msg: "ClientHello First Bytes:",
       data: { hex: clientHelloBuffer.subarray(0, 5).toString("hex") }
     }));
     if (clientHelloBuffer[5] !== 1) {
-      logger.debug(() => ({
+      logger$1.debug(() => ({
         msg: "Invalid ClientHello message: First byte is not 0x01"
       }));
       return { ja4PlusFingerprint: DEFAULT_JA4 };
     }
-    logger.debug(() => ({
+    logger$1.debug(() => ({
       msg: "Headers TLS Version:",
       data: { xTlsVersion }
     }));
@@ -41,7 +41,7 @@ const getJA4 = async (headers, logger) => {
     const ja4PlusFingerprint = readTlsClientHello.calculateJa4FromHelloData(clientHello);
     return { ja4PlusFingerprint };
   } catch (e) {
-    logger.error(() => ({
+    logger$1.error(() => ({
       msg: "Error generating JA4+ fingerprint:",
       err: e instanceof Error ? e : new Error(String(e))
     }));

package/dist/cjs/api/startProviderApi.cjs

@@ -0,0 +1,240 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs");
+const https = require("node:https");
+const path = require("node:path");
+const node_url = require("node:url");
+const apiExpressRouter = require("@prosopo/api-express-router");
+const loadBalancer = require("@prosopo/load-balancer");
+const locale = require("@prosopo/locale");
+const logger = require("@prosopo/logger");
+const types = require("@prosopo/types");
+const api = require("@prosopo/user-access-policy/api");
+const node = require("@prosopo/util/node");
+const cors = require("cors");
+const express = require("express");
+const rateLimit = require("express-rate-limit");
+const createApiAdminRoutesProvider = require("./admin/createApiAdminRoutesProvider.cjs");
+const block = require("./block.cjs");
+const captcha = require("./captcha.cjs");
+const domainMiddleware = require("./domainMiddleware.cjs");
+const headerCheckMiddleware = require("./headerCheckMiddleware.cjs");
+const ignoreMiddleware = require("./ignoreMiddleware.cjs");
+const ipInfoMiddleware = require("./ipInfoMiddleware.cjs");
+const ja4Middleware = require("./ja4Middleware.cjs");
+const _public = require("./public.cjs");
+const robotsMiddleware = require("./robotsMiddleware.cjs");
+const verify = require("./verify.cjs");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const __dirname$1 = path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("api/startProviderApi.cjs", document.baseURI).href));
+const certPath = path.resolve(__dirname$1, "../../../../certs");
+const keyPath = path.join(certPath, "server.key");
+const crtPath = path.join(certPath, "server.crt");
+const isTlsAvailable = () => {
+  return fs.existsSync(keyPath) && fs.existsSync(crtPath);
+};
+const getClientApiPathsExpectingProsopoHeaders = () => {
+  const paths = Object.values(types.ClientApiPaths).filter(
+    (path2) => path2.indexOf("verify") === -1 && path2.indexOf("spam") === -1
+  );
+  return paths;
+};
+const getUserFromJWT = (req) => {
+  try {
+    const authHeader = req.headers.Authorization || req.headers.authorization;
+    if (!authHeader || typeof authHeader !== "string") {
+      return void 0;
+    }
+    const jwt = authHeader.replace("Bearer ", "");
+    if (!jwt) {
+      return void 0;
+    }
+    const parts = jwt.split(".");
+    if (parts.length !== 3 || !parts[1]) {
+      return void 0;
+    }
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    return payload.sub;
+  } catch (e) {
+    return void 0;
+  }
+};
+async function startProviderApi(env, admin = false, port) {
+  env.logger.info(() => ({ msg: "Starting Prosopo API" }));
+  const providerCacheDir = path.resolve("./provider-list-cache");
+  loadBalancer.setProviderLoader(async (environment) => {
+    if (environment === "development") {
+      const { loadBalancer: loadBalancer2 } = await import("@prosopo/load-balancer");
+      return loadBalancer2(environment);
+    }
+    const url = loadBalancer.getLoadBalancerUrl(environment);
+    const filePath = await node.cacheFile(
+      providerCacheDir,
+      url,
+      env.logger,
+      "provider-list-",
+      ".json"
+    );
+    const text = fs.readFileSync(filePath, "utf-8");
+    const providers = JSON.parse(text);
+    return loadBalancer.convertHostedProvider(providers);
+  });
+  const apiApp = express();
+  const apiPort = port || env.config.server?.port;
+  const apiEndpointAdapter = apiExpressRouter.createApiExpressDefaultEndpointAdapter(
+    logger.parseLogLevel(env.config.logLevel)
+  );
+  let apiRuleRoutesProvider;
+  let apiAdminRoutesProvider;
+  try {
+    apiRuleRoutesProvider = new api.AccessRuleApiRoutes(
+      env.getDb().getUserAccessRulesStorage(),
+      env.logger
+    );
+    apiAdminRoutesProvider = createApiAdminRoutesProvider.createApiAdminRoutesProvider(env);
+  } catch (err) {
+    env.logger.warn(() => ({
+      msg: "Skipping admin/access-rule routes; DB unavailable",
+      err
+    }));
+  }
+  const clientPathsExcludingVerify = getClientApiPathsExpectingProsopoHeaders();
+  env.logger.debug(() => ({
+    msg: "Adding headerCheckMiddleware",
+    paths: clientPathsExcludingVerify
+  }));
+  apiApp.set("trust proxy", 1);
+  apiApp.use(cors({ exposedHeaders: ["x-prosopo-meta"] }));
+  apiApp.use(express.json({ limit: "50mb" }));
+  apiApp.use(_public.publicRouter(env));
+  const isTestOrDevelopmentEnv = process.env.NODE_ENV === "test" || env.config.defaultEnvironment === "development";
+  if (!isTestOrDevelopmentEnv) {
+    const configRateLimits = env.config.rateLimits;
+    const rateLimits = {
+      ...configRateLimits,
+      ...api.getExpressApiRuleRateLimits()
+    };
+    const adminPaths = Object.values(types.AdminApiPaths);
+    for (const [path2, limit] of Object.entries(rateLimits)) {
+      const enumPath = path2;
+      if (adminPaths.includes(enumPath)) {
+        apiApp.use(
+          enumPath,
+          rateLimit({
+            ...limit,
+            keyGenerator: (req) => {
+              const user = getUserFromJWT(req);
+              return user || req.ip || "unknown";
+            }
+          })
+        );
+      } else if (path2 === types.ClientApiPaths.VerifyImageCaptchaSolutionDapp || path2 === types.ClientApiPaths.VerifyPowCaptchaSolution) {
+        apiApp.use(
+          enumPath,
+          rateLimit({
+            ...limit,
+            keyGenerator: (req) => {
+              const siteKey = req.headers["prosopo-site-key"];
+              return siteKey || req.ip || "unknown";
+            }
+          })
+        );
+      } else {
+        apiApp.use(enumPath, rateLimit(limit));
+      }
+    }
+  }
+  const i18Middleware = await locale.i18nMiddleware({});
+  apiApp.use(robotsMiddleware.robotsMiddleware());
+  apiApp.use(ignoreMiddleware.ignoreMiddleware());
+  apiApp.use(apiExpressRouter.requestLoggerMiddleware(env));
+  apiApp.use(i18Middleware);
+  apiApp.use(ja4Middleware.ja4Middleware(env));
+  apiApp.use(ipInfoMiddleware.ipInfoMiddleware(env));
+  apiApp.use(clientPathsExcludingVerify, headerCheckMiddleware.headerCheckMiddleware(env));
+  apiApp.use(verify.prosopoVerifyRouter(env));
+  env.logger.info(() => ({ msg: "Enabling admin auth middleware" }));
+  apiApp.use(
+    "/v1/prosopo/provider/admin",
+    apiExpressRouter.authMiddleware(env.pair, env.authAccount)
+  );
+  if (apiRuleRoutesProvider) {
+    const userAccessRuleRoutes = apiRuleRoutesProvider.getRoutes();
+    for (const userAccessRuleRoute in userAccessRuleRoutes) {
+      apiApp.use(
+        userAccessRuleRoute,
+        apiExpressRouter.authMiddleware(env.pair, env.authAccount)
+      );
+    }
+    apiApp.use(
+      apiExpressRouter.apiExpressRouterFactory.createRouter(
+        apiRuleRoutesProvider,
+        apiEndpointAdapter
+      )
+    );
+  }
+  if (apiAdminRoutesProvider) {
+    apiApp.use(
+      apiExpressRouter.apiExpressRouterFactory.createRouter(
+        apiAdminRoutesProvider,
+        // unlike the default one, it should have errorStatusCode as 400
+        apiExpressRouter.createApiExpressDefaultEndpointAdapter(
+          logger.parseLogLevel(env.config.logLevel),
+          400
+        )
+      )
+    );
+  }
+  apiApp.use(block.blockMiddleware(env));
+  apiApp.use("/v1/prosopo/provider/client/", domainMiddleware.domainMiddleware(env));
+  apiApp.use(captcha.prosopoRouter(env));
+  const useTls = fs.existsSync(keyPath) && fs.existsSync(crtPath);
+  if (useTls) {
+    env.logger.info(() => ({ msg: "Starting Provider API with HTTPS" }));
+    const httpsOptions = {
+      key: fs.readFileSync(keyPath),
+      cert: fs.readFileSync(crtPath)
+    };
+    const httpsServer = https.createServer(httpsOptions, apiApp);
+    return httpsServer.listen(apiPort, () => {
+      env.logger.info(() => ({
+        data: { apiPort, protocol: "https" },
+        msg: "Prosopo app listening with HTTPS"
+      }));
+    });
+  }
+  return apiApp.listen(apiPort, () => {
+    env.logger.info(() => ({
+      data: { apiPort },
+      msg: "Prosopo app listening"
+    }));
+  });
+}
+exports.getClientApiPathsExpectingProsopoHeaders = getClientApiPathsExpectingProsopoHeaders;
+exports.getUserFromJWT = getUserFromJWT;
+exports.isTlsAvailable = isTlsAvailable;
+exports.startProviderApi = startProviderApi;

package/dist/cjs/api/testSiteKey.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const isReservedTestSiteKey = (siteKey) => types.getTestSiteKeyMode(siteKey) !== null;
+const resolveTestSiteKeyVerdict = (siteKey, logger) => {
+  const mode = types.getTestSiteKeyMode(siteKey);
+  if (mode === null) {
+    return null;
+  }
+  logger?.warn(() => ({
+    msg: "Reserved TEST site key - forcing deterministic captcha verdict",
+    data: { siteKey, mode }
+  }));
+  return mode === types.TestSiteKeyMode.Pass;
+};
+exports.isReservedTestSiteKey = isReservedTestSiteKey;
+exports.resolveTestSiteKeyVerdict = resolveTestSiteKeyVerdict;

package/dist/cjs/api/verify.cjs

@@ -7,9 +7,19 @@ const utilCrypto = require("@prosopo/util-crypto");
 const express = require("express");
 const tasks = require("../tasks/tasks.cjs");
 const apiToggleMaintenanceModeEndpoint = require("./admin/apiToggleMaintenanceModeEndpoint.cjs");
+const testSiteKey = require("./testSiteKey.cjs");
 function prosopoVerifyRouter(env) {
   const router = express.Router();
-  const userAccessRulesStorage = env.getDb().getUserAccessRulesStorage();
+  let userAccessRulesStorage;
+  try {
+    userAccessRulesStorage = env.getDb().getUserAccessRulesStorage();
+  } catch (err) {
+    env.logger.warn(() => ({
+      msg: "User access rules storage unavailable; verify endpoints will skip access-policy checks",
+      err
+    }));
+    userAccessRulesStorage = void 0;
+  }
   router.post(
     types.ClientApiPaths.VerifyImageCaptchaSolutionDapp,
     async (req, res, next) => {
@@ -36,9 +46,17 @@ function prosopoVerifyRouter(env) {
           })
         );
       }
-      const { dappSignature, token, ip, maxVerifiedTime } = parsed;
+      const { dappSignature, token, ip, maxVerifiedTime, email } = parsed;
       try {
         const { user, dapp, timestamp, commitmentId } = types.decodeProcaptchaOutput(token);
+        const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
+        if (testVerdict !== null) {
+          const verificationResponse2 = {
+            status: "ok",
+            verified: testVerdict
+          };
+          return res.json(verificationResponse2);
+        }
         utilCrypto.validateAddress(dapp, false, 42);
         utilCrypto.validateAddress(user, false, 42);
         const clientRecord = await tasks$1.db.getClientRecord(dapp);
@@ -61,7 +79,13 @@ function prosopoVerifyRouter(env) {
           maxVerifiedTime,
           ip,
           clientRecord.settings.disallowWebView,
-          clientRecord.settings.contextAware?.enabled
+          clientRecord.settings.contextAware?.enabled,
+          userAccessRulesStorage,
+          email,
+          clientRecord.settings.spamEmailDomainCheckEnabled,
+          clientRecord.settings.spamFilter,
+          clientRecord.settings.trafficFilter,
+          clientRecord.settings.storeMetadata
         );
         req.logger.debug(() => ({ data: { response } }));
         const verificationResponse = tasks$1.imgCaptchaManager.getVerificationResponse(
@@ -69,7 +93,8 @@ function prosopoVerifyRouter(env) {
           clientRecord,
           req.i18n.t,
           response[types.ApiParams.score],
-          response[types.ApiParams.commitmentId]
+          response[types.ApiParams.commitmentId],
+          response[types.ApiParams.status]
         );
         res.json(verificationResponse);
       } catch (err) {
@@ -111,8 +136,16 @@ function prosopoVerifyRouter(env) {
         );
       }
       try {
-        const { token, dappSignature, verifiedTimeout, ip } = parsed;
+        const { token, dappSignature, verifiedTimeout, ip, email } = parsed;
         const { dapp, user, timestamp, challenge } = types.decodeProcaptchaOutput(token);
+        const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
+        if (testVerdict !== null) {
+          const verificationResponse2 = {
+            status: "ok",
+            verified: testVerdict
+          };
+          return res.json(verificationResponse2);
+        }
         utilCrypto.validateAddress(dapp, false, 42);
         utilCrypto.validateAddress(user, false, 42);
         const clientRecord = await tasks$1.db.getClientRecord(dapp);
@@ -134,15 +167,114 @@ function prosopoVerifyRouter(env) {
         }
         const dappPair = env.keyring.addFromAddress(dapp);
         apiExpressRouter.verifySignature(dappSignature, timestamp.toString(), dappPair);
-        const { verified, score } = await tasks$1.powCaptchaManager.serverVerifyPowCaptchaSolution(
+        const { verified, score, reason } = await tasks$1.powCaptchaManager.serverVerifyPowCaptchaSolution(
           dapp,
           challenge,
           verifiedTimeout,
           env,
           ip,
-          userAccessRulesStorage
+          userAccessRulesStorage,
+          email,
+          clientRecord.settings.spamEmailDomainCheckEnabled,
+          clientRecord.settings.spamFilter,
+          clientRecord.settings.trafficFilter,
+          clientRecord.settings.storeMetadata
         );
         const verificationResponse = tasks$1.powCaptchaManager.getVerificationResponse(
+          verified,
+          clientRecord,
+          req.i18n.t,
+          score,
+          reason
+        );
+        return res.json(verificationResponse);
+      } catch (err) {
+        req.logger.error(() => ({
+          msg: "Error in verifyPowCaptchaSolution",
+          err,
+          data: { body: req.body }
+        }));
+        return next(
+          new common.ProsopoApiError("API.BAD_REQUEST", {
+            context: { code: 500, error: err },
+            i18n: req.i18n,
+            logger: req.logger
+          })
+        );
+      }
+    }
+  );
+  router.post(
+    types.ClientApiPaths.VerifyPuzzleCaptchaSolution,
+    async (req, res, next) => {
+      const tasks$1 = new tasks.Tasks(env, req.logger);
+      if (apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
+        req.logger.info(() => ({
+          msg: "Maintenance mode active - returning verified for puzzle captcha verification"
+        }));
+        const verificationResponse = {
+          status: "ok",
+          verified: true
+        };
+        return res.json(verificationResponse);
+      }
+      let parsed;
+      try {
+        parsed = types.ServerPuzzleCaptchaVerifyRequestBody.parse(req.body);
+      } catch (err) {
+        return next(
+          new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+            context: { code: 400, error: err, body: req.body },
+            i18n: req.i18n,
+            logger: req.logger
+          })
+        );
+      }
+      try {
+        const { token, dappSignature, verifiedTimeout, ip, email } = parsed;
+        const { dapp, user, timestamp, challenge } = types.decodeProcaptchaOutput(token);
+        const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
+        if (testVerdict !== null) {
+          const verificationResponse2 = {
+            status: "ok",
+            verified: testVerdict
+          };
+          return res.json(verificationResponse2);
+        }
+        utilCrypto.validateAddress(dapp, false, 42);
+        utilCrypto.validateAddress(user, false, 42);
+        const clientRecord = await tasks$1.db.getClientRecord(dapp);
+        if (!clientRecord) {
+          return next(
+            new common.ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
+              context: { code: 400, siteKey: dapp },
+              i18n: req.i18n,
+              logger: req.logger
+            })
+          );
+        }
+        if (!challenge) {
+          const unverifiedResponse = {
+            status: req.i18n.t("API.USER_NOT_VERIFIED"),
+            [types.ApiParams.verified]: false
+          };
+          return res.json(unverifiedResponse);
+        }
+        const dappPair = env.keyring.addFromAddress(dapp);
+        apiExpressRouter.verifySignature(dappSignature, timestamp.toString(), dappPair);
+        const { verified, score } = await tasks$1.puzzleCaptchaManager.serverVerifyPuzzleCaptchaSolution(
+          dapp,
+          challenge,
+          verifiedTimeout,
+          env,
+          ip,
+          userAccessRulesStorage,
+          email,
+          clientRecord.settings.spamEmailDomainCheckEnabled,
+          clientRecord.settings.trafficFilter,
+          clientRecord.settings.storeMetadata
+        );
+        const verificationResponse = tasks$1.puzzleCaptchaManager.getVerificationResponse(
           verified,
           clientRecord,
           req.i18n.t,
@@ -150,8 +282,11 @@ function prosopoVerifyRouter(env) {
         );
         return res.json(verificationResponse);
       } catch (err) {
-        console.error("\nError in verifyPowCaptchaSolution:", err);
-        req.logger.error(() => ({ err, data: { body: req.body } }));
+        req.logger.error(() => ({
+          msg: "Error in verifyPuzzleCaptchaSolution",
+          err,
+          data: { body: req.body }
+        }));
         return next(
           new common.ProsopoApiError("API.BAD_REQUEST", {
             context: { code: 500, error: err },

package/dist/cjs/compositeIpAddress.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const typesDatabase = require("@prosopo/types-database");
+const types = require("@prosopo/types");
 const util = require("@prosopo/util");
 const ipAddress = require("ip-address");
 const V6_SHIFT = 64n;
@@ -12,7 +12,7 @@ const getCompositeIpAddress = (ip) => {
   } catch (e) {
     return {
       lower: 0n,
-      type: typesDatabase.IpAddressType.v4
+      type: types.IpAddressType.v4
     };
   }
   return getCompositeFromIpAddress(ipAddress2);
@@ -22,21 +22,21 @@ const getCompositeFromIpAddress = (ipAddress$1) => {
   if (ipAddress$1 instanceof ipAddress.Address4) {
     return {
       lower: numericIp,
-      type: typesDatabase.IpAddressType.v4
+      type: types.IpAddressType.v4
     };
   }
   ipAddress$1;
   return {
     lower: numericIp & v6_LOWER_MASK,
     upper: numericIp >> V6_SHIFT,
-    type: typesDatabase.IpAddressType.v6
+    type: types.IpAddressType.v6
   };
 };
 const getIpAddressFromComposite = (compositeIpAddress) => {
   switch (compositeIpAddress.type) {
-    case typesDatabase.IpAddressType.v4:
+    case types.IpAddressType.v4:
       return ipAddress.Address4.fromBigInt(getBigInt(compositeIpAddress.lower));
-    case typesDatabase.IpAddressType.v6:
+    case types.IpAddressType.v6:
       return ipAddress.Address6.fromBigInt(
         getBigInt(compositeIpAddress.upper) << V6_SHIFT | getBigInt(compositeIpAddress.lower) & v6_LOWER_MASK
       );

package/dist/cjs/index.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./tasks/index.cjs");
+const updateSpamEmailDomains = require("./tasks/spam/updateSpamEmailDomains.cjs");
 const util = require("./util.cjs");
 const block = require("./api/block.cjs");
 const captcha = require("./api/captcha.cjs");
@@ -8,9 +9,11 @@ const verify = require("./api/verify.cjs");
 const ja4Middleware = require("./api/ja4Middleware.cjs");
 const _public = require("./api/public.cjs");
 const domainMiddleware = require("./api/domainMiddleware.cjs");
+const startProviderApi = require("./api/startProviderApi.cjs");
 const captchaScheduler = require("./schedulers/captchaScheduler.cjs");
 const getClientList = require("./schedulers/getClientList.cjs");
 const setClientEntropy = require("./schedulers/setClientEntropy.cjs");
+const updateSpamEmailDomains$1 = require("./schedulers/updateSpamEmailDomains.cjs");
 const headerCheckMiddleware = require("./api/headerCheckMiddleware.cjs");
 const createApiAdminRoutesProvider = require("./api/admin/createApiAdminRoutesProvider.cjs");
 const ignoreMiddleware = require("./api/ignoreMiddleware.cjs");
@@ -18,7 +21,10 @@ const robotsMiddleware = require("./api/robotsMiddleware.cjs");
 const compositeIpAddress = require("./compositeIpAddress.cjs");
 const ipComparison = require("./services/ipComparison.cjs");
 const blacklistRequestInspector = require("./api/blacklistRequestInspector.cjs");
+require("./tasks/frictionless/frictionlessTasks.cjs");
+const types = require("@prosopo/types");
 const tasks = require("./tasks/tasks.cjs");
+exports.updateSpamEmailDomains = updateSpamEmailDomains.updateSpamEmailDomains;
 exports.checkIfTaskIsRunning = util.checkIfTaskIsRunning;
 exports.deepValidateIpAddress = util.deepValidateIpAddress;
 exports.encodeStringAddress = util.encodeStringAddress;
@@ -35,9 +41,14 @@ exports.getJA4 = ja4Middleware.getJA4;
 exports.ja4Middleware = ja4Middleware.ja4Middleware;
 exports.publicRouter = _public.publicRouter;
 exports.domainMiddleware = domainMiddleware.domainMiddleware;
+exports.getClientApiPathsExpectingProsopoHeaders = startProviderApi.getClientApiPathsExpectingProsopoHeaders;
+exports.getUserFromJWT = startProviderApi.getUserFromJWT;
+exports.isTlsAvailable = startProviderApi.isTlsAvailable;
+exports.startProviderApi = startProviderApi.startProviderApi;
 exports.storeCaptchasExternally = captchaScheduler.storeCaptchasExternally;
 exports.getClientList = getClientList.getClientList;
 exports.setClientEntropy = setClientEntropy.setClientEntropy;
+exports.updateSpamEmailDomainsScheduler = updateSpamEmailDomains$1.updateSpamEmailDomainsScheduler;
 exports.headerCheckMiddleware = headerCheckMiddleware.headerCheckMiddleware;
 exports.createApiAdminRoutesProvider = createApiAdminRoutesProvider.createApiAdminRoutesProvider;
 exports.ignoreMiddleware = ignoreMiddleware.ignoreMiddleware;
@@ -48,4 +59,8 @@ exports.compareIPs = ipComparison.compareIPs;
 exports.BlacklistRequestInspector = blacklistRequestInspector.BlacklistRequestInspector;
 exports.getPrioritisedAccessRule = blacklistRequestInspector.getPrioritisedAccessRule;
 exports.getRequestUserScope = blacklistRequestInspector.getRequestUserScope;
+Object.defineProperty(exports, "FrictionlessReason", {
+  enumerable: true,
+  get: () => types.FrictionlessReason
+});
 exports.Tasks = tasks.Tasks;

package/dist/cjs/rules/lang.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const checkLangRules = (config, acceptLanguage) => {
   const lConfig = config.lRules;
   let lScore = 0;
-  if (lConfig) {
+  if (lConfig && acceptLanguage) {
     const languages = acceptLanguage.split(",").map((lang) => lang.trim().split(";")[0]);
     for (const lang of languages) {
       if (lang && lConfig[lang]) {