@prosopo/provider 4.15.14 → 4.15.16

package/dist/api/captcha.js

@@ -1,63 +1,81 @@
-import { handleErrors } from "@prosopo/api-express-router";
+import checkSpamEmail_default from "./captcha/checkSpamEmail.js";
+import handler_default from "./captcha/getFrictionlessCaptchaChallenge/handler.js";
+import getImageCaptchaChallenge_default from "./captcha/getImageCaptchaChallenge.js";
+import getPoWCaptchaChallenge_default from "./captcha/getPoWCaptchaChallenge.js";
+import getPuzzleCaptchaChallenge_default from "./captcha/getPuzzleCaptchaChallenge.js";
+import submitImageCaptchaSolution_default from "./captcha/submitImageCaptchaSolution.js";
+import submitPoWCaptchaSolution_default from "./captcha/submitPoWCaptchaSolution.js";
+import submitPuzzleCaptchaSolution_default from "./captcha/submitPuzzleCaptchaSolution.js";
 import { ClientApiPaths } from "@prosopo/types";
+import { handleErrors } from "@prosopo/api-express-router";
 import express from "express";
-import checkSpamEmail from "./captcha/checkSpamEmail.js";
-import "./captcha/getFrictionlessCaptchaChallenge.js";
-import getImageCaptchaChallenge from "./captcha/getImageCaptchaChallenge.js";
-import getPoWCaptchaChallenge from "./captcha/getPoWCaptchaChallenge.js";
-import getPuzzleCaptchaChallenge from "./captcha/getPuzzleCaptchaChallenge.js";
-import submitImageCaptchaSolution from "./captcha/submitImageCaptchaSolution.js";
-import submitPoWCaptchaSolution from "./captcha/submitPoWCaptchaSolution.js";
-import submitPuzzleCaptchaSolution from "./captcha/submitPuzzleCaptchaSolution.js";
-import getFrictionlessCaptchaChallenge from "./captcha/getFrictionlessCaptchaChallenge/handler.js";
-const asyncHandler = (handler) => (req, res, next) => {
-  Promise.resolve().then(() => handler(req, res, next)).catch(next);
+//#region src/api/captcha.ts
+/**
+* Wraps an async route handler so that any rejection - including synchronous
+* throws (e.g. from validateSiteKey/validateAddr) that become rejected
+* promises inside the async handler - is forwarded to Express's error handler.
+* Without this, Express 4 does not observe the rejection and the request hangs
+* instead of returning the intended 4xx response.
+*
+* The handler is invoked inside `Promise.resolve().then(...)` so that even a
+* truly synchronous throw (from a non-async handler) is captured as a rejected
+* promise and forwarded to `next`, rather than propagating synchronously.
+*/
+var asyncHandler = (handler) => (req, res, next) => {
+	Promise.resolve().then(() => handler(req, res, next)).catch(next);
 };
+/**
+* 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 {ProviderEnvironment} env - The Prosopo environment
+*/
 function prosopoRouter(env) {
-  const router = express.Router();
-  let userAccessRulesStorage;
-  try {
-    userAccessRulesStorage = env.getDb().getUserAccessRulesStorage();
-  } catch (err) {
-    env.logger.warn(() => ({
-      msg: "User access rules storage unavailable; captcha endpoints will skip access-policy checks",
-      err
-    }));
-    userAccessRulesStorage = void 0;
-  }
-  router.post(
-    ClientApiPaths.GetImageCaptchaChallenge,
-    asyncHandler(getImageCaptchaChallenge(env, userAccessRulesStorage))
-  );
-  router.post(
-    ClientApiPaths.SubmitImageCaptchaSolution,
-    asyncHandler(submitImageCaptchaSolution(env))
-  );
-  router.post(
-    ClientApiPaths.GetPowCaptchaChallenge,
-    asyncHandler(getPoWCaptchaChallenge(env, userAccessRulesStorage))
-  );
-  router.post(
-    ClientApiPaths.SubmitPowCaptchaSolution,
-    asyncHandler(submitPoWCaptchaSolution(env))
-  );
-  router.post(
-    ClientApiPaths.GetFrictionlessCaptchaChallenge,
-    asyncHandler(getFrictionlessCaptchaChallenge(env, userAccessRulesStorage))
-  );
-  router.post(
-    ClientApiPaths.GetPuzzleCaptchaChallenge,
-    asyncHandler(getPuzzleCaptchaChallenge(env, userAccessRulesStorage))
-  );
-  router.post(
-    ClientApiPaths.SubmitPuzzleCaptchaSolution,
-    asyncHandler(submitPuzzleCaptchaSolution(env))
-  );
-  router.post(ClientApiPaths.CheckSpamEmail, asyncHandler(checkSpamEmail(env)));
-  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; captcha endpoints will skip access-policy checks",
+			err
+		}));
+		userAccessRulesStorage = void 0;
+	}
+	/**
+	* Provides a Captcha puzzle to a Dapp User
+	*/
+	router.post(ClientApiPaths.GetImageCaptchaChallenge, asyncHandler(getImageCaptchaChallenge_default(env, userAccessRulesStorage)));
+	/**
+	* Receives solved CAPTCHA challenges from the user, stores to database, and checks against solution commitment
+	*/
+	router.post(ClientApiPaths.SubmitImageCaptchaSolution, asyncHandler(submitImageCaptchaSolution_default(env)));
+	/**
+	* Supplies a PoW challenge to a Dapp User
+	*/
+	router.post(ClientApiPaths.GetPowCaptchaChallenge, asyncHandler(getPoWCaptchaChallenge_default(env, userAccessRulesStorage)));
+	/**
+	* Verifies a user's PoW solution as being approved or not
+	*/
+	router.post(ClientApiPaths.SubmitPowCaptchaSolution, asyncHandler(submitPoWCaptchaSolution_default(env)));
+	/**
+	* Gets a frictionless captcha challenge
+	*/
+	router.post(ClientApiPaths.GetFrictionlessCaptchaChallenge, asyncHandler(handler_default(env, userAccessRulesStorage)));
+	/**
+	* Supplies a Puzzle challenge to a Dapp User
+	*/
+	router.post(ClientApiPaths.GetPuzzleCaptchaChallenge, asyncHandler(getPuzzleCaptchaChallenge_default(env, userAccessRulesStorage)));
+	/**
+	* Verifies a user's Puzzle solution as being approved or not
+	*/
+	router.post(ClientApiPaths.SubmitPuzzleCaptchaSolution, asyncHandler(submitPuzzleCaptchaSolution_default(env)));
+	/**
+	* Checks if an email domain is spam
+	*/
+	router.post(ClientApiPaths.CheckSpamEmail, asyncHandler(checkSpamEmail_default(env)));
+	router.use(handleErrors);
+	return router;
 }
