@prosopo/provider 2.1.5 → 2.1.6

package/dist/cjs/api/captcha.cjs

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const address = require("@polkadot/util-crypto/address");
+const common = require("@prosopo/common");
+const datasets = require("@prosopo/datasets");
+const types = require("@prosopo/types");
+const util = require("@prosopo/util");
+const express = require("express");
+const uuid = require("uuid");
+const getBotScore = require("../tasks/detection/getBotScore.cjs");
+const tasks = require("../tasks/tasks.cjs");
+const errorHandler = require("./errorHandler.cjs");
+const NO_IP_ADDRESS = "NO_IP_ADDRESS";
+const DEFAULT_FRICTIONLESS_THRESHOLD = 0.5;
+function prosopoRouter(env) {
+  const router = express.Router();
+  const tasks$1 = new tasks.Tasks(env);
+  const GetImageCaptchaChallengePath = `${types.ApiPaths.GetImageCaptchaChallenge}/:${types.ApiParams.datasetId}/:${types.ApiParams.user}/:${types.ApiParams.dapp}`;
+  router.get(GetImageCaptchaChallengePath, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.CaptchaRequestBody.parse(req.params);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+          context: { code: 400, error: err }
+        })
+      );
+    }
+    const { datasetId, user, dapp } = parsed;
+    try {
+      address.validateAddress(dapp, false, 42);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("API.INVALID_SITE_KEY", {
+          context: { code: 400, error: err, siteKey: dapp }
+        })
+      );
+    }
+    try {
+      address.validateAddress(dapp, false, 42);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("API.INVALID_SITE_KEY", {
+          context: { code: 400, error: err, siteKey: dapp }
+        })
+      );
+    }
+    try {
+      address.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 }
+          })
+        );
+      }
+      const taskData = await tasks$1.imgCaptchaManager.getRandomCaptchasAndRequestHash(
+        datasetId,
+        user,
+        req.ip || NO_IP_ADDRESS,
+        util.flatten(req.headers, ",")
+      );
+      const captchaResponse = {
+        [types.ApiParams.status]: "ok",
+        [types.ApiParams.captchas]: taskData.captchas.map((captcha) => ({
+          ...captcha,
+          items: captcha.items.map(
+            (item) => datasets.parseCaptchaAssets(item, env.assetsResolver)
+          )
+        })),
+        [types.ApiParams.requestHash]: taskData.requestHash,
+        [types.ApiParams.timestamp]: taskData.timestamp.toString(),
+        [types.ApiParams.signature]: {
+          [types.ApiParams.provider]: {
+            [types.ApiParams.requestHash]: taskData.signedRequestHash
+          }
+        }
+      };
+      return res.json(captchaResponse);
+    } catch (err) {
+      tasks$1.logger.error({ err, params: req.params });
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: {
+            error: err,
+            code: 500,
+            params: req.params
+          }
+        })
+      );
+    }
+  });
+  router.post(types.ApiPaths.SubmitImageCaptchaSolution, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.CaptchaSolutionBody.parse(req.body);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+          context: { code: 400, error: err, body: req.body }
+        })
+      );
+    }
+    const { user, dapp } = parsed;
+    try {
+      address.validateAddress(dapp, false, 42);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("API.INVALID_SITE_KEY", {
+          context: { code: 400, error: err, siteKey: dapp }
+        })
+      );
+    }
+    try {
+      address.validateAddress(user, false, 42);
+      const clientRecord = await tasks$1.db.getClientRecord(parsed.dapp);
+      if (!clientRecord) {
+        return next(
+          new common.ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
+            context: { code: 400, siteKey: dapp }
+          })
+        );
+      }
+      const result = await tasks$1.imgCaptchaManager.dappUserSolution(
+        user,
+        dapp,
+        parsed[types.ApiParams.requestHash],
+        parsed[types.ApiParams.captchas],
+        parsed[types.ApiParams.signature].user.timestamp,
+        Number.parseInt(parsed[types.ApiParams.timestamp]),
+        parsed[types.ApiParams.signature].provider.requestHash,
+        req.ip || NO_IP_ADDRESS,
+        util.flatten(req.headers, ",")
+      );
+      const returnValue = {
+        status: req.i18n.t(
+          result.verified ? "API.CAPTCHA_PASSED" : "API.CAPTCHA_FAILED"
+        ),
+        ...result
+      };
+      return res.json(returnValue);
+    } catch (err) {
+      tasks$1.logger.error({ err, body: req.body });
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 500, siteKey: req.body.dapp }
+        })
+      );
+    }
+  });
+  router.post(types.ApiPaths.GetPowCaptchaChallenge, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.GetPowCaptchaChallengeRequestBody.parse(req.body);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+          context: { code: 400, error: err }
+        })
+      );
+    }
+    const { user, dapp, sessionId } = parsed;
+    try {
+      address.validateAddress(dapp, false, 42);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("API.INVALID_SITE_KEY", {
+          context: { code: 400, error: err, siteKey: dapp }
+        })
+      );
+    }
+    try {
+      address.validateAddress(user, false, 42);
+      const clientSettings = await tasks$1.db.getClientRecord(dapp);
+      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 }
+          })
+        );
+      }
+      if (sessionId) {
+        const sessionRecord = await tasks$1.db.checkAndRemoveSession(sessionId);
+        if (!sessionRecord) {
+          return next(
+            new common.ProsopoApiError("API.BAD_REQUEST", {
+              context: { error: "Session ID not found", code: 400 }
+            })
+          );
+        }
+      } else if (!(clientSettings?.settings?.captchaType === "pow")) {
+        return next(
+          new common.ProsopoApiError("API.INCORRECT_CAPTCHA_TYPE", {
+            context: { code: 400, siteKey: dapp }
+          })
+        );
+      }
+      const origin = req.headers.origin;
+      if (!origin) {
+        return next(
+          new common.ProsopoApiError("API.BAD_REQUEST", {
+            context: { error: "Origin header not found", code: 400 }
+          })
+        );
+      }
+      const challenge = await tasks$1.powCaptchaManager.getPowCaptchaChallenge(
+        user,
+        dapp,
+        origin,
+        clientSettings?.settings?.powDifficulty
+      );
+      await tasks$1.db.storePowCaptchaRecord(
+        challenge.challenge,
+        {
+          requestedAtTimestamp: challenge.requestedAtTimestamp,
+          userAccount: user,
+          dappAccount: dapp
+        },
+        challenge.difficulty,
+        challenge.providerSignature,
+        req.ip || NO_IP_ADDRESS,
+        util.flatten(req.headers, ",")
+      );
+      const getPowCaptchaResponse = {
+        [types.ApiParams.status]: "ok",
+        [types.ApiParams.challenge]: challenge.challenge,
+        [types.ApiParams.difficulty]: challenge.difficulty,
+        [types.ApiParams.timestamp]: challenge.requestedAtTimestamp.toString(),
+        [types.ApiParams.signature]: {
+          [types.ApiParams.provider]: {
+            [types.ApiParams.challenge]: challenge.providerSignature
+          }
+        }
+      };
+      return res.json(getPowCaptchaResponse);
+    } catch (err) {
+      tasks$1.logger.error({ err, body: req.body });
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: {
+            code: 500,
+            siteKey: req.body.dapp
+          }
+        })
+      );
+    }
+  });
+  router.post(types.ApiPaths.SubmitPowCaptchaSolution, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.SubmitPowCaptchaSolutionBody.parse(req.body);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+          context: { code: 400, error: err, body: req.body }
+        })
+      );
+    }
+    const {
+      challenge,
+      difficulty,
+      signature,
+      nonce,
+      verifiedTimeout,
+      dapp,
+      user
+    } = parsed;
+    try {
+      address.validateAddress(dapp, false, 42);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("API.INVALID_SITE_KEY", {
+          context: { code: 400, error: err, siteKey: dapp }
+        })
+      );
+    }
+    try {
+      address.validateAddress(user, false, 42);
+      address.validateAddress(dapp, 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 }
+          })
+        );
+      }
+      const verified = await tasks$1.powCaptchaManager.verifyPowCaptchaSolution(
+        challenge,
+        difficulty,
+        signature.provider.challenge,
+        nonce,
+        verifiedTimeout,
+        signature.user.timestamp,
+        req.ip || NO_IP_ADDRESS,
+        util.flatten(req.headers, ",")
+      );
+      const response = { status: "ok", verified };
+      return res.json(response);
+    } catch (err) {
+      tasks$1.logger.error({ err, body: req.body });
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: {
+            code: 500,
+            siteKey: req.body.dapp
+          }
+        })
+      );
+    }
+  });
+  router.post(
+    types.ApiPaths.GetFrictionlessCaptchaChallenge,
+    async (req, res, next) => {
+      try {
+        const { token, dapp } = types.GetFrictionlessCaptchaChallengeRequestBody.parse(req.body);
+        const botScore = await getBotScore.getBotScore(token);
+        const clientConfig = await tasks$1.db.getClientRecord(dapp);
+        const botThreshold = clientConfig?.settings?.frictionlessThreshold || DEFAULT_FRICTIONLESS_THRESHOLD;
+        if (Number(botScore) > botThreshold) {
+          const response2 = {
+            [types.ApiParams.captchaType]: "image",
+            [types.ApiParams.status]: "ok"
+          };
+          return res.json(response2);
+        }
+        const sessionRecord = {
+          sessionId: uuid.v4(),
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        await tasks$1.db.storeSessionRecord(sessionRecord);
+        const response = {
+          [types.ApiParams.captchaType]: "pow",
+          [types.ApiParams.sessionId]: sessionRecord.sessionId,
+          [types.ApiParams.status]: "ok"
+        };
+        return res.json(response);
+      } catch (err) {
+        console.error("Error in frictionless captcha challenge:", err);
+        tasks$1.logger.error(err);
+        return next(
+          new common.ProsopoApiError("API.BAD_REQUEST", {
+            context: { code: 400, error: err }
+          })
+        );
+      }
+    }
+  );
+  router.post(types.ApiPaths.UpdateProviderClients, async (req, res, next) => {
+    try {
+      await tasks$1.clientTaskManager.getClientList();
+      return res.json({ message: "Provider updated" });
+    } catch (err) {
+      tasks$1.logger.error(err);
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
+    }
+  });
+  router.get(types.ApiPaths.GetProviderDetails, async (req, res, next) => {
+    try {
+      return res.json({ version: util.version, ...{ message: "Provider online" } });
+    } catch (err) {
+      tasks$1.logger.error({ err, params: req.params });
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 500 }
+        })
+      );
+    }
+  });
+  router.use(errorHandler.handleErrors);
+  return router;
+}
+exports.prosopoRouter = prosopoRouter;

