@prosopo/provider 4.15.14 → 4.15.15

package/dist/api/verify.js

@@ -1,384 +1,341 @@
-import { VERIFY_FORWARDED_HEADER } from "@prosopo/api";
-import { verifySignature, handleErrors } from "@prosopo/api-express-router";
-import { ProsopoApiError } from "@prosopo/common";
-import { decodeProcaptchaOutput, ClientApiPaths, CaptchaType, VerifySolutionBody, ApiParams, ServerPowCaptchaVerifyRequestBody, ServerPuzzleCaptchaVerifyRequestBody } from "@prosopo/types";
-import { validateAddress } from "@prosopo/util-crypto";
-import express from "express";
+import { metricsEnabled, recordCaptchaVerify } from "./metrics.js";
 import { Tasks } from "../tasks/tasks.js";
 import { getMaintenanceMode } from "./admin/apiToggleMaintenanceModeEndpoint.js";
-import { forwardVerifyIfNotIssuer } from "./forwardVerify.js";
-import { metricsEnabled, recordCaptchaVerify } from "./metrics.js";
 import { isReservedTestSiteKey, resolveTestSiteKeyVerdict } from "./testSiteKey.js";
-const deriveVerifySource = (body) => {
-  if (getMaintenanceMode()) return "maintenance";
-  try {
-    const token = body?.token;
-    if (token) {
-      const { dapp } = decodeProcaptchaOutput(token);
-      if (isReservedTestSiteKey(dapp)) return "test_key";
-    }
-  } catch {
-  }
-  return "real";
+import { forwardVerifyIfNotIssuer } from "./forwardVerify.js";
+import { ProsopoApiError } from "@prosopo/common";
+import { ApiParams, CaptchaType, ClientApiPaths, ServerPowCaptchaVerifyRequestBody, ServerPuzzleCaptchaVerifyRequestBody, VerifySolutionBody, decodeProcaptchaOutput } from "@prosopo/types";
+import { validateAddress } from "@prosopo/util-crypto";
+import { handleErrors, verifySignature } from "@prosopo/api-express-router";
+import express from "express";
+import { VERIFY_FORWARDED_HEADER } from "@prosopo/api";
+//#region src/api/verify.ts
+var deriveVerifySource = (body) => {
+	if (getMaintenanceMode()) return "maintenance";
+	try {
+		const token = body?.token;
+		if (token) {
+			const { dapp } = decodeProcaptchaOutput(token);
+			if (isReservedTestSiteKey(dapp)) return "test_key";
+		}
+	} catch {}
+	return "real";
 };
-const VERIFY_PATH_TYPE = {
-  [ClientApiPaths.VerifyImageCaptchaSolutionDapp]: CaptchaType.image,
-  [ClientApiPaths.VerifyPowCaptchaSolution]: CaptchaType.pow,
-  [ClientApiPaths.VerifyPuzzleCaptchaSolution]: CaptchaType.puzzle
+var VERIFY_PATH_TYPE = {
+	[ClientApiPaths.VerifyImageCaptchaSolutionDapp]: CaptchaType.image,
+	[ClientApiPaths.VerifyPowCaptchaSolution]: CaptchaType.pow,
+	[ClientApiPaths.VerifyPuzzleCaptchaSolution]: 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 (!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);
-        recordCaptchaVerify({
-          type,
-          verified,
-          source: deriveVerifySource(req.body)
-        });
-      }
-      return originalJson(body);
-    };
-    next();
-  });
-  router.post(
-    ClientApiPaths.VerifyImageCaptchaSolutionDapp,
-    async (req, res, next) => {
-      if (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 = VerifySolutionBody.parse(req.body);
-      } catch (err) {
-        return next(
-          new 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 } = decodeProcaptchaOutput(token);
-        const testVerdict = resolveTestSiteKeyVerdict(dapp, req.logger);
-        if (testVerdict !== null) {
-          const verificationResponse2 = {
-            status: "ok",
-            verified: testVerdict
-          };
-          return res.json(verificationResponse2);
-        }
-        const forwarded = await forwardVerifyIfNotIssuer({
-          env,
-          logger: req.logger,
-          path: ClientApiPaths.VerifyImageCaptchaSolutionDapp,
-          providerUrl,
-          dapp,
-          user,
-          body: parsed,
-          alreadyForwarded: req.headers[VERIFY_FORWARDED_HEADER] !== void 0
-        });
-        if (forwarded) {
-          return res.json(forwarded);
-        }
-        const tasks = new Tasks(env, req.logger);
-        validateAddress(dapp, false, 42);
-        validateAddress(user, false, 42);
-        const clientRecord = await tasks.db.getClientRecord(dapp);
-        if (!clientRecord) {
-          return next(
-            new ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
-              context: { code: 400, siteKey: dapp, user },
-              i18n: req.i18n,
-              logger: req.logger
-            })
-          );
-        }
-        const keyPair = env.keyring.addFromAddress(dapp);
-        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[ApiParams.verified],
-          clientRecord,
-          req.i18n.t,
-          response[ApiParams.score],
-          response[ApiParams.commitmentId],
-          response[ApiParams.status]
-        );
-        res.json(verificationResponse);
-      } catch (err) {
-        req.logger.error(() => ({
-          err,
-          msg: "Error in verifyImageCaptchaSolution",
-          data: { body: req.body }
-        }));
-        return next(
-          new ProsopoApiError("API.BAD_REQUEST", {
-            context: { code: 500, siteKey: req.body.dapp, user: req.body.user },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-    }
-  );
-  router.post(
-    ClientApiPaths.VerifyPowCaptchaSolution,
-    async (req, res, next) => {
-      if (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 = ServerPowCaptchaVerifyRequestBody.parse(req.body);
-      } catch (err) {
-        return next(
-          new 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 } = decodeProcaptchaOutput(token);
-        const testVerdict = resolveTestSiteKeyVerdict(dapp, req.logger);
-        if (testVerdict !== null) {
-          const verificationResponse2 = {
-            status: "ok",
-            verified: testVerdict
-          };
-          return res.json(verificationResponse2);
-        }
-        const forwarded = await forwardVerifyIfNotIssuer({
-          env,
-          logger: req.logger,
-          path: ClientApiPaths.VerifyPowCaptchaSolution,
-          providerUrl,
-          dapp,
-          user,
-          body: parsed,
-          alreadyForwarded: req.headers[VERIFY_FORWARDED_HEADER] !== void 0
-        });
-        if (forwarded) {
-          return res.json(forwarded);
-        }
-        const tasks = new Tasks(env, req.logger);
-        validateAddress(dapp, false, 42);
-        validateAddress(user, false, 42);
-        const clientRecord = await tasks.db.getClientRecord(dapp);
-        if (!clientRecord) {
-          return next(
-            new 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"),
-            [ApiParams.verified]: false
-          };
-          return res.json(unverifiedResponse);
-        }
-        const dappPair = env.keyring.addFromAddress(dapp);
-        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 ProsopoApiError("API.BAD_REQUEST", {
-            context: { code: 500, error: err },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-    }
-  );
-  router.post(
-    ClientApiPaths.VerifyPuzzleCaptchaSolution,
-    async (req, res, next) => {
-      if (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 = ServerPuzzleCaptchaVerifyRequestBody.parse(req.body);
-      } catch (err) {
-        return next(
-          new 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 } = decodeProcaptchaOutput(token);
-        const testVerdict = resolveTestSiteKeyVerdict(dapp, req.logger);
-        if (testVerdict !== null) {
-          const verificationResponse2 = {
-            status: "ok",
-            verified: testVerdict
-          };
-          return res.json(verificationResponse2);
-        }
-        const forwarded = await forwardVerifyIfNotIssuer({
-          env,
-          logger: req.logger,
-          path: ClientApiPaths.VerifyPuzzleCaptchaSolution,
-          providerUrl,
-          dapp,
-          user,
-          body: parsed,
-          alreadyForwarded: req.headers[VERIFY_FORWARDED_HEADER] !== void 0
-        });
-        if (forwarded) {
-          return res.json(forwarded);
-        }
-        const tasks = new Tasks(env, req.logger);
-        validateAddress(dapp, false, 42);
-        validateAddress(user, false, 42);
-        const clientRecord = await tasks.db.getClientRecord(dapp);
-        if (!clientRecord) {
-          return next(
-            new 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"),
-            [ApiParams.verified]: false
-          };
-          return res.json(unverifiedResponse);
-        }
-        const dappPair = env.keyring.addFromAddress(dapp);
-        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 ProsopoApiError("API.BAD_REQUEST", {
-            context: { code: 500, error: err },
-            i18n: req.i18n,
-            logger: req.logger
-          })
-        );
-      }
-    }
-  );
-  router.use(handleErrors);
-  return router;
+	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 (!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);
+				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(ClientApiPaths.VerifyImageCaptchaSolutionDapp, async (req, res, next) => {
+		if (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 = VerifySolutionBody.parse(req.body);
+		} catch (err) {
+			return next(new 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 } = decodeProcaptchaOutput(token);
+			const testVerdict = resolveTestSiteKeyVerdict(dapp, req.logger);
+			if (testVerdict !== null) {
+				const verificationResponse = {
+					status: "ok",
+					verified: testVerdict
+				};
+				return res.json(verificationResponse);
+			}
+			const forwarded = await forwardVerifyIfNotIssuer({
+				env,
+				logger: req.logger,
+				path: ClientApiPaths.VerifyImageCaptchaSolutionDapp,
+				providerUrl,
+				dapp,
+				user,
+				body: parsed,
+				alreadyForwarded: req.headers[VERIFY_FORWARDED_HEADER] !== void 0
+			});
+			if (forwarded) return res.json(forwarded);
+			const tasks = new Tasks(env, req.logger);
+			validateAddress(dapp, false, 42);
+			validateAddress(user, false, 42);
+			const clientRecord = await tasks.db.getClientRecord(dapp);
+			if (!clientRecord) return next(new ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
+				context: {
+					code: 400,
+					siteKey: dapp,
+					user
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+			const keyPair = env.keyring.addFromAddress(dapp);
+			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[ApiParams.verified], clientRecord, req.i18n.t, response[ApiParams.score], response[ApiParams.commitmentId], response[ApiParams.status]);
+			res.json(verificationResponse);
+		} catch (err) {
+			req.logger.error(() => ({
+				err,
+				msg: "Error in verifyImageCaptchaSolution",
+				data: { body: req.body }
+			}));
+			return next(new 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(ClientApiPaths.VerifyPowCaptchaSolution, async (req, res, next) => {
+		if (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 = ServerPowCaptchaVerifyRequestBody.parse(req.body);
+		} catch (err) {
+			return next(new 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 } = decodeProcaptchaOutput(token);
+			const testVerdict = resolveTestSiteKeyVerdict(dapp, req.logger);
+			if (testVerdict !== null) {
+				const verificationResponse = {
+					status: "ok",
+					verified: testVerdict
+				};
+				return res.json(verificationResponse);
+			}
+			const forwarded = await forwardVerifyIfNotIssuer({
+				env,
+				logger: req.logger,
+				path: ClientApiPaths.VerifyPowCaptchaSolution,
+				providerUrl,
+				dapp,
+				user,
+				body: parsed,
+				alreadyForwarded: req.headers[VERIFY_FORWARDED_HEADER] !== void 0
+			});
+			if (forwarded) return res.json(forwarded);
+			const tasks = new Tasks(env, req.logger);
+			validateAddress(dapp, false, 42);
+			validateAddress(user, false, 42);
+			const clientRecord = await tasks.db.getClientRecord(dapp);
+			if (!clientRecord) return next(new 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"),
+					[ApiParams.verified]: false
+				};
+				return res.json(unverifiedResponse);
+			}
+			const dappPair = env.keyring.addFromAddress(dapp);
+			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 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(ClientApiPaths.VerifyPuzzleCaptchaSolution, async (req, res, next) => {
+		if (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 = ServerPuzzleCaptchaVerifyRequestBody.parse(req.body);
+		} catch (err) {
+			return next(new 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 } = decodeProcaptchaOutput(token);
+			const testVerdict = resolveTestSiteKeyVerdict(dapp, req.logger);
+			if (testVerdict !== null) {
+				const verificationResponse = {
+					status: "ok",
+					verified: testVerdict
+				};
+				return res.json(verificationResponse);
+			}
+			const forwarded = await forwardVerifyIfNotIssuer({
+				env,
+				logger: req.logger,
+				path: ClientApiPaths.VerifyPuzzleCaptchaSolution,
+				providerUrl,
+				dapp,
+				user,
+				body: parsed,
+				alreadyForwarded: req.headers[VERIFY_FORWARDED_HEADER] !== void 0
+			});
+			if (forwarded) return res.json(forwarded);
+			const tasks = new Tasks(env, req.logger);
+			validateAddress(dapp, false, 42);
+			validateAddress(user, false, 42);
+			const clientRecord = await tasks.db.getClientRecord(dapp);
+			if (!clientRecord) return next(new 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"),
+					[ApiParams.verified]: false
+				};
+				return res.json(unverifiedResponse);
+			}
+			const dappPair = env.keyring.addFromAddress(dapp);
+			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 ProsopoApiError("API.BAD_REQUEST", {
+				context: {
+					code: 500,
+					error: err
+				},
+				i18n: req.i18n,
+				logger: req.logger
+			}));
+		}
+	});
+	router.use(handleErrors);
+	return router;
 }
-export {
-  prosopoVerifyRouter
-};
+//#endregion
+export { prosopoVerifyRouter };