Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
refactor(gateways): rename setupRelayServer to setupGatewayProxy
bernie-g3805b9e19b84
diff --git a/backend/src/ee/services/pam-web-access/pam-web-access-service.ts b/backend/src/ee/services/pam-web-access/pam-web-access-service.tsindex d0ed5164b6..9963e50152 100644--- a/backend/src/ee/services/pam-web-access/pam-web-access-service.ts+++ b/backend/src/ee/services/pam-web-access/pam-web-access-service.ts@@ -13,7 +13,7 @@ import { TPermissionServiceFactory } from "@app/ee/services/permission/permissioimport { ResourcePermissionPamResourceActions } from "@app/ee/services/permission/resource-permission";import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";import { GatewayProxyProtocol } from "@app/lib/gateway/types";-import { setupRelayServer, withGatewayV2Proxy } from "@app/lib/gateway-v2/gateway-v2";+import { setupGatewayProxy, withGatewayV2Proxy } from "@app/lib/gateway-v2/gateway-v2";import { logger } from "@app/lib/logger";import { ActorType } from "@app/services/auth/auth-type";import { TAuthTokenServiceFactory } from "@app/services/auth-token/auth-token-service";@@ -326,7 +326,7 @@ export const pamWebAccessServiceFactory = ({let session: { id: string; accountId?: string | null } | null = null;let cleanedUp = false;let handlerResult: TSessionHandlerResult | null = null;- let relayServer: { port: number; cleanup: () => Promise<void> } | null = null;+ let proxyServer: { port: number; cleanup: () => Promise<void> } | null = null;let relayCerts: TGatewayV2ConnectionDetails | null = null;let expiryTimer: ReturnType<typeof setTimeout> | null = null;let pingInterval: ReturnType<typeof setInterval> | null = null;@@ -356,13 +356,13 @@ export const pamWebAccessServiceFactory = ({}}- if (relayServer) {+ if (proxyServer) {try {- await relayServer.cleanup();+ await proxyServer.cleanup();} catch (err) {logger.debug(err, "Error closing relay server");} finally {- relayServer = null;+ proxyServer = null;}}@@ -554,7 +554,7 @@ export const pamWebAccessServiceFactory = ({return {certs: attemptCerts,- server: await setupRelayServer({+ server: await setupGatewayProxy({protocol: isRdp ? GatewayProxyProtocol.PamRdpBrowser : GatewayProxyProtocol.Pam,...attemptCerts,longLived: true,@@ -565,7 +565,7 @@ export const pamWebAccessServiceFactory = ({);const { certs } = attempt.result;- relayServer = attempt.result.server;+ proxyServer = attempt.result.server;// The tunnel is open from here rather than from whenever the session handler first dials, so// a socket that closed during setup has to be caught: its "close" fired before the listener@@ -594,7 +594,7 @@ export const pamWebAccessServiceFactory = ({const ctx: TSessionContext = {socket,- relayPort: relayServer.port,+ relayPort: proxyServer.port,resourceName: account.name,sessionId: session.id,sendMessage: boundSendMessage,diff --git a/backend/src/lib/gateway-v2/gateway-retry.test.ts b/backend/src/lib/gateway-v2/gateway-retry.test.tsindex de2a28e02a..dd2c9ec6df 100644--- a/backend/src/lib/gateway-v2/gateway-retry.test.ts+++ b/backend/src/lib/gateway-v2/gateway-retry.test.ts@@ -4,25 +4,25 @@ const RELAY_ERR = "TLS connection error: ECONNREFUSED";describe("isGatewayTransportFailure", () => {test("retryable when a channel failed to come up and none ever did", () => {- expect(isGatewayTransportFailure({ relayError: RELAY_ERR, establishedChannel: false })).toBe(true);+ expect(isGatewayTransportFailure({ transportError: RELAY_ERR, establishedChannel: false })).toBe(true);});test("not retryable once a channel came up, even with a relay error recorded", () => {- // The bug this guards: relayError accumulates across every channel a proxy serves and is never+ // The bug this guards: transportError accumulates across every channel a proxy serves and is never// cleared, so one transient setup blip would otherwise mark a later target-side failure (a// half-applied rotation) as safe to replay on another member.- expect(isGatewayTransportFailure({ relayError: RELAY_ERR, establishedChannel: true })).toBe(false);+ expect(isGatewayTransportFailure({ transportError: RELAY_ERR, establishedChannel: true })).toBe(false);});test("not retryable with no relay error at all", () => {- expect(isGatewayTransportFailure({ relayError: "", establishedChannel: false })).toBe(false);- expect(isGatewayTransportFailure({ relayError: "", establishedChannel: true })).toBe(false);+ expect(isGatewayTransportFailure({ transportError: "", establishedChannel: false })).toBe(false);+ expect(isGatewayTransportFailure({ transportError: "", establishedChannel: true })).toBe(false);});test("several accumulated relay errors are still only retryable if nothing established", () => {const many = [RELAY_ERR, RELAY_ERR].join(",");- expect(isGatewayTransportFailure({ relayError: many, establishedChannel: false })).toBe(true);- expect(isGatewayTransportFailure({ relayError: many, establishedChannel: true })).toBe(false);+ expect(isGatewayTransportFailure({ transportError: many, establishedChannel: false })).toBe(true);+ expect(isGatewayTransportFailure({ transportError: many, establishedChannel: true })).toBe(false);});});diff --git a/backend/src/lib/gateway-v2/gateway-retry.ts b/backend/src/lib/gateway-v2/gateway-retry.tsindex 5b7c068c2d..86c5b536de 100644--- a/backend/src/lib/gateway-v2/gateway-retry.ts+++ b/backend/src/lib/gateway-v2/gateway-retry.ts@@ -3,14 +3,14 @@* member would apply twice.*/-/** `relayError` is never cleared, so requiring that no channel established is what bounds it. */+/** `transportError` is never cleared, so requiring that no channel established is what bounds it. */export const isGatewayTransportFailure = ({- relayError,+ transportError,establishedChannel}: {- relayError: string;+ transportError: string;establishedChannel: boolean;-}): boolean => Boolean(relayError) && !establishedChannel;+}): boolean => Boolean(transportError) && !establishedChannel;/** An early tunnel can fail while a later one reaches the target, so a transport failure alone is not enough. */export const isAttemptRetryable = ({diff --git a/backend/src/lib/gateway-v2/gateway-v2.test.ts b/backend/src/lib/gateway-v2/gateway-v2.test.tsindex 82fd3e20fb..601c7eb183 100644--- a/backend/src/lib/gateway-v2/gateway-v2.test.ts+++ b/backend/src/lib/gateway-v2/gateway-v2.test.ts@@ -5,7 +5,7 @@ import forge from "node-forge";import { GatewayProxyProtocol } from "@app/lib/gateway/types";-import { setupRelayServer } from "./gateway-v2";+import { setupGatewayProxy } from "./gateway-v2";const tracker = vi.hoisted(() => ({channelOpened: vi.fn(),@@ -195,7 +195,7 @@ const waitFor = async (predicate: () => boolean) => {// can leak a release into the next test's counters.const drainChannels = (count: number) => waitFor(() => tracker.channelClosed.mock.calls.length === count);-describe("setupRelayServer", () => {+describe("setupGatewayProxy", () => {beforeEach(() => {tracker.channelOpened.mockClear();tracker.channelClosed.mockClear();@@ -213,25 +213,25 @@ describe("setupRelayServer", () => {};test("resolves when not eager, because the dial is deferred to the first client", async () => {- const server = await setupRelayServer(args);+ const server = await setupGatewayProxy(args);expect(server.port).toBeGreaterThan(0);expect(server.hasEstablishedChannel()).toBe(false);await server.cleanup();});test("rejects when eager, which is what gives pool failover something to catch", async () => {- await expect(setupRelayServer({ ...args, eager: true })).rejects.toThrow();+ await expect(setupGatewayProxy({ ...args, eager: true })).rejects.toThrow();});test("reports the failure as a transport error, so it is safe to retry elsewhere", async () => {- await expect(setupRelayServer({ ...args, eager: true })).rejects.toMatchObject({+ await expect(setupGatewayProxy({ ...args, eager: true })).rejects.toMatchObject({name: "BadRequest",gatewayId: GATEWAY_ID});});test("counts no channel for a tunnel that never opened", async () => {- await expect(setupRelayServer({ ...args, eager: true })).rejects.toThrow();+ await expect(setupGatewayProxy({ ...args, eager: true })).rejects.toThrow();expect(tracker.channelOpened).not.toHaveBeenCalled();expect(tracker.markSuspect).toHaveBeenCalledWith(GATEWAY_ID);});@@ -249,14 +249,14 @@ describe("setupRelayServer", () => {});test("does not touch the gateway until a client connects when not eager", async () => {- const server = await setupRelayServer(argsFor(relay.relayHost));+ const server = await setupGatewayProxy(argsFor(relay.relayHost));expect(relay.tunnelsOpened()).toBe(0);expect(server.hasEstablishedChannel()).toBe(false);await server.cleanup();});test("opens the tunnel during setup when eager", async () => {- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });await waitFor(() => relay.tunnelsOpened() === 1);expect(server.hasEstablishedChannel()).toBe(true);expect(tracker.channelOpened).toHaveBeenCalledTimes(1);@@ -266,7 +266,7 @@ describe("setupRelayServer", () => {});test("hands the tunnel it already opened to the first client instead of dialing again", async () => {- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });await waitFor(() => relay.tunnelsOpened() === 1);// The reused tunnel has to still carry traffic; a probe-and-drop would fail here.@@ -279,7 +279,7 @@ describe("setupRelayServer", () => {});test("dials a fresh tunnel for the second client", async () => {- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });await expect(connectAndEcho(server.port)).resolves.toBe("ping");await expect(connectAndEcho(server.port)).resolves.toBe("ping");@@ -292,7 +292,7 @@ describe("setupRelayServer", () => {});test("releases the tunnel and its channel count when no client ever claims it", async () => {- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });await waitFor(() => relay.tunnelsOpened() === 1);await server.cleanup();@@ -302,7 +302,7 @@ describe("setupRelayServer", () => {});test("releases the channel count once when a claimed tunnel closes", async () => {- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });await expect(connectAndEcho(server.port)).resolves.toBe("ping");await server.cleanup();diff --git a/backend/src/lib/gateway-v2/gateway-v2.ts b/backend/src/lib/gateway-v2/gateway-v2.tsindex dbe3ce7e59..185f9abb7d 100644--- a/backend/src/lib/gateway-v2/gateway-v2.ts+++ b/backend/src/lib/gateway-v2/gateway-v2.ts@@ -20,27 +20,27 @@ import { markAttemptTransportFailure, markAttemptTunnelEstablished } from "./gatimport { getGatewayLoadTracker } from "./gateway-load-tracker";import { isGatewayTransportFailure } from "./gateway-retry";-interface IGatewayRelayServer {+interface IGatewayProxyServer {server: net.Server;port: number;cleanup: () => Promise<void>;- getRelayError: () => string;+ getTransportError: () => string;hasEstablishedChannel: () => boolean;}const DEFAULT_RELAY_CONNECTION_TIMEOUT_MS = 100000;/**- * A gateway tunnel is TLS inside TLS: `gatewayConn` is a TLSSocket whose transport is `relayConn`,+ * A gateway tunnel is TLS inside TLS: `gatewayConn` is a TLSSocket whose transport is `transportConn`,* itself a TLSSocket. Tear the two down innermost-first.*/export const destroyGatewayTunnel = ({- relayConn,+ transportConn,gatewayConn,tunnelId,trigger}: {- relayConn?: net.Socket | null;+ transportConn?: net.Socket | null;gatewayConn?: net.Socket | null;/** Correlates the teardown with the tunnel's other lifecycle lines. */tunnelId?: string;@@ -52,13 +52,13 @@ export const destroyGatewayTunnel = ({// from OpenSSL's stack.if (tunnelId) {logger.info(- `gatewayTunnel: teardown scheduled [tunnelId=${tunnelId}] [trigger=${trigger ?? "unknown"}] [gatewayDestroyed=${Boolean(gatewayConn?.destroyed)}] [relayDestroyed=${Boolean(relayConn?.destroyed)}]`+ `gatewayTunnel: teardown scheduled [tunnelId=${tunnelId}] [trigger=${trigger ?? "unknown"}] [gatewayDestroyed=${Boolean(gatewayConn?.destroyed)}] [transportDestroyed=${Boolean(transportConn?.destroyed)}]`);}setImmediate(() => {gatewayConn?.destroy();- relayConn?.destroy();+ transportConn?.destroy();if (tunnelId) {logger.info(`gatewayTunnel: teardown complete [tunnelId=${tunnelId}] [trigger=${trigger ?? "unknown"}]`);}@@ -131,7 +131,7 @@ const GATEWAY_IDLE_TIMEOUT_MS = 120000;const DIRECT_HANDSHAKE_TIMEOUT_MS = 3000;export const createGatewayConnection = async (- relayConn: net.Socket,+ transportConn: net.Socket,gateway: { clientCertificate: string; clientPrivateKey: string; serverCertificateChain: string },protocol: GatewayProxyProtocol,tunnelId?: string,@@ -159,7 +159,7 @@ export const createGatewayConnection = async (const isIpLiteral = Boolean(net.isIP(serverName));const tlsOptions: tls.ConnectionOptions = {- socket: relayConn,+ socket: transportConn,cert: gateway.clientCertificate,key: gateway.clientPrivateKey,ca: splitPemChain(gateway.serverCertificateChain),@@ -176,7 +176,7 @@ export const createGatewayConnection = async (try {// These listeners outlive the handshake, so each one has to stay correct once the tunnel is// established: destroying is always deferred, and reject() is a no-op on a settled promise.- // Callers respond to a rejection by scheduling relayConn's destroy, which lands on the same+ // Callers respond to a rejection by scheduling transportConn's destroy, which lands on the same// queue behind ours, so the inner socket still goes first.const gatewaySocket = tls.connect(tlsOptions, () => {if (!gatewaySocket.authorized) {@@ -211,7 +211,7 @@ export const createGatewayConnection = async (});};-export const setupRelayServer = async ({+export const setupGatewayProxy = async ({gatewayId,protocol,directAddress,@@ -236,8 +236,8 @@ export const setupRelayServer = async ({* gateway sees one channel that becomes the session.*/eager?: boolean;-}): Promise<IGatewayRelayServer> => {- const relayErrorMsg: string[] = [];+}): Promise<IGatewayProxyServer> => {+ const transportErrors: string[] = [];let establishedChannel = false;const loadTracker = getGatewayLoadTracker();let localPort = 0;@@ -248,7 +248,7 @@ export const setupRelayServer = async ({type TUpstream = {tunnelId: string;- relayConn: net.Socket;+ transportConn: net.Socket;gatewayConn: net.Socket;releaseChannel: () => void;};@@ -293,17 +293,17 @@ export const setupRelayServer = async ({serverName,direct ? DIRECT_HANDSHAKE_TIMEOUT_MS : undefined);- return { relayConn: conn, gatewayConn: gwConn };+ return { transportConn: conn, gatewayConn: gwConn };} catch (err) {- destroyGatewayTunnel({ relayConn: conn, tunnelId, trigger: "gatewayHandshakeFailed" });+ destroyGatewayTunnel({ transportConn: conn, tunnelId, trigger: "gatewayHandshakeFailed" });throw err;}};- let relayConn: net.Socket;+ let transportConn: net.Socket;let gatewayConn: net.Socket;try {- ({ relayConn, gatewayConn } = await openOverTransport(directAddress ? dialDirect : dialRelay));+ ({ transportConn, gatewayConn } = await openOverTransport(directAddress ? dialDirect : dialRelay));} catch (err) {const reason = err instanceof Error ? err.message : String(err);tunnelLog(tunnelId, directAddress ? "direct transport failed" : "relay transport failed", ` [err=${reason}]`);@@ -311,7 +311,7 @@ export const setupRelayServer = async ({tunnelLog(tunnelId, "falling back to relay");try {- ({ relayConn, gatewayConn } = await openOverTransport(dialRelay));+ ({ transportConn, gatewayConn } = await openOverTransport(dialRelay));} catch (relayErr) {tunnelLog(tunnelId,@@ -322,11 +322,13 @@ export const setupRelayServer = async ({}}- relayConn.on("close", (hadError: boolean) => tunnelLog(tunnelId, "relay socket close", ` [hadError=${hadError}]`));+ transportConn.on("close", (hadError: boolean) =>+ tunnelLog(tunnelId, "transport socket close", ` [hadError=${hadError}]`)+ );gatewayConn.on("close", (hadError: boolean) =>tunnelLog(tunnelId, "gateway socket close", ` [hadError=${hadError}]`));- relayConn.on("error", (err: Error) => tunnelLog(tunnelId, "relay socket error", ` [err=${err.message}]`));+ transportConn.on("error", (err: Error) => tunnelLog(tunnelId, "transport socket error", ` [err=${err.message}]`));gatewayConn.on("error", (err: Error) => tunnelLog(tunnelId, "gateway socket error", ` [err=${err.message}]`));// The gateway dials the target the moment it accepts the channel, so from here the attempt is@@ -337,12 +339,12 @@ export const setupRelayServer = async ({if (longLived) {// Drop the inactivity timeout applied after the handshake. Without this, an idle session is// destroyed once it goes quiet for GATEWAY_IDLE_TIMEOUT_MS.- relayConn.setTimeout(0);+ transportConn.setTimeout(0);gatewayConn.setTimeout(0);// Enable TCP keep-alive probes every 30s to detect dead connections// without terminating idle-but-alive ones.- relayConn.setKeepAlive(true, 30000);+ transportConn.setKeepAlive(true, 30000);gatewayConn.setKeepAlive(true, 30000);}@@ -374,7 +376,7 @@ export const setupRelayServer = async ({return {tunnelId,- relayConn,+ transportConn,gatewayConn,releaseChannel: () => {if (released) return;@@ -389,10 +391,10 @@ export const setupRelayServer = async ({const discardPendingUpstream = () => {if (!pendingUpstream) return;- const { tunnelId, relayConn, gatewayConn, releaseChannel } = pendingUpstream;+ const { tunnelId, transportConn, gatewayConn, releaseChannel } = pendingUpstream;pendingUpstream = null;releaseChannel();- destroyGatewayTunnel({ relayConn, gatewayConn, tunnelId, trigger: "discardUnclaimed" });+ destroyGatewayTunnel({ transportConn, gatewayConn, tunnelId, trigger: "discardUnclaimed" });};return new Promise((resolve, reject) => {@@ -406,14 +408,14 @@ export const setupRelayServer = async ({const claimed = pendingUpstream;pendingUpstream = null;- const { tunnelId, relayConn, gatewayConn, releaseChannel } = claimed ?? (await openUpstream());+ const { tunnelId, transportConn, gatewayConn, releaseChannel } = claimed ?? (await openUpstream());tunnelLog(tunnelId, claimed ? "claimed pre-opened tunnel" : "opened tunnel for client");// Its "close" already fired, so the teardown listeners below would never run and the// channel would stay counted for the life of the pod.if (clientConn.destroyed) {releaseChannel();- destroyGatewayTunnel({ relayConn, gatewayConn, tunnelId, trigger: "clientAlreadyGone" });+ destroyGatewayTunnel({ transportConn, gatewayConn, tunnelId, trigger: "clientAlreadyGone" });return;}@@ -426,11 +428,11 @@ export const setupRelayServer = async ({tunnelLog(tunnelId, "teardown triggered", ` [trigger=${trigger}]`);releaseChannel();clientConn.destroy();- destroyGatewayTunnel({ relayConn, gatewayConn, tunnelId, trigger });+ destroyGatewayTunnel({ transportConn, gatewayConn, tunnelId, trigger });};clientConn.on("error", (err: Error) => destroyAll(`clientError:${err.message}`));- relayConn.on("error", () => destroyAll("relayError"));+ transportConn.on("error", () => destroyAll("transportError"));gatewayConn.on("error", () => destroyAll("gatewayError"));// Bidirectional data forwarding@@ -438,11 +440,11 @@ export const setupRelayServer = async ({gatewayConn.pipe(clientConn);clientConn.on("close", () => destroyAll("clientClose"));- relayConn.on("close", () => destroyAll("relayClose"));+ transportConn.on("close", () => destroyAll("transportClose"));gatewayConn.on("close", () => destroyAll("gatewayClose"));} catch (err) {const errorMsg = err instanceof Error ? err.message : String(err);- relayErrorMsg.push(errorMsg);+ transportErrors.push(errorMsg);clientConn.destroy();}})();@@ -462,7 +464,7 @@ export const setupRelayServer = async ({}localPort = address.port;- const relayServer: IGatewayRelayServer = {+ const proxyServer: IGatewayProxyServer = {server,port: address.port,cleanup: async () => {@@ -473,12 +475,12 @@ export const setupRelayServer = async ({logger.debug("Error closing server:", err instanceof Error ? err.message : String(err));}},- getRelayError: () => relayErrorMsg.join(","),+ getTransportError: () => transportErrors.join(","),hasEstablishedChannel: () => establishedChannel};if (!eager) {- resolve(relayServer);+ resolve(proxyServer);return;}@@ -492,14 +494,14 @@ export const setupRelayServer = async ({const dropIfUnclaimed = () => {if (pendingUpstream === upstream) discardPendingUpstream();};- upstream.relayConn.once("close", dropIfUnclaimed);+ upstream.transportConn.once("close", dropIfUnclaimed);upstream.gatewayConn.once("close", dropIfUnclaimed);- upstream.relayConn.once("error", dropIfUnclaimed);+ upstream.transportConn.once("error", dropIfUnclaimed);upstream.gatewayConn.once("error", dropIfUnclaimed);- resolve(relayServer);+ resolve(proxyServer);} catch (err) {- await relayServer.cleanup();+ await proxyServer.cleanup();markAttemptTransportFailure();await getGatewayLoadTracker()?.markSuspect(gatewayId);reject(@@ -525,9 +527,9 @@ export const withGatewayV2Proxy = async <T>(): Promise<T> => {const { gatewayId, protocol, directAddress, relayHost, gateway, relay, httpsAgent, longLived } = options;- let relayServer;+ let proxyServer;try {- relayServer = await setupRelayServer({+ proxyServer = await setupGatewayProxy({gatewayId,protocol,directAddress,@@ -546,23 +548,25 @@ export const withGatewayV2Proxy = async <T>(});}- const { port, cleanup, getRelayError, hasEstablishedChannel } = relayServer;+ const { port, cleanup, getTransportError, hasEstablishedChannel } = proxyServer;try {// Execute the callback with the allocated portreturn await callback(port);} catch (err) {- const relayErrorMessage = getRelayError();- if (relayErrorMessage) {- logger.error("Relay error:", relayErrorMessage);+ const transportErrorMessage = getTransportError();+ if (transportErrorMessage) {+ logger.error("Relay error:", transportErrorMessage);}logger.error("Gateway error:", err instanceof Error ? err.message : String(err));- let errorMessage = relayErrorMessage || (err instanceof Error ? err.message : String(err));+ let errorMessage = transportErrorMessage || (err instanceof Error ? err.message : String(err));if (isAxiosError(err) && (err.response?.data as { message?: string })?.message) {errorMessage = (err.response?.data as { message: string }).message;}- if (isGatewayTransportFailure({ relayError: relayErrorMessage, establishedChannel: hasEstablishedChannel() })) {+ if (+ isGatewayTransportFailure({ transportError: transportErrorMessage, establishedChannel: hasEstablishedChannel() })+ ) {markAttemptTransportFailure();await getGatewayLoadTracker()?.markSuspect(gatewayId);throw new GatewayTransportError({ message: errorMessage, gatewayId });