package/dist/cjs/api/errorHandler.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const locale = require("@prosopo/locale");
+const zod = require("zod");
+const handleErrors = (err, request, response, next) => {
+  const { code, statusMessage, jsonError } = unwrapError(err);
+  response.statusMessage = statusMessage;
+  response.set("content-type", "application/json");
+  response.status(code);
+  response.send({ error: jsonError });
+  response.end();
+};
+const unwrapError = (err) => {
+  const code = "code" in err ? err.code : 400;
+  let message = err.message;
+  let jsonError = { code, message };
+  let statusMessage = err.message;
+  jsonError.message = message;
+  while (err instanceof common.ProsopoBaseError && err.context) {
+    jsonError.code = err.context.translationKey || err.translationKey || jsonError.code;
+    jsonError.message = err.message;
+    if (err.context.error) {
+      err = err.context.error;
+    } else {
+      break;
+    }
+  }
+  if (err instanceof zod.ZodError) {
+    message = locale.i18n.t("CAPTCHA.PARSE_ERROR");
+    statusMessage = message;
+    if (typeof err.message === "object") {
+      jsonError = err.message;
+    } else {
+      jsonError.message = JSON.parse(err.message);
+    }
+  }
+  jsonError.code = jsonError.code || code;
+  return { code, statusMessage, jsonError };
+};
+exports.handleErrors = handleErrors;
+exports.unwrapError = unwrapError;