-export {
-  asyncHandler,
-  prosopoRouter
-};
+//#endregion
+export { asyncHandler, prosopoRouter };

package/dist/api/dnsEventUrl.js

@@ -1,25 +1,23 @@
 import { createHmac } from "node:crypto";
-const EXTENSIONS = ["gif", "png", "webp"];
-const buildDnsEventUrl = (sessionId) => {
-  const subzone = process.env.DNS_EVENT_SUBZONE;
-  const secret = process.env.DNS_EVENT_HMAC_SECRET;
-  if (!subzone || !secret) {
-    return void 0;
-  }
-  const path = derivePath(sessionId, secret);
-  const port = process.env.DNS_EVENT_PORT;
-  const host = port ? `${sessionId}.${subzone}:${port}` : `${sessionId}.${subzone}`;
-  return `https://${host}${path}?sid=${sessionId}`;
+//#region src/api/dnsEventUrl.ts
+var EXTENSIONS = [
+	"gif",
+	"png",
+	"webp"
+];
+var buildDnsEventUrl = (sessionId) => {
+	const subzone = process.env.DNS_EVENT_SUBZONE;
+	const secret = process.env.DNS_EVENT_HMAC_SECRET;
+	if (!subzone || !secret) return;
+	const path = derivePath(sessionId, secret);
+	const port = process.env.DNS_EVENT_PORT;
+	return `https://${port ? `${sessionId}.${subzone}:${port}` : `${sessionId}.${subzone}`}${path}?sid=${sessionId}`;
 };
-const derivePath = (sessionId, secret) => {
-  const mac = createHmac("sha256", secret);
-  mac.update(sessionId);
-  const digest = mac.digest();
-  const name = digest.subarray(0, 8).toString("hex");
-  const ext = EXTENSIONS[(digest.at(8) ?? 0) % EXTENSIONS.length];
-  return `/${name}.${ext}`;
-};
-export {
-  buildDnsEventUrl,
-  derivePath
+var derivePath = (sessionId, secret) => {
+	const mac = createHmac("sha256", secret);
+	mac.update(sessionId);
+	const digest = mac.digest();
+	return `/${digest.subarray(0, 8).toString("hex")}.${EXTENSIONS[(digest.at(8) ?? 0) % EXTENSIONS.length]}`;
 };
+//#endregion
+export { buildDnsEventUrl, derivePath };

package/dist/api/domainMiddleware.js

@@ -1,124 +1,113 @@
-import { handleErrors } from "@prosopo/api-express-router";
+import { recordDomainValidation } from "./metrics.js";
+import { Tasks } from "../tasks/tasks.js";
+import { getMaintenanceMode } from "./admin/apiToggleMaintenanceModeEndpoint.js";
+import { isReservedTestSiteKey } from "./testSiteKey.js";
 import { ProsopoApiError } from "@prosopo/common";
-import { parseUrl, decodeGoogleTranslateHost } from "@prosopo/util";
+import { decodeGoogleTranslateHost, parseUrl } from "@prosopo/util";
 import { validateAddress } from "@prosopo/util-crypto";
 import { ZodError } from "zod";
-import "../tasks/index.js";
-import { getMaintenanceMode } from "./admin/apiToggleMaintenanceModeEndpoint.js";
-import { recordDomainValidation } from "./metrics.js";
-import { isReservedTestSiteKey } from "./testSiteKey.js";
-import { Tasks } from "../tasks/tasks.js";
-const domainMiddleware = (env) => {
-  let cachedTasks;
-  return async (req, res, next) => {
-    try {
-      if (getMaintenanceMode()) {
-        req.logger.info(() => ({
-          msg: "Maintenance mode active - skipping domain validation"
-        }));
-        next();
-        return;
-      }
-      if (!cachedTasks) {
-        cachedTasks = new Tasks(env);
-      }
-      const tasks = cachedTasks;
-      const siteKey = req.headers["prosopo-site-key"];
-      if (!siteKey)
-        throw siteKeyNotRegisteredError(
-          req.i18n,
-          "No sitekey provided",
-          req.logger
-        );
-      try {
-        validateAddress(siteKey, false, 42);
-      } catch (err) {
-        throw invalidSiteKeyError(req.i18n, siteKey, req.logger);
-      }
-      if (isReservedTestSiteKey(siteKey)) {
-        recordDomainValidation("test_key");
-        next();
-        return;
-      }
-      const clientSettings = await tasks.db.getClientRecord(siteKey);
-      if (!clientSettings)
-        throw siteKeyNotRegisteredError(req.i18n, siteKey, req.logger);
-      const allowedDomains = clientSettings.settings?.domains;
-      if (!allowedDomains)
-        throw siteKeyInvalidDomainError(
-          req.i18n,
-          siteKey,
-          req.hostname,
-          req.logger
-        );
-      const origin = req.headers.origin;
-      if (!origin)
-        throw unauthorizedOriginError(req.i18n, void 0, req.logger);
-      const candidateOrigins = [origin, ...googleTranslateOrigins(origin)];
-      for (const candidate of candidateOrigins) {
-        for (const domain of allowedDomains) {
-          if (tasks.clientTaskManager.domainPatternMatcher(candidate, domain)) {
-            recordDomainValidation("allowed");
-            next();
-            return;
-          }
-        }
-      }
-      throw unauthorizedOriginError(req.i18n, origin, req.logger);
-    } catch (err) {
-      recordDomainValidation("rejected");
-      if (err instanceof ProsopoApiError || err instanceof ZodError || err instanceof SyntaxError) {
-        handleErrors(err, req, res, next);
-      } else {
-        res.status(401).json({ error: "Unauthorized", message: err });
-        return;
-      }
-    }
-  };
-};
-const googleTranslateOrigins = (origin) => {
-  try {
-    const url = parseUrl(origin);
-    const decodedHost = decodeGoogleTranslateHost(url.hostname);
-    if (!decodedHost) return [];
-    return [`${url.protocol}//${decodedHost}`];
-  } catch {
-    return [];
-  }
+import { handleErrors } from "@prosopo/api-express-router";
+//#region src/api/domainMiddleware.ts
+var domainMiddleware = (env) => {
+	let cachedTasks;
+	return async (req, res, next) => {
+		try {
+			if (getMaintenanceMode()) {
+				req.logger.info(() => ({ msg: "Maintenance mode active - skipping domain validation" }));
+				next();
+				return;
+			}
+			if (!cachedTasks) cachedTasks = new Tasks(env);
+			const tasks = cachedTasks;
+			const siteKey = req.headers["prosopo-site-key"];
+			if (!siteKey) throw siteKeyNotRegisteredError(req.i18n, "No sitekey provided", req.logger);
+			try {
+				validateAddress(siteKey, false, 42);
+			} catch (err) {
+				throw invalidSiteKeyError(req.i18n, siteKey, req.logger);
+			}
+			if (isReservedTestSiteKey(siteKey)) {
+				recordDomainValidation("test_key");
+				next();
+				return;
+			}
+			const clientSettings = await tasks.db.getClientRecord(siteKey);
+			if (!clientSettings) throw siteKeyNotRegisteredError(req.i18n, siteKey, req.logger);
+			const allowedDomains = clientSettings.settings?.domains;
+			if (!allowedDomains) throw siteKeyInvalidDomainError(req.i18n, siteKey, req.hostname, req.logger);
+			const origin = req.headers.origin;
+			if (!origin) throw unauthorizedOriginError(req.i18n, void 0, req.logger);
+			const candidateOrigins = [origin, ...googleTranslateOrigins(origin)];
+			for (const candidate of candidateOrigins) for (const domain of allowedDomains) if (tasks.clientTaskManager.domainPatternMatcher(candidate, domain)) {
+				recordDomainValidation("allowed");
+				next();
+				return;
+			}
+			throw unauthorizedOriginError(req.i18n, origin, req.logger);
+		} catch (err) {
+			recordDomainValidation("rejected");
+			if (err instanceof ProsopoApiError || err instanceof ZodError || err instanceof SyntaxError) handleErrors(err, req, res, next);
+			else {
+				res.status(401).json({
+					error: "Unauthorized",
+					message: err
+				});
+				return;
+			}
+		}
+	};
 };
-const siteKeyNotRegisteredError = (i18n, dapp, logger) => {
-  return new ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
-    context: { code: 400, siteKey: dapp },
-    i18n,
-    logger
-  });
+var googleTranslateOrigins = (origin) => {
+	try {
+		const url = parseUrl(origin);
+		const decodedHost = decodeGoogleTranslateHost(url.hostname);
+		if (!decodedHost) return [];
+		return [`${url.protocol}//${decodedHost}`];
+	} catch {
+		return [];
+	}
 };
-const invalidSiteKeyError = (i18n, siteKey, logger) => {
-  return new ProsopoApiError("API.INVALID_SITE_KEY", {
-    context: { code: 400, siteKey },
-    i18n,
-    logger
-  });
+var siteKeyNotRegisteredError = (i18n, dapp, logger) => {
+	return new ProsopoApiError("API.SITE_KEY_NOT_REGISTERED", {
+		context: {
+			code: 400,
+			siteKey: dapp
+		},
+		i18n,
+		logger
+	});
 };
-const unauthorizedOriginError = (i18n, origin, logger) => {
-  return new ProsopoApiError("API.UNAUTHORIZED_ORIGIN_URL", {
-    context: { code: 400, origin },
-    i18n,
-    logger
-  });
+var invalidSiteKeyError = (i18n, siteKey, logger) => {
+	return new ProsopoApiError("API.INVALID_SITE_KEY", {
+		context: {
+			code: 400,
+			siteKey
+		},
+		i18n,
+		logger
+	});
 };
-const siteKeyInvalidDomainError = (i18n, dapp, domain, logger) => {
-  return new ProsopoApiError("API.UNAUTHORIZED_ORIGIN_URL", {
-    context: {
-      code: 400,
-      message: "No domains are allowed for this site key. Please fix in the Procaptcha Portal",
-      siteKey: dapp,
-      domain
-    },
-    i18n,
-    logger
-  });
+var unauthorizedOriginError = (i18n, origin, logger) => {
+	return new ProsopoApiError("API.UNAUTHORIZED_ORIGIN_URL", {
+		context: {
+			code: 400,
+			origin
+		},
+		i18n,
+		logger
+	});
 };
-export {
-  domainMiddleware
+var siteKeyInvalidDomainError = (i18n, dapp, domain, logger) => {
+	return new ProsopoApiError("API.UNAUTHORIZED_ORIGIN_URL", {
+		context: {
+			code: 400,
+			message: "No domains are allowed for this site key. Please fix in the Procaptcha Portal",
+			siteKey: dapp,
+			domain
+		},
+		i18n,
+		logger
+	});
 };
+//#endregion
+export { domainMiddleware };

package/dist/api/forwardVerify.js

@@ -1,54 +1,68 @@
 import { ProviderApi } from "@prosopo/api";
 import { getProviders } from "@prosopo/load-balancer";
+//#region src/api/forwardVerify.ts
+/**
+* A client can send a verify request to *any* pronode, not necessarily the
+* provider that issued the token. This determines the issuing provider from the
+* `providerUrl` embedded in the token and, when it is a *different* provider to
+* this one, forwards the verification request to it and returns its response —
+* mirroring the AWS Lambda verify endpoint, but running on a provider.
+*
+* Returns `null` when this provider is the issuer (or the issuer cannot be
+* determined), signalling the caller to verify locally as before.
+*
+* @param env - The provider environment
+* @param logger - Request-scoped logger
+* @param path - The verify path to forward to (kept identical, so the issuer
+*   routes the request to the correct captcha-type verification)
+* @param providerUrl - The issuing provider url, decoded from the token
+* @param dapp - The site key (used as the `Prosopo-Site-Key` header)
+* @param user - The user account (used as the `Prosopo-User` header)
+* @param body - The original, already-parsed request body, forwarded verbatim
+*/
 function normalizeProviderUrl(url) {
-  try {
-    const parsed = new URL(url);
-    parsed.hostname = parsed.hostname.replace(/^(ipv4|ipv6)\./, "");
-    return parsed.toString().replace(/\/$/, "");
-  } catch {
-    return url.replace(/\/$/, "");
-  }
+	try {
+		const parsed = new URL(url);
+		parsed.hostname = parsed.hostname.replace(/^(ipv4|ipv6)\./, "");
+		return parsed.toString().replace(/\/$/, "");
+	} catch {
+		return url.replace(/\/$/, "");
+	}
 }
 async function forwardVerifyIfNotIssuer(args) {
-  const { env, logger, path, providerUrl, dapp, user, body, alreadyForwarded } = args;
-  if (alreadyForwarded) {
-    return null;
-  }
-  if (!providerUrl) {
-    return null;
-  }
-  let providers;
-  try {
-    providers = await getProviders(env.defaultEnvironment);
-  } catch (error) {
-    logger.warn(() => ({
-      msg: "Failed to load provider list; verifying locally",
-      err: error instanceof Error ? error : new Error(String(error)),
-      data: { providerUrl }
-    }));
-    return null;
-  }
-  const normalizedProviderUrl = normalizeProviderUrl(providerUrl);
-  const issuer = providers.find(
-    (provider) => normalizeProviderUrl(provider.url) === normalizedProviderUrl
-  );
-  if (!issuer) {
-    logger.warn(() => ({
-      msg: "Token providerUrl is not a known provider; verifying locally",
-      data: { providerUrl }
-    }));
-    return null;
-  }
-  if (env.pair?.address && issuer.address === env.pair.address) {
-    return null;
-  }
-  logger.info(() => ({
-    msg: "Forwarding verify request to issuing provider",
-    data: { providerUrl, path, dapp }
-  }));
-  const providerApi = new ProviderApi(issuer.url, dapp);
-  return providerApi.forwardVerify(path, body, user);
+	const { env, logger, path, providerUrl, dapp, user, body, alreadyForwarded } = args;
+	if (alreadyForwarded) return null;
+	if (!providerUrl) return null;
+	let providers;
+	try {
+		providers = await getProviders(env.defaultEnvironment);
+	} catch (error) {
+		logger.warn(() => ({
+			msg: "Failed to load provider list; verifying locally",
+			err: error instanceof Error ? error : new Error(String(error)),
+			data: { providerUrl }
+		}));
+		return null;
+	}
+	const normalizedProviderUrl = normalizeProviderUrl(providerUrl);
+	const issuer = providers.find((provider) => normalizeProviderUrl(provider.url) === normalizedProviderUrl);
+	if (!issuer) {
+		logger.warn(() => ({
+			msg: "Token providerUrl is not a known provider; verifying locally",
+			data: { providerUrl }
+		}));
+		return null;
+	}
+	if (env.pair?.address && issuer.address === env.pair.address) return null;
+	logger.info(() => ({
+		msg: "Forwarding verify request to issuing provider",
+		data: {
+			providerUrl,
+			path,
+			dapp
+		}
+	}));
+	return new ProviderApi(issuer.url, dapp).forwardVerify(path, body, user);
 }
-export {
-  forwardVerifyIfNotIssuer
-};
+//#endregion
+export { forwardVerifyIfNotIssuer };

package/dist/api/handshakeTimingMiddleware.js

@@ -1,66 +1,47 @@
-import { handleErrors } from "@prosopo/api-express-router";
 import { getLogger } from "@prosopo/logger";
-const HEADER_TCP_TO_CHELLO = "x-tls-tcp-to-chello-us";
-const HEADER_CHELLO_TO_HANDSHAKE = "x-tls-chello-to-handshake-us";
-const parseTimingHeader = (raw, logger, headerName) => {
-  if (raw === void 0) {
-    return void 0;
-  }
-  const value = Array.isArray(raw) ? raw[0] : raw;
-  if (value === void 0) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (Number.isNaN(parsed) || parsed < 0) {
-    logger.debug(() => ({
-      msg: "Ignoring malformed handshake timing header",
-      data: { header: headerName, raw: value }
-    }));
-    return void 0;
-  }
-  return parsed;
-};
-const getHandshakeTiming = (headers, logger) => {
-  const log = logger ?? getLogger("info", "provider:handshake-timing");
-  return {
-    tcpToChelloUs: parseTimingHeader(
-      headers[HEADER_TCP_TO_CHELLO],
-      log,
-      HEADER_TCP_TO_CHELLO
-    ),
-    chelloToHandshakeUs: parseTimingHeader(
-      headers[HEADER_CHELLO_TO_HANDSHAKE],
-      log,
-      HEADER_CHELLO_TO_HANDSHAKE
-    )
-  };
+import { handleErrors } from "@prosopo/api-express-router";
+//#region src/api/handshakeTimingMiddleware.ts
+var HEADER_TCP_TO_CHELLO = "x-tls-tcp-to-chello-us";
+var HEADER_CHELLO_TO_HANDSHAKE = "x-tls-chello-to-handshake-us";
+var parseTimingHeader = (raw, logger, headerName) => {
+	if (raw === void 0) return;
+	const value = Array.isArray(raw) ? raw[0] : raw;
+	if (value === void 0) return;
+	const parsed = Number.parseInt(value, 10);
+	if (Number.isNaN(parsed) || parsed < 0) {
+		logger.debug(() => ({
+			msg: "Ignoring malformed handshake timing header",
+			data: {
+				header: headerName,
+				raw: value
+			}
+		}));
+		return;
+	}
+	return parsed;
 };
-const handshakeTimingMiddleware = (env) => {
-  return async (req, res, next) => {
-    try {
-      const timing = getHandshakeTiming(req.headers, req.logger);
-      if (timing.tcpToChelloUs !== void 0) {
-        req.tcpToChelloUs = timing.tcpToChelloUs;
-      }
-      if (timing.chelloToHandshakeUs !== void 0) {
-        req.chelloToHandshakeUs = timing.chelloToHandshakeUs;
-      }
-      if (timing.tcpToChelloUs !== void 0 || timing.chelloToHandshakeUs !== void 0) {
-        req.logger = req.logger.with(
-          {
-            tcpToChelloUs: timing.tcpToChelloUs,
-            chelloToHandshakeUs: timing.chelloToHandshakeUs
-          },
-          "handshakeTiming"
-        );
-      }
-      next();
-    } catch (err) {
-      return handleErrors(err, req, res, next);
-    }
-  };
+var getHandshakeTiming = (headers, logger) => {
+	const log = logger ?? getLogger("info", "provider:handshake-timing");
+	return {
+		tcpToChelloUs: parseTimingHeader(headers[HEADER_TCP_TO_CHELLO], log, HEADER_TCP_TO_CHELLO),
+		chelloToHandshakeUs: parseTimingHeader(headers[HEADER_CHELLO_TO_HANDSHAKE], log, HEADER_CHELLO_TO_HANDSHAKE)
+	};
 };
-export {
-  getHandshakeTiming,
-  handshakeTimingMiddleware
+var handshakeTimingMiddleware = (env) => {
+	return async (req, res, next) => {
+		try {
+			const timing = getHandshakeTiming(req.headers, req.logger);
+			if (timing.tcpToChelloUs !== void 0) req.tcpToChelloUs = timing.tcpToChelloUs;
+			if (timing.chelloToHandshakeUs !== void 0) req.chelloToHandshakeUs = timing.chelloToHandshakeUs;
+			if (timing.tcpToChelloUs !== void 0 || timing.chelloToHandshakeUs !== void 0) req.logger = req.logger.with({
+				tcpToChelloUs: timing.tcpToChelloUs,
+				chelloToHandshakeUs: timing.chelloToHandshakeUs
+			}, "handshakeTiming");
+			next();
+		} catch (err) {
+			return handleErrors(err, req, res, next);
+		}
+	};
 };
+//#endregion
+export { getHandshakeTiming, handshakeTimingMiddleware };