@prosopo/provider 4.15.13 → 4.15.15

package/dist/cjs/api/startProviderApi.cjs

@@ -1,245 +1,227 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const fs = require("node:fs");
-const https = require("node:https");
-const path = require("node:path");
-const node_url = require("node:url");
-const apiExpressRouter = require("@prosopo/api-express-router");
-const locale = require("@prosopo/locale");
-const logger = require("@prosopo/logger");
-const types = require("@prosopo/types");
-const api = require("@prosopo/user-access-policy/api");
-const cors = require("cors");
-const express = require("express");
-const rateLimit = require("express-rate-limit");
-const createApiAdminRoutesProvider = require("./admin/createApiAdminRoutesProvider.cjs");
-const blacklistRequestInspector = require("./blacklistRequestInspector.cjs");
-const block = require("./block.cjs");
-const captcha = require("./captcha.cjs");
-const domainMiddleware = require("./domainMiddleware.cjs");
-const handshakeTimingMiddleware = require("./handshakeTimingMiddleware.cjs");
-const headerCheckMiddleware = require("./headerCheckMiddleware.cjs");
-const ignoreMiddleware = require("./ignoreMiddleware.cjs");
-const ipInfoMiddleware = require("./ipInfoMiddleware.cjs");
-const ja4Middleware = require("./ja4Middleware.cjs");
-const metrics = require("./metrics.cjs");
-const _public = require("./public.cjs");
-const robotsMiddleware = require("./robotsMiddleware.cjs");
-const verify = require("./verify.cjs");
-var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
-const __dirname$1 = path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("api/startProviderApi.cjs", document.baseURI).href));
-const certPath = path.resolve(__dirname$1, "../../../../certs");
-const keyPath = path.join(certPath, "server.key");
-const crtPath = path.join(certPath, "server.crt");
-const isTlsAvailable = () => {
-  return fs.existsSync(keyPath) && fs.existsSync(crtPath);
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_metrics = require("./metrics.cjs");
+const require_blacklistRequestInspector = require("./blacklistRequestInspector.cjs");
+const require_block = require("./block.cjs");
+const require_captcha = require("./captcha.cjs");
+const require_verify = require("./verify.cjs");
+const require_ja4Middleware = require("./ja4Middleware.cjs");
+const require_handshakeTimingMiddleware = require("./handshakeTimingMiddleware.cjs");
+const require_public = require("./public.cjs");
+const require_domainMiddleware = require("./domainMiddleware.cjs");
+const require_createApiAdminRoutesProvider = require("./admin/createApiAdminRoutesProvider.cjs");
+const require_headerCheckMiddleware = require("./headerCheckMiddleware.cjs");
+const require_ignoreMiddleware = require("./ignoreMiddleware.cjs");
+const require_ipInfoMiddleware = require("./ipInfoMiddleware.cjs");
+const require_robotsMiddleware = require("./robotsMiddleware.cjs");
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_types = require("@prosopo/types");
+let node_https = require("node:https");
+node_https = require_runtime.__toESM(node_https, 1);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let _prosopo_api_express_router = require("@prosopo/api-express-router");
+let express = require("express");
+express = require_runtime.__toESM(express, 1);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_url = require("node:url");
+let _prosopo_locale = require("@prosopo/locale");
+let _prosopo_user_access_policy_api = require("@prosopo/user-access-policy/api");
+let cors = require("cors");
+cors = require_runtime.__toESM(cors, 1);
+let express_rate_limit = require("express-rate-limit");
+express_rate_limit = require_runtime.__toESM(express_rate_limit, 1);
+//#region src/api/startProviderApi.ts
+var __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+var certPath = node_path.default.resolve(__dirname$1, "../../../../certs");
+var keyPath = node_path.default.join(certPath, "server.key");
+var crtPath = node_path.default.join(certPath, "server.crt");
+/**
+* Check if TLS certificates are available
+* @returns True if both key and cert files exist
+*/
+var isTlsAvailable = () => {
+	return node_fs.default.existsSync(keyPath) && node_fs.default.existsSync(crtPath);
 };
-const getClientApiPathsExpectingProsopoHeaders = () => {
-  const paths = Object.values(types.ClientApiPaths).filter(
-    (path2) => path2.indexOf("verify") === -1 && path2.indexOf("spam") === -1
-  );
-  return paths;
+/**
+* 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
+*/
+var getClientApiPathsExpectingProsopoHeaders = () => {
+	return Object.values(_prosopo_types.ClientApiPaths).filter((path) => path.indexOf("verify") === -1 && path.indexOf("spam") === -1);
 };
-const getUserFromJWT = (req) => {
-  try {
-    const authHeader = req.headers.Authorization || req.headers.authorization;
-    if (!authHeader || typeof authHeader !== "string") {
-      return void 0;
-    }
-    const jwt = authHeader.replace("Bearer ", "");
-    if (!jwt) {
-      return void 0;
-    }
-    const parts = jwt.split(".");
-    if (parts.length !== 3 || !parts[1]) {
-      return void 0;
-    }
-    const payload = JSON.parse(
-      Buffer.from(parts[1], "base64url").toString("utf-8")
-    );
-    return payload.sub;
-  } catch (e) {
-    return void 0;
-  }
+/**
+* Extract authenticated user address from JWT for rate limiting
+* @param req Express request object
+* @returns User address from JWT or undefined
+*/
+var getUserFromJWT = (req) => {
+	try {
+		const authHeader = req.headers.Authorization || req.headers.authorization;
+		if (!authHeader || typeof authHeader !== "string") return;
+		const jwt = authHeader.replace("Bearer ", "");
+		if (!jwt) return;
+		const parts = jwt.split(".");
+		if (parts.length !== 3 || !parts[1]) return;
+		return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8")).sub;
+	} catch (e) {
+		return;
+	}
 };
+/**
+* Start the Prosopo Provider API server
+*
+* This function creates and configures an Express server with all necessary middleware
+* for the Prosopo Provider API, including:
+* - CORS support
+* - Rate limiting (disabled in test/development environments)
+* - Authentication and authorization
+* - Request validation (headers, domains, etc.)
+* - Blocking and security middleware
+* - Admin and client API routes
+* - Access rule management
+*
+* @param env - The ProviderEnvironment containing configuration and database connections
+* @param admin - Whether to enable admin mode (currently unused, kept for compatibility)
+* @param port - Optional port override. If not provided, uses env.config.server.port
+* @returns Promise<Server> - The Node.js HTTP server instance
+*
+* @example
+* ```typescript
+* const env = new ProviderEnvironment(config);
+* await env.isReady();
+* const server = await startProviderApi(env);
+* ```
+*/
 async function startProviderApi(env, admin = false, port) {
-  env.logger.info(() => ({ msg: "Starting Prosopo API" }));
-  const apiApp = express();
-  const apiPort = port || env.config.server?.port;
-  const apiEndpointAdapter = apiExpressRouter.createApiExpressDefaultEndpointAdapter(
-    logger.parseLogLevel(env.config.logLevel)
-  );
-  let apiRuleRoutesProvider;
-  let apiAdminRoutesProvider;
-  try {
-    apiRuleRoutesProvider = new api.AccessRuleApiRoutes(
-      env.getDb().getUserAccessRulesStorage(),
-      env.logger
-    );
-    apiAdminRoutesProvider = createApiAdminRoutesProvider.createApiAdminRoutesProvider(env);
-  } catch (err) {
-    env.logger.warn(() => ({
-      msg: "Skipping admin/access-rule routes; DB unavailable",
-      err
-    }));
-  }
-  const clientPathsExcludingVerify = getClientApiPathsExpectingProsopoHeaders();
-  env.logger.debug(() => ({
-    msg: "Adding headerCheckMiddleware",
-    paths: clientPathsExcludingVerify
-  }));
-  apiApp.set("trust proxy", 1);
-  apiApp.use(
-    cors({
-      exposedHeaders: ["x-prosopo-meta"],
-      allowedHeaders: [
-        "Accept",
-        "Accept-Language",
-        "Authorization",
-        "Content-Language",
-        "Content-Type",
-        "Prosopo-Site-Key",
-        "Prosopo-User",
-        "x-prosopo-meta"
-      ],
-      maxAge: 86400
-    })
-  );
-  apiApp.use(express.json({ limit: "1mb" }));
-  apiApp.use(_public.publicRouter(env));
-  apiApp.use(metrics.metricsMiddleware());
-  const isTestOrDevelopmentEnv = process.env.NODE_ENV === "test" || env.config.defaultEnvironment === "development";
-  if (!isTestOrDevelopmentEnv) {
-    const configRateLimits = env.config.rateLimits;
-    const rateLimits = {
-      ...configRateLimits,
-      ...api.getExpressApiRuleRateLimits()
-    };
-    const adminPaths = Object.values(types.AdminApiPaths);
-    const rateLimitHandler = (path2) => (req, res, _next, options) => {
-      env.logger.warn(() => ({
-        msg: "Rate limit exceeded",
-        data: {
-          path: path2,
-          ip: req.ip,
-          siteKey: req.headers["prosopo-site-key"]
-        }
-      }));
-      res.status(options.statusCode).send(options.message);
-    };
-    for (const [path2, limit] of Object.entries(rateLimits)) {
-      const enumPath = path2;
-      if (adminPaths.includes(enumPath)) {
-        apiApp.use(
-          enumPath,
-          rateLimit({
-            ...limit,
-            handler: rateLimitHandler(enumPath),
-            keyGenerator: (req) => {
-              const user = getUserFromJWT(req);
-              return user || req.ip || "unknown";
-            }
-          })
-        );
-      } else if (path2 === types.ClientApiPaths.VerifyImageCaptchaSolutionDapp || path2 === types.ClientApiPaths.VerifyPowCaptchaSolution) {
-        apiApp.use(
-          enumPath,
-          rateLimit({
-            ...limit,
-            handler: rateLimitHandler(enumPath),
-            keyGenerator: (req) => {
-              const siteKey = req.headers["prosopo-site-key"];
-              return siteKey || req.ip || "unknown";
-            }
-          })
-        );
-      } else {
-        apiApp.use(
-          enumPath,
-          rateLimit({ ...limit, handler: rateLimitHandler(enumPath) })
-        );
-      }
-    }
-  }
-  const i18Middleware = await locale.i18nMiddleware({});
-  apiApp.use(robotsMiddleware.robotsMiddleware());
-  apiApp.use(ignoreMiddleware.ignoreMiddleware());
-  apiApp.use(apiExpressRouter.requestLoggerMiddleware(env));
-  apiApp.use(i18Middleware);
-  apiApp.use(ja4Middleware.ja4Middleware(env));
-  apiApp.use(handshakeTimingMiddleware.handshakeTimingMiddleware(env));
-  apiApp.use(ipInfoMiddleware.ipInfoMiddleware(env));
-  apiApp.use(clientPathsExcludingVerify, headerCheckMiddleware.headerCheckMiddleware(env));
-  apiApp.use(verify.prosopoVerifyRouter(env));
-  env.logger.info(() => ({ msg: "Enabling admin auth middleware" }));
-  apiApp.use(
-    "/v1/prosopo/provider/admin",
-    apiExpressRouter.authMiddleware(env.pair, env.authAccount)
-  );
-  if (apiRuleRoutesProvider) {
-    const userAccessRuleRoutes = apiRuleRoutesProvider.getRoutes();
-    for (const userAccessRuleRoute in userAccessRuleRoutes) {
-      apiApp.use(
-        userAccessRuleRoute,
-        apiExpressRouter.authMiddleware(env.pair, env.authAccount)
-      );
-    }
-    for (const userAccessRuleRoute in userAccessRuleRoutes) {
-      apiApp.use(userAccessRuleRoute, (req, res, next) => {
-        if (req.method === "POST") {
-          res.on("finish", () => {
-            if (res.statusCode >= 200 && res.statusCode < 300) {
-              blacklistRequestInspector.getVerdictCache().clear();
-            }
-          });
-        }
-        next();
-      });
-    }
-    apiApp.use(
-      apiExpressRouter.apiExpressRouterFactory.createRouter(
-        apiRuleRoutesProvider,
-        apiEndpointAdapter
-      )
-    );
-  }
-  if (apiAdminRoutesProvider) {
-    apiApp.use(
-      apiExpressRouter.apiExpressRouterFactory.createRouter(
-        apiAdminRoutesProvider,
-        // unlike the default one, it should have errorStatusCode as 400
-        apiExpressRouter.createApiExpressDefaultEndpointAdapter(
-          logger.parseLogLevel(env.config.logLevel),
-          400
-        )
-      )
-    );
-  }
-  apiApp.use(block.blockMiddleware(env));
-  apiApp.use("/v1/prosopo/provider/client/", domainMiddleware.domainMiddleware(env));
-  apiApp.use(captcha.prosopoRouter(env));
-  const useTls = fs.existsSync(keyPath) && fs.existsSync(crtPath);
-  if (useTls) {
-    env.logger.info(() => ({ msg: "Starting Provider API with HTTPS" }));
-    const httpsOptions = {
-      key: fs.readFileSync(keyPath),
-      cert: fs.readFileSync(crtPath)
-    };
-    const httpsServer = https.createServer(httpsOptions, apiApp);
-    return httpsServer.listen(apiPort, () => {
-      env.logger.info(() => ({
-        data: { apiPort, protocol: "https" },
-        msg: "Prosopo app listening with HTTPS"
-      }));
-    });
-  }
-  return apiApp.listen(apiPort, () => {
-    env.logger.info(() => ({
-      data: { apiPort },
-      msg: "Prosopo app listening"
-    }));
-  });
+	env.logger.info(() => ({ msg: "Starting Prosopo API" }));
+	const apiApp = (0, express.default)();
+	const apiPort = port || env.config.server?.port;
+	const apiEndpointAdapter = (0, _prosopo_api_express_router.createApiExpressDefaultEndpointAdapter)((0, _prosopo_logger.parseLogLevel)(env.config.logLevel));
+	let apiRuleRoutesProvider;
+	let apiAdminRoutesProvider;
+	try {
+		apiRuleRoutesProvider = new _prosopo_user_access_policy_api.AccessRuleApiRoutes(env.getDb().getUserAccessRulesStorage(), env.logger);
+		apiAdminRoutesProvider = require_createApiAdminRoutesProvider.createApiAdminRoutesProvider(env);
+	} catch (err) {
+		env.logger.warn(() => ({
+			msg: "Skipping admin/access-rule routes; DB unavailable",
+			err
+		}));
+	}
+	const clientPathsExcludingVerify = getClientApiPathsExpectingProsopoHeaders();
+	env.logger.debug(() => ({
+		msg: "Adding headerCheckMiddleware",
+		paths: clientPathsExcludingVerify
+	}));
+	apiApp.set("trust proxy", 1);
+	apiApp.use((0, cors.default)({
+		exposedHeaders: ["x-prosopo-meta"],
+		allowedHeaders: [
+			"Accept",
+			"Accept-Language",
+			"Authorization",
+			"Content-Language",
+			"Content-Type",
+			"Prosopo-Site-Key",
+			"Prosopo-User",
+			"x-prosopo-meta"
+		],
+		maxAge: 86400
+	}));
+	apiApp.use(express.default.json({ limit: "1mb" }));
+	apiApp.use(require_public.publicRouter(env));
+	apiApp.use(require_metrics.metricsMiddleware());
+	if (!(process.env.NODE_ENV === "test" || env.config.defaultEnvironment === "development")) {
+		const rateLimits = {
+			...env.config.rateLimits,
+			...(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),
+				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),
+				keyGenerator: (req) => {
+					return req.headers["prosopo-site-key"] || req.ip || "unknown";
+				}
+			}));
+			else apiApp.use(enumPath, (0, express_rate_limit.default)({
+				...limit,
+				handler: rateLimitHandler(enumPath)
+			}));
+		}
+	}
+	const i18Middleware = await (0, _prosopo_locale.i18nMiddleware)({});
+	apiApp.use(require_robotsMiddleware.robotsMiddleware());
+	apiApp.use(require_ignoreMiddleware.ignoreMiddleware());
+	apiApp.use((0, _prosopo_api_express_router.requestLoggerMiddleware)(env));
+	apiApp.use(i18Middleware);
+	apiApp.use(require_ja4Middleware.ja4Middleware(env));
+	apiApp.use(require_handshakeTimingMiddleware.handshakeTimingMiddleware(env));
+	apiApp.use(require_ipInfoMiddleware.ipInfoMiddleware(env));
+	apiApp.use(clientPathsExcludingVerify, require_headerCheckMiddleware.headerCheckMiddleware(env));
+	apiApp.use(require_verify.prosopoVerifyRouter(env));
+	env.logger.info(() => ({ msg: "Enabling admin auth middleware" }));
+	apiApp.use("/v1/prosopo/provider/admin", (0, _prosopo_api_express_router.authMiddleware)(env.pair, env.authAccount));
+	if (apiRuleRoutesProvider) {
+		const userAccessRuleRoutes = apiRuleRoutesProvider.getRoutes();
+		for (const userAccessRuleRoute in userAccessRuleRoutes) apiApp.use(userAccessRuleRoute, (0, _prosopo_api_express_router.authMiddleware)(env.pair, env.authAccount));
+		for (const userAccessRuleRoute in userAccessRuleRoutes) apiApp.use(userAccessRuleRoute, (req, res, next) => {
+			if (req.method === "POST") res.on("finish", () => {
+				if (res.statusCode >= 200 && res.statusCode < 300) require_blacklistRequestInspector.getVerdictCache().clear();
+			});
+			next();
+		});
+		apiApp.use(_prosopo_api_express_router.apiExpressRouterFactory.createRouter(apiRuleRoutesProvider, apiEndpointAdapter));
+	}
+	if (apiAdminRoutesProvider) apiApp.use(_prosopo_api_express_router.apiExpressRouterFactory.createRouter(apiAdminRoutesProvider, (0, _prosopo_api_express_router.createApiExpressDefaultEndpointAdapter)((0, _prosopo_logger.parseLogLevel)(env.config.logLevel), 400)));
+	apiApp.use(require_block.blockMiddleware(env));
+	apiApp.use("/v1/prosopo/provider/client/", require_domainMiddleware.domainMiddleware(env));
+	apiApp.use(require_captcha.prosopoRouter(env));
+	if (node_fs.default.existsSync(keyPath) && node_fs.default.existsSync(crtPath)) {
+		env.logger.info(() => ({ msg: "Starting Provider API with HTTPS" }));
+		const httpsOptions = {
+			key: node_fs.default.readFileSync(keyPath),
+			cert: node_fs.default.readFileSync(crtPath)
+		};
+		return node_https.default.createServer(httpsOptions, apiApp).listen(apiPort, () => {
+			env.logger.info(() => ({
+				data: {
+					apiPort,
+					protocol: "https"
+				},
+				msg: "Prosopo app listening with HTTPS"
+			}));
+		});
+	}
+	return apiApp.listen(apiPort, () => {
+		env.logger.info(() => ({
+			data: { apiPort },
+			msg: "Prosopo app listening"
+		}));
+	});
 }