package/dist/cjs/api/verify.cjs

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const address = require("@polkadot/util-crypto/address");
+const common = require("@prosopo/common");
+const types = require("@prosopo/types");
+const express = require("express");
+const tasks = require("../tasks/tasks.cjs");
+const authMiddleware = require("./authMiddleware.cjs");
+const errorHandler = require("./errorHandler.cjs");
+function prosopoVerifyRouter(env) {
+  const router = express.Router();
+  const tasks$1 = new tasks.Tasks(env);
+  router.post(
+    types.ApiPaths.VerifyImageCaptchaSolutionDapp,
+    async (req, res, next) => {
+      let parsed;
+      try {
+        parsed = types.VerifySolutionBody.parse(req.body);
+      } catch (err) {
+        return next(
+          new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+            context: { code: 400, error: err, body: req.body }
+          })
+        );
+      }
+      const { dappSignature, token } = parsed;
+      try {
+        const { user, dapp, timestamp, commitmentId } = types.decodeProcaptchaOutput(token);
+        address.validateAddress(dapp, false, 42);
+        address.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 }
+            })
+          );
+        }
+        const keyPair = env.keyring.addFromAddress(dapp);
+        authMiddleware.verifySignature(dappSignature, timestamp.toString(), keyPair);
+        const response = await tasks$1.imgCaptchaManager.verifyImageCaptchaSolution(
+          user,
+          dapp,
+          commitmentId,
+          parsed.maxVerifiedTime
+        );
+        const verificationResponse = {
+          [types.ApiParams.status]: req.t(response.status),
+          [types.ApiParams.verified]: response[types.ApiParams.verified],
+          ...response.commitmentId && {
+            [types.ApiParams.commitmentId]: response.commitmentId
+          }
+        };
+        res.json(verificationResponse);
+      } catch (err) {
+        tasks$1.logger.error({ err, body: req.body });
+        return next(
+          new common.ProsopoApiError("API.BAD_REQUEST", {
+            context: { code: 500 }
+          })
+        );
+      }
+    }
+  );
+  router.post(types.ApiPaths.VerifyPowCaptchaSolution, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.ServerPowCaptchaVerifyRequestBody.parse(req.body);
+    } catch (err) {
+      return next(
+        new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+          context: { code: 400, error: err, body: req.body }
+        })
+      );
+    }
+    try {
+      const { token, dappSignature, verifiedTimeout } = parsed;
+      const { dapp, user, timestamp, challenge } = types.decodeProcaptchaOutput(token);
+      address.validateAddress(dapp, false, 42);
+      address.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 }
+          })
+        );
+      }
+      if (!challenge) {
+        const unverifiedResponse = {
+          status: req.t("API.USER_NOT_VERIFIED"),
+          [types.ApiParams.verified]: false
+        };
+        return res.json(unverifiedResponse);
+      }
+      const dappPair = env.keyring.addFromAddress(dapp);
+      authMiddleware.verifySignature(dappSignature, timestamp.toString(), dappPair);
+      const approved = await tasks$1.powCaptchaManager.serverVerifyPowCaptchaSolution(
+        dapp,
+        challenge,
+        verifiedTimeout
+      );
+      const verificationResponse = {
+        status: req.t(approved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"),
+        [types.ApiParams.verified]: approved
+      };
+      return res.json(verificationResponse);
+    } catch (err) {
+      tasks$1.logger.error({ err, body: req.body });
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 500 }
+        })
+      );
+    }
+  });
+  router.use(errorHandler.handleErrors);
+  return router;
+}
+exports.prosopoVerifyRouter = prosopoVerifyRouter;

