@prosopo/provider 4.15.14 → 4.15.15

package/dist/cjs/api/verify.cjs

@@ -1,384 +1,343 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const api = require("@prosopo/api");
-const apiExpressRouter = require("@prosopo/api-express-router");
-const common = require("@prosopo/common");
-const types = require("@prosopo/types");
-const utilCrypto = require("@prosopo/util-crypto");
-const express = require("express");
-const tasks = require("../tasks/tasks.cjs");
-const apiToggleMaintenanceModeEndpoint = require("./admin/apiToggleMaintenanceModeEndpoint.cjs");
-const forwardVerify = require("./forwardVerify.cjs");
-const metrics = require("./metrics.cjs");
-const testSiteKey = require("./testSiteKey.cjs");
-const deriveVerifySource = (body) => {
-  if (apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) return "maintenance";
-  try {
-    const token = body?.token;
-    if (token) {
-      const { dapp } = types.decodeProcaptchaOutput(token);
-      if (testSiteKey.isReservedTestSiteKey(dapp)) return "test_key";
-    }
-  } catch {
-  }
-  return "real";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_metrics = require("./metrics.cjs");
+const require_tasks = require("../tasks/tasks.cjs");
+const require_apiToggleMaintenanceModeEndpoint = require("./admin/apiToggleMaintenanceModeEndpoint.cjs");
+const require_testSiteKey = require("./testSiteKey.cjs");
+const require_forwardVerify = require("./forwardVerify.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _prosopo_api_express_router = require("@prosopo/api-express-router");
+let express = require("express");
+express = require_runtime.__toESM(express, 1);
+let _prosopo_api = require("@prosopo/api");
+//#region src/api/verify.ts
+var deriveVerifySource = (body) => {
+	if (require_apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) return "maintenance";
+	try {
+		const token = body?.token;
+		if (token) {
+			const { dapp } = (0, _prosopo_types.decodeProcaptchaOutput)(token);
+			if (require_testSiteKey.isReservedTestSiteKey(dapp)) return "test_key";
+		}
+	} catch {}
+	return "real";
 };
-const VERIFY_PATH_TYPE = {
-  [types.ClientApiPaths.VerifyImageCaptchaSolutionDapp]: types.CaptchaType.image,
-  [types.ClientApiPaths.VerifyPowCaptchaSolution]: types.CaptchaType.pow,
-  [types.ClientApiPaths.VerifyPuzzleCaptchaSolution]: types.CaptchaType.puzzle
+var VERIFY_PATH_TYPE = {
+	[_prosopo_types.ClientApiPaths.VerifyImageCaptchaSolutionDapp]: _prosopo_types.CaptchaType.image,
+	[_prosopo_types.ClientApiPaths.VerifyPowCaptchaSolution]: _prosopo_types.CaptchaType.pow,
+	[_prosopo_types.ClientApiPaths.VerifyPuzzleCaptchaSolution]: _prosopo_types.CaptchaType.puzzle
 };
+/**
+* Returns a router connected to the database which can interact with the Proposo protocol
+*
+* @return {Router} - A middleware router that can interact with the Prosopo protocol
+* @param {Environment} env - The Prosopo environment
+*/
 function prosopoVerifyRouter(env) {
-  const router = express.Router();
-  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.use((req, res, next) => {
-    if (!metrics.metricsEnabled()) return next();
-    const type = VERIFY_PATH_TYPE[req.path];
-    if (!type) return next();
-    const originalJson = res.json.bind(res);
-    res.json = (body) => {
-      if (res.statusCode < 300) {
-        const verified = !!(body && typeof body === "object" && body.verified);
-        metrics.recordCaptchaVerify({
-          type,
-          verified,
-          source: deriveVerifySource(req.body)
-        });
-      }
-      return originalJson(body);
-    };
-    next();
-  });
-  router.post(
-    types.ClientApiPaths.VerifyImageCaptchaSolutionDapp,
-    async (req, res, next) => {
-      if (apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
-        req.logger.info(() => ({
-          msg: "Maintenance mode active - returning verified for image captcha verification"
-        }));
-        const verificationResponse = {
-          status: "ok",
-          verified: true
-        };
-        return res.json(verificationResponse);
-      }
-      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 },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-      const { dappSignature, token, ip, maxVerifiedTime, email } = parsed;
-      try {
-        const { user, dapp, timestamp, commitmentId, providerUrl } = types.decodeProcaptchaOutput(token);
-        const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
-        if (testVerdict !== null) {
-          const verificationResponse2 = {
-            status: "ok",
-            verified: testVerdict
-          };
-          return res.json(verificationResponse2);
-        }
-        const forwarded = await forwardVerify.forwardVerifyIfNotIssuer({
-          env,
-          logger: req.logger,
-          path: types.ClientApiPaths.VerifyImageCaptchaSolutionDapp,
-          providerUrl,
-          dapp,
-          user,
-          body: parsed,
-          alreadyForwarded: req.headers[api.VERIFY_FORWARDED_HEADER] !== void 0
-        });
-        if (forwarded) {
-          return res.json(forwarded);
-        }
-        const tasks$1 = new tasks.Tasks(env, req.logger);
-        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, user },
-              i18n: req.i18n,
-              logger: req.logger
-            })
-          );
-        }
-        const keyPair = env.keyring.addFromAddress(dapp);
-        apiExpressRouter.verifySignature(dappSignature, timestamp.toString(), keyPair);
-        const response = await tasks$1.imgCaptchaManager.verifyImageCaptchaSolution(
-          user,
-          dapp,
-          commitmentId,
-          env,
-          maxVerifiedTime,
-          ip,
-          clientRecord.settings.disallowWebView,
-          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(
-          response[types.ApiParams.verified],
-          clientRecord,
-          req.i18n.t,
-          response[types.ApiParams.score],
-          response[types.ApiParams.commitmentId],
-          response[types.ApiParams.status]
-        );
-        res.json(verificationResponse);
-      } catch (err) {
-        req.logger.error(() => ({
-          err,
-          msg: "Error in verifyImageCaptchaSolution",
-          data: { body: req.body }
-        }));
-        return next(
-          new common.ProsopoApiError("API.BAD_REQUEST", {
-            context: { code: 500, siteKey: req.body.dapp, user: req.body.user },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-    }
-  );
-  router.post(
-    types.ClientApiPaths.VerifyPowCaptchaSolution,
-    async (req, res, next) => {
-      if (apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
-        req.logger.info(() => ({
-          msg: "Maintenance mode active - returning verified for PoW captcha verification"
-        }));
-        const verificationResponse = {
-          status: "ok",
-          verified: true
-        };
-        return res.json(verificationResponse);
-      }
-      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 },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-      try {
-        const { token, dappSignature, ip, email } = parsed;
-        const { dapp, user, timestamp, challenge, providerUrl } = types.decodeProcaptchaOutput(token);
-        const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
-        if (testVerdict !== null) {
-          const verificationResponse2 = {
-            status: "ok",
-            verified: testVerdict
-          };
-          return res.json(verificationResponse2);
-        }
-        const forwarded = await forwardVerify.forwardVerifyIfNotIssuer({
-          env,
-          logger: req.logger,
-          path: types.ClientApiPaths.VerifyPowCaptchaSolution,
-          providerUrl,
-          dapp,
-          user,
-          body: parsed,
-          alreadyForwarded: req.headers[api.VERIFY_FORWARDED_HEADER] !== void 0
-        });
-        if (forwarded) {
-          return res.json(forwarded);
-        }
-        const tasks$1 = new tasks.Tasks(env, req.logger);
-        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, reason } = await tasks$1.powCaptchaManager.serverVerifyPowCaptchaSolution(
-          dapp,
-          challenge,
-          clientRecord.settings.verifiedTimeout,
-          env,
-          ip,
-          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) => {
-      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, ip, email } = parsed;
-        const { dapp, user, timestamp, challenge, providerUrl } = types.decodeProcaptchaOutput(token);
-        const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
-        if (testVerdict !== null) {
-          const verificationResponse2 = {
-            status: "ok",
-            verified: testVerdict
-          };
-          return res.json(verificationResponse2);
-        }
-        const forwarded = await forwardVerify.forwardVerifyIfNotIssuer({
-          env,
-          logger: req.logger,
-          path: types.ClientApiPaths.VerifyPuzzleCaptchaSolution,
-          providerUrl,
-          dapp,
-          user,
-          body: parsed,
-          alreadyForwarded: req.headers[api.VERIFY_FORWARDED_HEADER] !== void 0
-        });
-        if (forwarded) {
-          return res.json(forwarded);
-        }
-        const tasks$1 = new tasks.Tasks(env, req.logger);
-        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,
-          clientRecord.settings.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,
-          score
-        );
-        return res.json(verificationResponse);
-      } catch (err) {
-        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 },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-    }
-  );
-  router.use(apiExpressRouter.handleErrors);
-  return router;
+	const router = express.default.Router();
+	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.use((req, res, next) => {
+		if (!require_metrics.metricsEnabled()) return next();
+		const type = VERIFY_PATH_TYPE[req.path];
+		if (!type) return next();
+		const originalJson = res.json.bind(res);
+		res.json = (body) => {
+			if (res.statusCode < 300) {
+				const verified = !!(body && typeof body === "object" && body.verified);
+				require_metrics.recordCaptchaVerify({
+					type,
+					verified,
+					source: deriveVerifySource(req.body)
+				});
+			}
+			return originalJson(body);
+		};
+		next();
+	});
+	/**
+	* Verifies a dapp's solution as being approved or not
+	*
+	* @param {string} user - Dapp User AccountId
+	* @param {string} dapp - Dapp Contract AccountId
+	* @param {string} blockNumber - The block number at which the captcha was requested
+	* @param {string} dappUserSignature - The signature fo dapp user
+	* @param {string} commitmentId - The captcha solution to look up
+	* @param {number} maxVerifiedTime - The maximum time in milliseconds since the blockNumber
+	*/
+	router.post(_prosopo_types.ClientApiPaths.VerifyImageCaptchaSolutionDapp, async (req, res, next) => {
+		if (require_apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
+			req.logger.info(() => ({ msg: "Maintenance mode active - returning verified for image captcha verification" }));
+			return res.json({
+				status: "ok",
+				verified: true
+			});
+		}
+		let parsed;
+		try {
+			parsed = _prosopo_types.VerifySolutionBody.parse(req.body);
+		} catch (err) {
+			return next(new _prosopo_common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+				context: {
+					code: 400,
+					error: err,
+					body: req.body
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+		const { dappSignature, token, ip, maxVerifiedTime, email } = parsed;
+		try {
+			const { user, dapp, timestamp, commitmentId, providerUrl } = (0, _prosopo_types.decodeProcaptchaOutput)(token);
+			const testVerdict = require_testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
+			if (testVerdict !== null) {
+				const verificationResponse = {
+					status: "ok",
+					verified: testVerdict
+				};
+				return res.json(verificationResponse);
+			}
+			const forwarded = await require_forwardVerify.forwardVerifyIfNotIssuer({
+				env,
+				logger: req.logger,
+				path: _prosopo_types.ClientApiPaths.VerifyImageCaptchaSolutionDapp,
+				providerUrl,
+				dapp,
+				user,
+				body: parsed,
+				alreadyForwarded: req.headers[_prosopo_api.VERIFY_FORWARDED_HEADER] !== void 0
+			});
+			if (forwarded) return res.json(forwarded);
+			const tasks = new require_tasks.Tasks(env, req.logger);
+			(0, _prosopo_util_crypto.validateAddress)(dapp, false, 42);
+			(0, _prosopo_util_crypto.validateAddress)(user, false, 42);
+			const clientRecord = await tasks.db.getClientRecord(dapp);
+			if (!clientRecord) return next(new _prosopo_common.ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
+				context: {
+					code: 400,
+					siteKey: dapp,
+					user
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+			const keyPair = env.keyring.addFromAddress(dapp);
+			(0, _prosopo_api_express_router.verifySignature)(dappSignature, timestamp.toString(), keyPair);
+			const response = await tasks.imgCaptchaManager.verifyImageCaptchaSolution(user, dapp, commitmentId, env, maxVerifiedTime, ip, clientRecord.settings.disallowWebView, 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.imgCaptchaManager.getVerificationResponse(response[_prosopo_types.ApiParams.verified], clientRecord, req.i18n.t, response[_prosopo_types.ApiParams.score], response[_prosopo_types.ApiParams.commitmentId], response[_prosopo_types.ApiParams.status]);
+			res.json(verificationResponse);
+		} catch (err) {
+			req.logger.error(() => ({
+				err,
+				msg: "Error in verifyImageCaptchaSolution",
+				data: { body: req.body }
+			}));
+			return next(new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+				context: {
+					code: 500,
+					siteKey: req.body.dapp,
+					user: req.body.user
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+	});
+	/**
+	* Verifies a dapp's solution as being approved or not
+	*
+	* @param {string} token - Token containing dapp, blockNumber and challenge
+	* @param {string} dappSignature - Signed token
+	* @param {number} verifiedTimeout - The maximum time in milliseconds to be valid
+	*/
+	router.post(_prosopo_types.ClientApiPaths.VerifyPowCaptchaSolution, async (req, res, next) => {
+		if (require_apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
+			req.logger.info(() => ({ msg: "Maintenance mode active - returning verified for PoW captcha verification" }));
+			return res.json({
+				status: "ok",
+				verified: true
+			});
+		}
+		let parsed;
+		try {
+			parsed = _prosopo_types.ServerPowCaptchaVerifyRequestBody.parse(req.body);
+		} catch (err) {
+			return next(new _prosopo_common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+				context: {
+					code: 400,
+					error: err,
+					body: req.body
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+		try {
+			const { token, dappSignature, ip, email } = parsed;
+			const { dapp, user, timestamp, challenge, providerUrl } = (0, _prosopo_types.decodeProcaptchaOutput)(token);
+			const testVerdict = require_testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
+			if (testVerdict !== null) {
+				const verificationResponse = {
+					status: "ok",
+					verified: testVerdict
+				};
+				return res.json(verificationResponse);
+			}
+			const forwarded = await require_forwardVerify.forwardVerifyIfNotIssuer({
+				env,
+				logger: req.logger,
+				path: _prosopo_types.ClientApiPaths.VerifyPowCaptchaSolution,
+				providerUrl,
+				dapp,
+				user,
+				body: parsed,
+				alreadyForwarded: req.headers[_prosopo_api.VERIFY_FORWARDED_HEADER] !== void 0
+			});
+			if (forwarded) return res.json(forwarded);
+			const tasks = new require_tasks.Tasks(env, req.logger);
+			(0, _prosopo_util_crypto.validateAddress)(dapp, false, 42);
+			(0, _prosopo_util_crypto.validateAddress)(user, false, 42);
+			const clientRecord = await tasks.db.getClientRecord(dapp);
+			if (!clientRecord) return next(new _prosopo_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"),
+					[_prosopo_types.ApiParams.verified]: false
+				};
+				return res.json(unverifiedResponse);
+			}
+			const dappPair = env.keyring.addFromAddress(dapp);
+			(0, _prosopo_api_express_router.verifySignature)(dappSignature, timestamp.toString(), dappPair);
+			const { verified, score, reason } = await tasks.powCaptchaManager.serverVerifyPowCaptchaSolution(dapp, challenge, clientRecord.settings.verifiedTimeout, env, ip, userAccessRulesStorage, email, clientRecord.settings.spamEmailDomainCheckEnabled, clientRecord.settings.spamFilter, clientRecord.settings.trafficFilter, clientRecord.settings.storeMetadata);
+			const verificationResponse = tasks.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 _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+				context: {
+					code: 500,
+					error: err
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+	});
+	/**
+	* Verifies a dapp's puzzle captcha solution as being approved or not
+	*
+	* @param {string} token - Token containing dapp, blockNumber and challenge
+	* @param {string} dappSignature - Signed token
+	* @param {number} verifiedTimeout - The maximum time in milliseconds to be valid
+	*/
+	router.post(_prosopo_types.ClientApiPaths.VerifyPuzzleCaptchaSolution, async (req, res, next) => {
+		if (require_apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
+			req.logger.info(() => ({ msg: "Maintenance mode active - returning verified for puzzle captcha verification" }));
+			return res.json({
+				status: "ok",
+				verified: true
+			});
+		}
+		let parsed;
+		try {
+			parsed = _prosopo_types.ServerPuzzleCaptchaVerifyRequestBody.parse(req.body);
+		} catch (err) {
+			return next(new _prosopo_common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+				context: {
+					code: 400,
+					error: err,
+					body: req.body
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+		try {
+			const { token, dappSignature, ip, email } = parsed;
+			const { dapp, user, timestamp, challenge, providerUrl } = (0, _prosopo_types.decodeProcaptchaOutput)(token);
+			const testVerdict = require_testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
+			if (testVerdict !== null) {
+				const verificationResponse = {
+					status: "ok",
+					verified: testVerdict
+				};
+				return res.json(verificationResponse);
+			}
+			const forwarded = await require_forwardVerify.forwardVerifyIfNotIssuer({
+				env,
+				logger: req.logger,
+				path: _prosopo_types.ClientApiPaths.VerifyPuzzleCaptchaSolution,
+				providerUrl,
+				dapp,
+				user,
+				body: parsed,
+				alreadyForwarded: req.headers[_prosopo_api.VERIFY_FORWARDED_HEADER] !== void 0
+			});
+			if (forwarded) return res.json(forwarded);
+			const tasks = new require_tasks.Tasks(env, req.logger);
+			(0, _prosopo_util_crypto.validateAddress)(dapp, false, 42);
+			(0, _prosopo_util_crypto.validateAddress)(user, false, 42);
+			const clientRecord = await tasks.db.getClientRecord(dapp);
+			if (!clientRecord) return next(new _prosopo_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"),
+					[_prosopo_types.ApiParams.verified]: false
+				};
+				return res.json(unverifiedResponse);
+			}
+			const dappPair = env.keyring.addFromAddress(dapp);
+			(0, _prosopo_api_express_router.verifySignature)(dappSignature, timestamp.toString(), dappPair);
+			const { verified, score } = await tasks.puzzleCaptchaManager.serverVerifyPuzzleCaptchaSolution(dapp, challenge, clientRecord.settings.verifiedTimeout, env, ip, userAccessRulesStorage, email, clientRecord.settings.spamEmailDomainCheckEnabled, clientRecord.settings.trafficFilter, clientRecord.settings.storeMetadata);
+			const verificationResponse = tasks.puzzleCaptchaManager.getVerificationResponse(verified, clientRecord, req.i18n.t, score);
+			return res.json(verificationResponse);
+		} catch (err) {
+			req.logger.error(() => ({
+				msg: "Error in verifyPuzzleCaptchaSolution",
+				err,
+				data: { body: req.body }
+			}));
+			return next(new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+				context: {
+					code: 500,
+					error: err
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+	});
+	router.use(_prosopo_api_express_router.handleErrors);
+	return router;
 }
+//#endregion
 exports.prosopoVerifyRouter = prosopoVerifyRouter;