@prosopo/provider 5.19.3 → 5.20.0

package/dist/cjs/api/captcha/submitPoWCaptchaSolution.cjs

@@ -12,6 +12,7 @@ let _prosopo_types = require("@prosopo/types");
 let _prosopo_util = require("@prosopo/util");
 let _prosopo_captcha_severity = require("@prosopo/captcha-severity");
 let _prosopo_puzzle_assets = require("@prosopo/puzzle-assets");
+let _prosopo_fingerprint_summary = require("@prosopo/fingerprint/summary");
 //#region src/api/captcha/submitPoWCaptchaSolution.ts
 var submitPoWCaptchaSolution_default = (env) => async (req, res, next) => {
 	if (require_apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) {
@@ -26,14 +27,12 @@ var submitPoWCaptchaSolution_default = (env) => async (req, res, next) => {
 	try {
 		parsed = _prosopo_types.SubmitPowCaptchaSolutionBody.parse(req.body);
 	} catch (err) {
-		return next(new _prosopo_common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
-			context: {
-				code: 400,
-				error: err,
-				body: require_requestBodySummary.summariseRequestBody(req)
-			},
-			i18n: req.i18n,
-			logger: req.logger
+		return next(new _prosopo_common.ProsopoError({
+			code: "INVALID_REQUEST",
+			errorSite: "PROV-27",
+			message: "Error parsing captcha",
+			cause: err,
+			context: { body: require_requestBodySummary.summariseRequestBody(req) }
 		}));
 	}
 	const { challenge, signature, nonce, dapp, user, behavioralData, salt, simdReadings, clientMetaData, fingerprintProof } = parsed;
@@ -49,22 +48,21 @@ var submitPoWCaptchaSolution_default = (env) => async (req, res, next) => {
 	}
 	try {
 		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 (!clientRecord) return next(new _prosopo_common.ProsopoError({
+			code: "SITE_KEY_NOT_REGISTERED",
+			errorSite: "PROV-28",
+			context: { siteKey: dapp }
 		}));
 		const flatHeaders = (0, _prosopo_util.flatten)(req.headers);
 		const userAgent = req.headers["user-agent"] ?? "";
 		const countryCode = req.ipInfo && "isValid" in req.ipInfo && req.ipInfo.isValid ? req.ipInfo.countryCode : void 0;
+		const fingerprintSummary = (0, _prosopo_fingerprint_summary.summariseFingerprintProof)(fingerprintProof);
 		req.logger.info(() => ({
 			msg: fingerprintProof ? "fingerprintProof detected" : "no fingerprintProof on PoW submission",
 			data: {
 				fingerprintProofPresent: fingerprintProof !== void 0,
 				fingerprintProofBytes: fingerprintProof?.length ?? 0,
+				fingerprintSummarised: fingerprintSummary !== void 0,
 				challenge
 			}
 		}));
@@ -72,12 +70,17 @@ var submitPoWCaptchaSolution_default = (env) => async (req, res, next) => {
 		tasks.powCaptchaManager.setPostPowContext({
 			ip: req.ip || "",
 			countryCode,
-			platform: require_devicePlatform.derivePlatform(userAgent, false),
+			platform: require_devicePlatform.derivePlatform(userAgent, false, {
+				headers: flatHeaders,
+				...req.ipInfo && "isValid" in req.ipInfo && req.ipInfo.isValid && { carrierNetwork: req.ipInfo.isMobile },
+				...req.tcpMss !== void 0 && { tcpMss: req.tcpMss }
+			}),
 			raw: {
 				headers: flatHeaders,
 				userAgent,
 				...req.ja4 && { ja4: req.ja4 },
 				...fingerprintProof && { fingerprintProof },
+				...fingerprintSummary && { fingerprintSummary },
 				...req.tcpToChelloUs !== void 0 && { tcpToChelloUs: req.tcpToChelloUs },
 				...req.chelloToHandshakeUs !== void 0 && { chelloToHandshakeUs: req.chelloToHandshakeUs },
 				...require_rawTlsSignalsMiddleware.rawTlsSignalsForSession(req),
@@ -86,7 +89,7 @@ var submitPoWCaptchaSolution_default = (env) => async (req, res, next) => {
 			}
 		});
 		const submitWindowMs = clientRecord.settings.solutionTimeout ?? clientRecord.settings.verifiedTimeout;
-		const result = await tasks.powCaptchaManager.verifyPowCaptchaSolution(challenge, signature.provider.challenge, nonce, submitWindowMs, signature.user.timestamp, (0, _prosopo_util.getIPAddress)(req.ip || ""), flatHeaders, behavioralData, salt, simdReadings, clientMetaData);
+		const result = await tasks.powCaptchaManager.verifyPowCaptchaSolution(challenge, signature.provider.challenge, nonce, submitWindowMs, signature.user.timestamp, (0, _prosopo_util.getIPAddress)(req.ip || ""), flatHeaders, behavioralData, salt, simdReadings, clientMetaData, fingerprintSummary);
 		if (result.routingOutput) req.logger.info(() => ({
 			msg: "post-PoW routing decision",
 			data: {
@@ -111,19 +114,18 @@ var submitPoWCaptchaSolution_default = (env) => async (req, res, next) => {
 		};
 		return res.json(response);
 	} catch (err) {
+		if ((0, _prosopo_common.isProsopoError)(err) && !(0, _prosopo_common.isSevereError)(err)) return next(err);
 		req.logger.error(() => ({
 			err,
 			body: require_requestBodySummary.summariseRequestBody(req),
 			msg: "Error in PoW captcha solution submission"
 		}));
-		return next(new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
-			context: {
-				code: 500,
-				siteKey: req.body.dapp,
-				error: err
-			},
-			i18n: req.i18n,
-			logger: req.logger
+		return next(new _prosopo_common.ProsopoError({
+			code: "UNEXPECTED",
+			errorSite: "PROV-29",
+			message: "BadRequest",
+			cause: err,
+			context: { siteKey: req.body.dapp }
 		}));
 	}
 };
@@ -150,7 +152,13 @@ var buildEscalation = async (tasks, result, challenge, perConnectionSignals, sit
 	const imageMaxRounds = siteConstraints?.imageMaxRounds ?? _prosopo_types.imageMaxRoundsDefault;
 	const escalationPuzzleOverrides = (() => {
 		if (escalatedType !== _prosopo_types.CaptchaType.puzzle) return void 0;
-		const { isMobile } = require_devicePlatform.derivePlatform(originSession.headers?.["user-agent"] ?? "", originSession.webView);
+		const { isMobile } = require_devicePlatform.derivePlatform(originSession.headers?.["user-agent"] ?? "", originSession.webView, {
+			...originSession.headers && { headers: originSession.headers },
+			...originSession.ipInfo?.isValid && { carrierNetwork: originSession.ipInfo.isMobile },
+			...originSession.tcpMss !== void 0 && { tcpMss: originSession.tcpMss },
+			...powRecord.deviceCapability !== void 0 && { deviceCapability: powRecord.deviceCapability },
+			...powRecord.behavioralDataPacked?.c2 !== void 0 && { touchEventCount: powRecord.behavioralDataPacked.c2.length }
+		});
 		const level = (0, _prosopo_captcha_severity.severityToPuzzleDifficulty)(routed.solvedImagesCount ?? originSession.solvedImagesCount, tasks.config.captchas.solved.count, (0, _prosopo_captcha_severity.resolveMaxEscalationLevel)(siteConstraints?.puzzleMaxDifficulty, isMobile));
 		if (level === 0) return void 0;
 		const difficulty = require_puzzleDifficulty.samplePuzzleDifficulty(level, _prosopo_puzzle_assets.DEFAULT_RENDER_SETTINGS.holeDarken);

package/dist/cjs/api/domainMiddleware.cjs

@@ -20,11 +20,11 @@ var domainMiddleware = (env) => {
 			if (!cachedTasks) cachedTasks = new require_tasks.Tasks(env);
 			const tasks = cachedTasks;
 			const siteKey = req.headers["prosopo-site-key"];
-			if (!siteKey) throw siteKeyNotRegisteredError(req.i18n, "No sitekey provided", req.logger);
+			if (!siteKey) throw siteKeyNotRegisteredError("No sitekey provided");
 			try {
 				(0, _prosopo_util_crypto.validateAddress)(siteKey, false, 42);
 			} catch (err) {
-				throw invalidSiteKeyError(req.i18n, siteKey, req.logger);
+				throw invalidSiteKeyError(siteKey);
 			}
 			if (require_testSiteKey.isReservedTestSiteKey(siteKey)) {
 				require_metrics.recordDomainValidation("test_key");
@@ -32,32 +32,34 @@ var domainMiddleware = (env) => {
 				return;
 			}
 			const clientSettings = await tasks.db.getClientRecord(siteKey);
-			if (!clientSettings) throw siteKeyNotRegisteredError(req.i18n, siteKey, req.logger);
+			if (!clientSettings) throw siteKeyNotRegisteredError(siteKey);
 			const allowedDomains = clientSettings.settings?.domains;
-			if (!allowedDomains) throw siteKeyInvalidDomainError(req.i18n, siteKey, req.hostname, req.logger);
+			if (!allowedDomains) throw siteKeyInvalidDomainError(siteKey, req.hostname);
 			const origin = req.headers.origin;
-			if (!origin) throw unauthorizedOriginError(req.i18n, void 0, req.logger);
+			if (!origin) throw unauthorizedOriginError(void 0);
 			const candidateOrigins = [origin, ...googleTranslateOrigins(origin)];
 			for (const candidate of candidateOrigins) for (const domain of allowedDomains) if (tasks.clientTaskManager.domainPatternMatcher(candidate, domain)) {
 				require_metrics.recordDomainValidation("allowed");
 				next();
 				return;
 			}
-			throw unauthorizedOriginError(req.i18n, origin, req.logger);
+			throw unauthorizedOriginError(origin);
 		} catch (err) {
 			require_metrics.recordDomainValidation("rejected");
-			if (err instanceof _prosopo_common.ProsopoApiError || err instanceof zod.ZodError || err instanceof SyntaxError) (0, _prosopo_api_express_router.handleErrors)(err, req, res, next);
-			else {
-				req.logger.error(() => ({
-					err,
-					msg: "Domain middleware error"
-				}));
-				res.status(401).json({
-					error: "Unauthorized",
-					message: "Unauthorized"
-				});
+			if ((0, _prosopo_common.isProsopoError)(err) || err instanceof zod.ZodError || err instanceof SyntaxError) {
+				(0, _prosopo_api_express_router.handleErrors)(err, req, res, next);
 				return;
 			}
+			req.logger.error(() => ({
+				err,
+				msg: "Domain middleware error"
+			}));
+			const error = new _prosopo_common.ProsopoError({
+				code: "UNAUTHORIZED",
+				errorSite: "PROV-85",
+				cause: err
+			});
+			res.status(error.status).json({ error: (0, _prosopo_common.toPublicError)(error, "BACKEND_ERROR") });
 		}
 	};
 };
@@ -71,46 +73,36 @@ var googleTranslateOrigins = (origin) => {
 		return [];
 	}
 };
-var siteKeyNotRegisteredError = (i18n, dapp, logger) => {
-	return new _prosopo_common.ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
-		context: {
-			code: 400,
-			siteKey: dapp
-		},
-		i18n,
-		logger
+var siteKeyNotRegisteredError = (dapp) => {
+	return new _prosopo_common.ProsopoError({
+		code: "SITE_KEY_NOT_REGISTERED",
+		errorSite: "PROV-30",
+		context: { siteKey: dapp }
 	});
 };
-var invalidSiteKeyError = (i18n, siteKey, logger) => {
-	return new _prosopo_common.ProsopoApiError("API.INVALID_SITE_KEY", {
-		context: {
-			code: 400,
-			siteKey
-		},
-		i18n,
-		logger
+var invalidSiteKeyError = (siteKey) => {
+	return new _prosopo_common.ProsopoError({
+		code: "SITE_KEY_INVALID",
+		errorSite: "PROV-31",
+		context: { siteKey }
 	});
 };
-var unauthorizedOriginError = (i18n, origin, logger) => {
-	return new _prosopo_common.ProsopoApiError("API.UNAUTHORIZED_ORIGIN_URL", {
-		context: {
-			code: 400,
-			origin
-		},
-		i18n,
-		logger
+var unauthorizedOriginError = (origin) => {
+	return new _prosopo_common.ProsopoError({
+		code: "ORIGIN_NOT_ALLOWED",
+		errorSite: "PROV-32",
+		context: { origin }
 	});
 };
-var siteKeyInvalidDomainError = (i18n, dapp, domain, logger) => {
-	return new _prosopo_common.ProsopoApiError("API.UNAUTHORIZED_ORIGIN_URL", {
+var siteKeyInvalidDomainError = (dapp, domain) => {
+	return new _prosopo_common.ProsopoError({
+		code: "ORIGIN_NOT_ALLOWED",
+		errorSite: "PROV-33",
 		context: {
-			code: 400,
 			message: "No domains are allowed for this site key. Please fix in the Procaptcha Portal",
 			siteKey: dapp,
 			domain
-		},
-		i18n,
-		logger
+		}
 	});
 };
 //#endregion

package/dist/cjs/api/errorCodeForReason.cjs

@@ -0,0 +1,22 @@
+let _prosopo_common = require("@prosopo/common");
+//#region src/api/errorCodeForReason.ts
+var RENAMED = {
+	"API.INVALID_SITE_KEY": "SITE_KEY_INVALID",
+	"API.UNAUTHORIZED_ORIGIN_URL": "ORIGIN_NOT_ALLOWED",
+	"API.BAD_REQUEST": "INVALID_REQUEST"
+};
+/**
+* A request validation outcome (a `ResultReason` or other translation key) as
+* the error code the widget branches on: the key without its namespace, e.g.
+* `API.VPN_BLOCKED` is `VPN_BLOCKED`. An outcome with no code of its own gets
+* `fallback`.
+*/
+var errorCodeForReason = (reason, fallback = "INVALID_REQUEST") => {
+	if (reason === void 0) return fallback;
+	const renamed = RENAMED[reason];
+	if (renamed) return renamed;
+	const unprefixed = reason.slice(reason.indexOf(".") + 1);
+	return (0, _prosopo_common.isErrorCode)(unprefixed) ? unprefixed : fallback;
+};
+//#endregion
+exports.errorCodeForReason = errorCodeForReason;

package/dist/cjs/api/headerCheckMiddleware.cjs

@@ -1,4 +1,5 @@
 const require_validateAddress = require("./validateAddress.cjs");
+let _prosopo_common = require("@prosopo/common");
 let _prosopo_api_express_router = require("@prosopo/api-express-router");
 //#region src/api/headerCheckMiddleware.ts
 var headerCheckMiddleware = (env) => {
@@ -7,15 +8,23 @@ var headerCheckMiddleware = (env) => {
 			const user = req.headers["prosopo-user"];
 			const siteKey = req.headers["prosopo-site-key"];
 			if (!user) {
-				unauthorised(res);
+				(0, _prosopo_api_express_router.sendProsopoError)(res, new _prosopo_common.ProsopoError({
+					code: "UNAUTHORIZED",
+					errorSite: "PROV-86",
+					message: "Missing prosopo-user header"
+				}));
 				return;
 			}
 			if (!siteKey) {
-				unauthorised(res);
+				(0, _prosopo_api_express_router.sendProsopoError)(res, new _prosopo_common.ProsopoError({
+					code: "UNAUTHORIZED",
+					errorSite: "PROV-87",
+					message: "Missing prosopo-site-key header"
+				}));
 				return;
 			}
-			require_validateAddress.validateSiteKey(siteKey, req.logger);
-			require_validateAddress.validateAddr(user, void 0, req.logger);
+			require_validateAddress.validateSiteKey(siteKey);
+			require_validateAddress.validateAddr(user);
 			req.user = user;
 			req.siteKey = siteKey;
 			req.logger = req.logger.with({
@@ -28,9 +37,5 @@ var headerCheckMiddleware = (env) => {
 		}
 	};
 };
-var unauthorised = (res) => res.status(401).json({
-	error: "Unauthorized",
-	message: "Unauthorized"
-});
 //#endregion
 exports.headerCheckMiddleware = headerCheckMiddleware;

package/dist/cjs/api/ipInfoMiddleware.cjs

@@ -1,6 +1,10 @@
 //#region src/api/ipInfoMiddleware.ts
-var ipInfoMiddleware = (env) => {
+var ipInfoMiddleware = (env, skipPaths = /* @__PURE__ */ new Set()) => {
 	return async (req, _res, next) => {
+		if (skipPaths.has(req.path)) {
+			next();
+			return;
+		}
 		try {
 			const ip = req.ip;
 			if (ip && env.ipInfoService.isAvailable()) req.ipInfo = await env.ipInfoService.lookup(ip);

package/dist/cjs/api/metrics.cjs

@@ -1,4 +1,6 @@
+let _prosopo_common = require("@prosopo/common");
 let _prosopo_types = require("@prosopo/types");
+let _prosopo_api_express_router = require("@prosopo/api-express-router");
 let node_crypto = require("node:crypto");
 let node_net = require("node:net");
 let prom_client = require("prom-client");
@@ -386,7 +388,13 @@ var metricsHandler = (env) => {
 	return async (req, res) => {
 		const access = metricsAccess(req);
 		if (access !== 200) {
-			res.status(access).send(access === 401 ? "Unauthorized" : "Forbidden");
+			(0, _prosopo_api_express_router.sendProsopoError)(res, access === 401 ? new _prosopo_common.ProsopoError({
+				code: "UNAUTHORIZED",
+				errorSite: "PROV-91"
+			}) : new _prosopo_common.ProsopoError({
+				code: "FORBIDDEN",
+				errorSite: "PROV-92"
+			}));
 			return;
 		}
 		const m = getMetrics();

package/dist/cjs/api/public.cjs

@@ -62,7 +62,11 @@ function publicRouter(env) {
 				data: { reqParams: req.params },
 				msg: "Error getting provider details"
 			}));
-			return next(new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 500 } }));
+			return next(new _prosopo_common.ProsopoError({
+				code: "UNEXPECTED",
+				errorSite: "PROV-34",
+				message: "BadRequest"
+			}));
 		}
 	});
 	router.use(require_assetDocument.assetDocumentRouter());

package/dist/cjs/api/rateLimitHandler.cjs

@@ -0,0 +1,20 @@
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_api_express_router = require("@prosopo/api-express-router");
+//#region src/api/rateLimitHandler.ts
+var rateLimitHandler = (logger, path) => (req, res, _next, options) => {
+	logger.warn(() => ({
+		msg: "Rate limit exceeded",
+		data: {
+			path,
+			ip: req.ip,
+			siteKey: req.headers["prosopo-site-key"]
+		}
+	}));
+	(0, _prosopo_api_express_router.sendProsopoError)(res, new _prosopo_common.ProsopoError({
+		code: "RATE_LIMITED",
+		errorSite: "PROV-93",
+		status: options.statusCode
+	}));
+};
+//#endregion
+exports.rateLimitHandler = rateLimitHandler;

package/dist/cjs/api/startProviderApi.cjs

@@ -17,11 +17,11 @@ const require_detectorPoolBodyParser = require("./detectorPoolBodyParser.cjs");
 const require_headerCheckMiddleware = require("./headerCheckMiddleware.cjs");
 const require_ignoreMiddleware = require("./ignoreMiddleware.cjs");
 const require_ipInfoMiddleware = require("./ipInfoMiddleware.cjs");
+const require_rateLimitHandler = require("./rateLimitHandler.cjs");
 const require_robotsMiddleware = require("./robotsMiddleware.cjs");
 let _prosopo_logger = require("@prosopo/logger");
 let _prosopo_types = require("@prosopo/types");
 let _prosopo_api_express_router = require("@prosopo/api-express-router");
-let _prosopo_locale = require("@prosopo/locale");
 let node_fs = require("node:fs");
 node_fs = require_runtime.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -30,6 +30,7 @@ let node_https = require("node:https");
 node_https = require_runtime.__toESM(node_https, 1);
 let express = require("express");
 express = require_runtime.__toESM(express, 1);
+let _prosopo_locale = require("@prosopo/locale");
 let node_url = require("node:url");
 let _prosopo_user_access_policy_api = require("@prosopo/user-access-policy/api");
 let cors = require("cors");
@@ -73,6 +74,7 @@ var providerCorsOptions = {
 var isTlsAvailable = () => {
 	return node_fs.default.existsSync(keyPath) && node_fs.default.existsSync(crtPath);
 };
+var getServerVerifyPaths = () => Object.values(_prosopo_types.ClientApiPaths).filter((path) => path.endsWith("/verify"));
 /**
 * Get client API paths that expect Prosopo headers (like site key) for validation, excluding verify and spam routes
 * @returns Array of ClientApiPaths excluding verify and spam routes
@@ -181,36 +183,25 @@ async function startProviderApi(env, admin = false, port) {
 			...(0, _prosopo_user_access_policy_api.getExpressApiRuleRateLimits)()
 		};
 		const adminPaths = Object.values(_prosopo_types.AdminApiPaths);
-		const rateLimitHandler = (path) => (req, res, _next, options) => {
-			env.logger.warn(() => ({
-				msg: "Rate limit exceeded",
-				data: {
-					path,
-					ip: req.ip,
-					siteKey: req.headers["prosopo-site-key"]
-				}
-			}));
-			res.status(options.statusCode).send(options.message);
-		};
 		for (const [path, limit] of Object.entries(rateLimits)) {
 			const enumPath = path;
 			if (adminPaths.includes(enumPath)) apiApp.use(enumPath, (0, express_rate_limit.default)({
 				...limit,
-				handler: rateLimitHandler(enumPath),
+				handler: require_rateLimitHandler.rateLimitHandler(env.logger, enumPath),
 				keyGenerator: (req) => {
 					return getUserFromJWT(req) || req.ip || "unknown";
 				}
 			}));
 			else if (path === _prosopo_types.ClientApiPaths.VerifyImageCaptchaSolutionDapp || path === _prosopo_types.ClientApiPaths.VerifyPowCaptchaSolution) apiApp.use(enumPath, (0, express_rate_limit.default)({
 				...limit,
-				handler: rateLimitHandler(enumPath),
+				handler: require_rateLimitHandler.rateLimitHandler(env.logger, enumPath),
 				keyGenerator: (req) => {
 					return req.headers["prosopo-site-key"] || req.ip || "unknown";
 				}
 			}));
 			else apiApp.use(enumPath, (0, express_rate_limit.default)({
 				...limit,
-				handler: rateLimitHandler(enumPath)
+				handler: require_rateLimitHandler.rateLimitHandler(env.logger, enumPath)
 			}));
 		}
 	}
@@ -222,7 +213,7 @@ async function startProviderApi(env, admin = false, port) {
 	apiApp.use(require_ja4Middleware.ja4Middleware(env));
 	apiApp.use(require_handshakeTimingMiddleware.handshakeTimingMiddleware(env));
 	apiApp.use(require_rawTlsSignalsMiddleware.rawTlsSignalsMiddleware(env));
-	apiApp.use(require_ipInfoMiddleware.ipInfoMiddleware(env));
+	apiApp.use(require_ipInfoMiddleware.ipInfoMiddleware(env, new Set(getServerVerifyPaths())));
 	apiApp.use(clientPathsExcludingVerify, require_headerCheckMiddleware.headerCheckMiddleware(env));
 	apiApp.use(require_verify.prosopoVerifyRouter(env));
 	env.logger.info(() => ({ msg: "Enabling admin auth middleware" }));
@@ -270,6 +261,7 @@ async function startProviderApi(env, admin = false, port) {
 }
 //#endregion
 exports.getClientApiPathsExpectingProsopoHeaders = getClientApiPathsExpectingProsopoHeaders;
+exports.getServerVerifyPaths = getServerVerifyPaths;
 exports.getUserFromJWT = getUserFromJWT;
 exports.isTlsAvailable = isTlsAvailable;
 exports.providerCorsOptions = providerCorsOptions;

package/dist/cjs/api/validateAddress.cjs

@@ -1,27 +1,21 @@
 let _prosopo_common = require("@prosopo/common");
 let _prosopo_util_crypto = require("@prosopo/util-crypto");
 //#region src/api/validateAddress.ts
-var validateSiteKey = (siteKey, logger) => {
-	return validateAddr(siteKey, "API.INVALID_SITE_KEY", logger);
-};
-var validateAddr = (address, translationKey = "CONTRACT.INVALID_ADDRESS", logger) => {
+var validateSiteKey = (siteKey) => validateAddr(siteKey, "SITE_KEY_INVALID");
+var validateAddr = (address, code = "INVALID_REQUEST") => {
+	let valid = false;
+	let cause;
 	try {
-		if (!(0, _prosopo_util_crypto.validateAddress)(address, false, 42)) throw new _prosopo_common.ProsopoApiError(translationKey, {
-			context: {
-				code: 400,
-				siteKey: address
-			},
-			logger
-		});
+		valid = (0, _prosopo_util_crypto.validateAddress)(address, false, 42);
 	} catch (err) {
-		throw new _prosopo_common.ProsopoApiError(translationKey, {
-			context: {
-				code: 400,
-				siteKey: address
-			},
-			logger
-		});
+		cause = err;
 	}
+	if (!valid) throw new _prosopo_common.ProsopoError({
+		code,
+		errorSite: "PROV-35",
+		cause,
+		context: { siteKey: address }
+	});
 };
 //#endregion
 exports.validateAddr = validateAddr;