package/dist/cjs/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./tasks/index.cjs");
+const util = require("./util.cjs");
+const captcha = require("./api/captcha.cjs");
+const verify = require("./api/verify.cjs");
+const admin = require("./api/admin.cjs");
+const errorHandler = require("./api/errorHandler.cjs");
+const authMiddleware = require("./api/authMiddleware.cjs");
+const captchaScheduler = require("./schedulers/captchaScheduler.cjs");
+const getClientList = require("./schedulers/getClientList.cjs");
+const tasks = require("./tasks/tasks.cjs");
+exports.checkIfTaskIsRunning = util.checkIfTaskIsRunning;
+exports.encodeStringAddress = util.encodeStringAddress;
+exports.shuffleArray = util.shuffleArray;
+exports.prosopoRouter = captcha.prosopoRouter;
+exports.prosopoVerifyRouter = verify.prosopoVerifyRouter;
+exports.prosopoAdminRouter = admin.prosopoAdminRouter;
+exports.handleErrors = errorHandler.handleErrors;
+exports.unwrapError = errorHandler.unwrapError;
+exports.authMiddleware = authMiddleware.authMiddleware;
+exports.verifySignature = authMiddleware.verifySignature;
+exports.storeCaptchasExternally = captchaScheduler.storeCaptchasExternally;
+exports.getClientList = getClientList.getClientList;
+exports.Tasks = tasks.Tasks;