+//#endregion
 exports.getClientApiPathsExpectingProsopoHeaders = getClientApiPathsExpectingProsopoHeaders;
 exports.getUserFromJWT = getUserFromJWT;
 exports.isTlsAvailable = isTlsAvailable;

package/dist/cjs/api/testSiteKey.cjs

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

package/dist/cjs/api/validateAddress.cjs

@@ -1,25 +1,28 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const utilCrypto = require("@prosopo/util-crypto");
-const validateSiteKey = (siteKey, logger) => {
-  return validateAddr(siteKey, "API.INVALID_SITE_KEY", logger);
+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);
 };
-const validateAddr = (address, translationKey = "CONTRACT.INVALID_ADDRESS", logger) => {
-  try {
-    const valid = utilCrypto.validateAddress(address, false, 42);
-    if (!valid) {
-      throw new common.ProsopoApiError(translationKey, {
-        context: { code: 400, siteKey: address },
-        logger
-      });
-    }
-  } catch (err) {
-    throw new common.ProsopoApiError(translationKey, {
-      context: { code: 400, siteKey: address },
-      logger
-    });
-  }
+var validateAddr = (address, translationKey = "CONTRACT.INVALID_ADDRESS", logger) => {
+	try {
+		if (!(0, _prosopo_util_crypto.validateAddress)(address, false, 42)) throw new _prosopo_common.ProsopoApiError(translationKey, {
+			context: {
+				code: 400,
+				siteKey: address
+			},
+			logger
+		});
+	} catch (err) {
+		throw new _prosopo_common.ProsopoApiError(translationKey, {
+			context: {
+				code: 400,
+				siteKey: address
+			},
+			logger
+		});
+	}
 };
+//#endregion
 exports.validateAddr = validateAddr;
 exports.validateSiteKey = validateSiteKey;