package/dist/cjs/schedulers/captchaScheduler.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const env = require("@prosopo/env");
+const types = require("@prosopo/types");
+const cron = require("cron");
+const tasks = require("../tasks/tasks.cjs");
+const util = require("../util.cjs");
+async function storeCaptchasExternally(pair, config) {
+  const env$1 = new env.ProviderEnvironment(config, pair);
+  await env$1.isReady();
+  const tasks$1 = new tasks.Tasks(env$1);
+  const defaultSchedule = "0 * * * *";
+  const cronSchedule = config.scheduledTasks?.captchaScheduler ? config.scheduledTasks.captchaScheduler.schedule ? config.scheduledTasks.captchaScheduler.schedule : defaultSchedule : defaultSchedule;
+  const job = new cron.CronJob(cronSchedule, async () => {
+    const taskRunning = await util.checkIfTaskIsRunning(
+      types.ScheduledTaskNames.StoreCommitmentsExternal,
+      env$1.getDb()
+    );
+    env$1.logger.info(
+      `${types.ScheduledTaskNames.StoreCommitmentsExternal} task running: ${taskRunning}`
+    );
+    if (!taskRunning) {
+      env$1.logger.info(
+        `${types.ScheduledTaskNames.StoreCommitmentsExternal} task....`
+      );
+      await tasks$1.clientTaskManager.storeCommitmentsExternal().catch((err) => {
+        env$1.logger.error(err);
+      });
+    }
+  });
+  job.start();
+}
+exports.storeCaptchasExternally = storeCaptchasExternally;

package/dist/cjs/schedulers/getClientList.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const env = require("@prosopo/env");
+const types = require("@prosopo/types");
+const cron = require("cron");
+const tasks = require("../tasks/tasks.cjs");
+const util = require("../util.cjs");
+async function getClientList(pair, config) {
+  const env$1 = new env.ProviderEnvironment(config, pair);
+  await env$1.isReady();
+  const tasks$1 = new tasks.Tasks(env$1);
+  const defaultSchedule = "0 * * * *";
+  const cronSchedule = config.scheduledTasks?.clientListScheduler ? config.scheduledTasks.clientListScheduler.schedule ? config.scheduledTasks.clientListScheduler.schedule : defaultSchedule : defaultSchedule;
+  const job = new cron.CronJob(cronSchedule, async () => {
+    const taskRunning = await util.checkIfTaskIsRunning(
+      types.ScheduledTaskNames.GetClientList,
+      env$1.getDb()
+    );
+    env$1.logger.info(
+      `${types.ScheduledTaskNames.GetClientList} task running: ${taskRunning}`
+    );
+    if (!taskRunning) {
+      env$1.logger.info(`${types.ScheduledTaskNames.GetClientList} task....`);
+      await tasks$1.clientTaskManager.getClientList().catch((err) => {
+        env$1.logger.error(err);
+      });
+    }
+  });
+  job.start();
+}
+exports.getClientList = getClientList;