@symmio/trading-core 0.1.0

package/dist/websocket/notifications/watch-notifications.js

@@ -0,0 +1,48 @@
+import { SymmError as e } from "../../shared/errors/symm-error.js";
+import { buildSubscribeMessage as t } from "./build-subscribe-message.js";
+import { normalizeNotification as n } from "./normalize-notification.js";
+import { parseNotificationFrame as r } from "./parse-notification-frame.js";
+import { createReconnectingSocket as i } from "../socket/create-reconnecting-socket.js";
+import { getSocketPool as a } from "../socket/get-socket-pool.js";
+//#region src/websocket/notifications/watch-notifications.ts
+function o(t) {
+	if (t instanceof e) return t;
+	let n = t instanceof Error ? t : void 0;
+	return new e("api", "NOTIFICATIONS_SOCKET_ERROR", `Notifications socket error${n ? `: ${n.message}` : "."}`, { cause: n });
+}
+function s(e, s) {
+	let { account: c, chainId: l, onNotification: u, onStatusChange: d, onError: f } = s, { notifications: p } = e.getChainConfig(l), m = e.getWebSocketConstructor(), h = t({
+		account: c,
+		channel: p.channel,
+		protocol: p.protocol
+	}), g = `${p.url}|${p.protocol}|${c.toLowerCase()}`;
+	return a(e).acquire(g, (e) => i({
+		url: p.url,
+		webSocketConstructor: m,
+		getOpenMessages: () => [h],
+		onMessage: e.onMessage,
+		onStatusChange: e.onStatusChange,
+		onError: e.onError
+	}), {
+		onMessage: (e) => {
+			let t;
+			try {
+				t = r(e, p.protocol);
+			} catch (e) {
+				f?.(o(e));
+				return;
+			}
+			if (t) try {
+				u(n(t));
+			} catch (e) {
+				f?.(o(e));
+			}
+		},
+		onStatusChange: d,
+		onError: (e) => f?.(o(e))
+	});
+}
+//#endregion
+export { s as watchNotifications };
+
+//# sourceMappingURL=watch-notifications.js.map

package/dist/websocket/notifications/watch-notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-notifications.js","names":[],"sources":["../../../src/websocket/notifications/watch-notifications.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport { SymmError } from \"../../shared/errors/symm-error\";\nimport { createReconnectingSocket } from \"../socket/create-reconnecting-socket\";\nimport { getSocketPool } from \"../socket/get-socket-pool\";\nimport type { SocketStatus } from \"../socket/socket-status\";\nimport { buildSubscribeMessage } from \"./build-subscribe-message\";\nimport { normalizeNotification } from \"./normalize-notification\";\nimport { parseNotificationFrame } from \"./parse-notification-frame\";\nimport type { Notification } from \"./types\";\n\n/**\n * Stop a {@link watchNotifications} subscription. Idempotent; the shared socket\n * closes once the last watcher on an endpoint+account releases.\n */\nexport type Unwatch = () => void;\n\n/**\n * Parameters for {@link watchNotifications}.\n */\nexport interface WatchNotificationsParameters {\n  /** SubAccount address to subscribe for. */\n  account: Address;\n  /** Target chain id. Defaults to the config's `defaultChainId`. */\n  chainId?: number;\n  /** Called for every normalized notification frame. */\n  onNotification: (notification: Notification) => void;\n  /** Called whenever the underlying connection status changes. */\n  onStatusChange?: (status: SocketStatus) => void;\n  /** Called on a transport or parse error; does not stop the subscription. */\n  onError?: (error: SymmError) => void;\n}\n\nfunction toNotificationsError(event: unknown): SymmError {\n  if (event instanceof SymmError) return event;\n  const cause = event instanceof Error ? event : undefined;\n  return new SymmError(\n    \"api\",\n    \"NOTIFICATIONS_SOCKET_ERROR\",\n    `Notifications socket error${cause ? `: ${cause.message}` : \".\"}`,\n    {\n      cause,\n    },\n  );\n}\n\n/**\n * Subscribe to live position/quote state notifications for an account.\n *\n * Opens (or reuses) one reconnecting socket to the chain's notifications\n * endpoint, sends the subscribe frame on every (re)connect, normalizes inbound\n * frames into {@link Notification}s, and invokes the handlers. Watchers sharing\n * the same endpoint+account share one socket; it closes when the last one\n * unwatches.\n *\n * @param config - The SDK config.\n * @param parameters - The account to watch and the handlers to invoke.\n * @returns An unwatch function that releases this subscription.\n * @throws {SymmError} synchronously when the chain is unsupported or no\n *   `WebSocket` implementation is available.\n *\n * @example\n * ```ts\n * const unwatch = watchNotifications(config, {\n *   account: \"0xabc…\",\n *   onNotification: (n) => console.log(n.type, n.quoteId),\n *   onStatusChange: (status) => console.log(status),\n * });\n * // later\n * unwatch();\n * ```\n */\nexport function watchNotifications(config: Config, parameters: WatchNotificationsParameters): Unwatch {\n  const { account, chainId, onNotification, onStatusChange, onError } = parameters;\n\n  const { notifications } = config.getChainConfig(chainId);\n  const webSocketConstructor = config.getWebSocketConstructor();\n  const subscribeMessage = buildSubscribeMessage({\n    account,\n    channel: notifications.channel,\n    protocol: notifications.protocol,\n  });\n\n  const key = `${notifications.url}|${notifications.protocol}|${account.toLowerCase()}`;\n\n  return getSocketPool(config).acquire(\n    key,\n    (handlers) =>\n      createReconnectingSocket({\n        url: notifications.url,\n        webSocketConstructor,\n        getOpenMessages: () => [subscribeMessage],\n        onMessage: handlers.onMessage,\n        onStatusChange: handlers.onStatusChange,\n        onError: handlers.onError,\n      }),\n    {\n      onMessage: (data) => {\n        let raw;\n        try {\n          raw = parseNotificationFrame(data, notifications.protocol);\n        } catch (err) {\n          onError?.(toNotificationsError(err));\n          return;\n        }\n        if (!raw) return;\n        try {\n          onNotification(normalizeNotification(raw));\n        } catch (err) {\n          onError?.(toNotificationsError(err));\n        }\n      },\n      onStatusChange,\n      onError: (event) => onError?.(toNotificationsError(event)),\n    },\n  );\n}\n"],"mappings":";;;;;;;AAiCA,SAAS,EAAqB,GAA2B;CACvD,IAAI,aAAiB,GAAW,OAAO;CACvC,IAAM,IAAQ,aAAiB,QAAQ,IAAQ,KAAA;CAC/C,OAAO,IAAI,EACT,OACA,8BACA,6BAA6B,IAAQ,KAAK,EAAM,YAAY,OAC5D,EACE,SACF,CACF;AACF;AA4BA,SAAgB,EAAmB,GAAgB,GAAmD;CACpG,IAAM,EAAE,YAAS,YAAS,mBAAgB,mBAAgB,eAAY,GAEhE,EAAE,qBAAkB,EAAO,eAAe,CAAO,GACjD,IAAuB,EAAO,wBAAwB,GACtD,IAAmB,EAAsB;EAC7C;EACA,SAAS,EAAc;EACvB,UAAU,EAAc;CAC1B,CAAC,GAEK,IAAM,GAAG,EAAc,IAAI,GAAG,EAAc,SAAS,GAAG,EAAQ,YAAY;CAElF,OAAO,EAAc,CAAM,EAAE,QAC3B,IACC,MACC,EAAyB;EACvB,KAAK,EAAc;EACnB;EACA,uBAAuB,CAAC,CAAgB;EACxC,WAAW,EAAS;EACpB,gBAAgB,EAAS;EACzB,SAAS,EAAS;CACpB,CAAC,GACH;EACE,YAAY,MAAS;GACnB,IAAI;GACJ,IAAI;IACF,IAAM,EAAuB,GAAM,EAAc,QAAQ;GAC3D,SAAS,GAAK;IACZ,IAAU,EAAqB,CAAG,CAAC;IACnC;GACF;GACK,OACL,IAAI;IACF,EAAe,EAAsB,CAAG,CAAC;GAC3C,SAAS,GAAK;IACZ,IAAU,EAAqB,CAAG,CAAC;GACrC;EACF;EACA;EACA,UAAU,MAAU,IAAU,EAAqB,CAAK,CAAC;CAC3D,CACF;AACF"}

package/dist/websocket/prices/index.d.ts

@@ -0,0 +1,4 @@
+export * from './parse-price-frame';
+export * from './types';
+export * from './watch-enigma-prices';
+//# sourceMappingURL=index.d.ts.map

package/dist/websocket/prices/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/websocket/prices/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,uBAAuB,CAAC"}

package/dist/websocket/prices/parse-price-frame.d.ts

@@ -0,0 +1,10 @@
+import { EnigmaPriceTick } from './types';
+/**
+ * Parse one inbound frame from the Enigma lowcap price WebSocket into an
+ * array of {@link EnigmaPriceTick}s, or `null` when the frame is not a price
+ * push (control frame, malformed JSON, unexpected shape).
+ *
+ * @param data - The raw `event.data` (a JSON string, or an already-parsed object).
+ */
+export declare function parsePriceFrame(data: unknown): EnigmaPriceTick[] | null;
+//# sourceMappingURL=parse-price-frame.d.ts.map

package/dist/websocket/prices/parse-price-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-price-frame.d.ts","sourceRoot":"","sources":["../../../src/websocket/prices/parse-price-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,EAAE,GAAG,IAAI,CA6BvE"}

package/dist/websocket/prices/parse-price-frame.js

@@ -0,0 +1,28 @@
+//#region src/websocket/prices/parse-price-frame.ts
+function e(e) {
+	let t = e;
+	if (typeof e == "string") try {
+		t = JSON.parse(e);
+	} catch {
+		return null;
+	}
+	if (!Array.isArray(t)) return null;
+	let n = [];
+	for (let e of t) {
+		if (!e || typeof e != "object") continue;
+		let t = e;
+		if (typeof t.name != "string") continue;
+		let r = null;
+		if (typeof t.markPrice == "number" && Number.isFinite(t.markPrice) ? r = String(t.markPrice) : typeof t.markPrice == "string" && t.markPrice.length > 0 && (r = t.markPrice), r === null) continue;
+		let i = {
+			name: t.name,
+			markPrice: r
+		};
+		typeof t.time == "number" && Number.isFinite(t.time) && (i.time = t.time), typeof t.address == "string" && t.address.length > 0 && (i.address = t.address), n.push(i);
+	}
+	return n;
+}
+//#endregion
+export { e as parsePriceFrame };
+
+//# sourceMappingURL=parse-price-frame.js.map

package/dist/websocket/prices/parse-price-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-price-frame.js","names":[],"sources":["../../../src/websocket/prices/parse-price-frame.ts"],"sourcesContent":["import type { EnigmaPriceTick } from \"./types\";\n\n/**\n * Parse one inbound frame from the Enigma lowcap price WebSocket into an\n * array of {@link EnigmaPriceTick}s, or `null` when the frame is not a price\n * push (control frame, malformed JSON, unexpected shape).\n *\n * @param data - The raw `event.data` (a JSON string, or an already-parsed object).\n */\nexport function parsePriceFrame(data: unknown): EnigmaPriceTick[] | null {\n  let parsed: unknown = data;\n  if (typeof data === \"string\") {\n    try {\n      parsed = JSON.parse(data);\n    } catch {\n      return null;\n    }\n  }\n  if (!Array.isArray(parsed)) return null;\n\n  const ticks: EnigmaPriceTick[] = [];\n  for (const item of parsed) {\n    if (!item || typeof item !== \"object\") continue;\n    const raw = item as Record<string, unknown>;\n    if (typeof raw.name !== \"string\") continue;\n    let markPriceStr: string | null = null;\n    if (typeof raw.markPrice === \"number\" && Number.isFinite(raw.markPrice)) {\n      markPriceStr = String(raw.markPrice);\n    } else if (typeof raw.markPrice === \"string\" && raw.markPrice.length > 0) {\n      markPriceStr = raw.markPrice;\n    }\n    if (markPriceStr === null) continue;\n    const tick: EnigmaPriceTick = { name: raw.name, markPrice: markPriceStr };\n    if (typeof raw.time === \"number\" && Number.isFinite(raw.time)) tick.time = raw.time;\n    if (typeof raw.address === \"string\" && raw.address.length > 0) tick.address = raw.address;\n    ticks.push(tick);\n  }\n  return ticks;\n}\n"],"mappings":";AASA,SAAgB,EAAgB,GAAyC;CACvE,IAAI,IAAkB;CACtB,IAAI,OAAO,KAAS,UAClB,IAAI;EACF,IAAS,KAAK,MAAM,CAAI;CAC1B,QAAQ;EACN,OAAO;CACT;CAEF,IAAI,CAAC,MAAM,QAAQ,CAAM,GAAG,OAAO;CAEnC,IAAM,IAA2B,CAAC;CAClC,KAAK,IAAM,KAAQ,GAAQ;EACzB,IAAI,CAAC,KAAQ,OAAO,KAAS,UAAU;EACvC,IAAM,IAAM;EACZ,IAAI,OAAO,EAAI,QAAS,UAAU;EAClC,IAAI,IAA8B;EAMlC,IALI,OAAO,EAAI,aAAc,YAAY,OAAO,SAAS,EAAI,SAAS,IACpE,IAAe,OAAO,EAAI,SAAS,IAC1B,OAAO,EAAI,aAAc,YAAY,EAAI,UAAU,SAAS,MACrE,IAAe,EAAI,YAEjB,MAAiB,MAAM;EAC3B,IAAM,IAAwB;GAAE,MAAM,EAAI;GAAM,WAAW;EAAa;EAGxE,AAFI,OAAO,EAAI,QAAS,YAAY,OAAO,SAAS,EAAI,IAAI,MAAG,EAAK,OAAO,EAAI,OAC3E,OAAO,EAAI,WAAY,YAAY,EAAI,QAAQ,SAAS,MAAG,EAAK,UAAU,EAAI,UAClF,EAAM,KAAK,CAAI;CACjB;CACA,OAAO;AACT"}

package/dist/websocket/prices/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Raw price frame as it arrives on the Enigma lowcap price WS. The endpoint
+ * broadcasts an array of these per message; one entry per market.
+ *
+ * `markPrice` arrives as a JSON number on the wire (the SDK normalizes it to
+ * a decimal string in {@link EnigmaPriceTick}).
+ */
+export interface RawEnigmaPriceFrame {
+    name: string;
+    markPrice: number;
+    /** Optional source timestamp (unix ms). */
+    time?: number;
+    /** Optional address of the underlying token / market. */
+    address?: string;
+}
+/**
+ * Normalized price tick the SDK delivers to consumers. Currently mirrors the
+ * raw frame 1:1; reserved for future enrichment (e.g. funding rate, index
+ * price) once the backend ships them.
+ */
+export interface EnigmaPriceTick {
+    /** Market symbol name (e.g. `"BTCUSDT"`). */
+    name: string;
+    /** Mark price as a decimal string. */
+    markPrice: string;
+    /** Source timestamp (unix ms), when present on the frame. */
+    time?: number;
+    /** Address of the underlying token / market, when present on the frame. */
+    address?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/websocket/prices/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/websocket/prices/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/websocket/prices/watch-enigma-prices.d.ts

@@ -0,0 +1,42 @@
+import { Config } from '../../core/config';
+import { SymmError } from '../../shared/errors/symm-error';
+import { Unwatch } from '../notifications/watch-notifications';
+import { SocketStatus } from '../socket/socket-status';
+import { EnigmaPriceTick } from './types';
+/**
+ * Parameters for {@link watchEnigmaPrices}.
+ */
+export interface WatchEnigmaPricesParameters {
+    /** Target chain id. Defaults to the config's `defaultChainId`. */
+    chainId?: number;
+    /** Called for every parsed batch of price ticks. */
+    onPrices: (prices: EnigmaPriceTick[]) => void;
+    /** Called whenever the underlying connection status changes. */
+    onStatusChange?: (status: SocketStatus) => void;
+    /** Called on a transport or parse error; does not stop the subscription. */
+    onError?: (error: SymmError) => void;
+}
+/**
+ * Subscribe to the chain's Enigma lowcap price-service WebSocket.
+ *
+ * The endpoint is broadcast-only — there is no subscribe message; every
+ * connected client receives the same price ticks. Watchers sharing the
+ * same `wsUrl` share one underlying socket; it closes when the last
+ * watcher unwatches.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Handlers + optional chain override.
+ * @returns An unwatch function that releases this subscription.
+ * @throws {SymmError} synchronously when the chain is unsupported, has no
+ *   `priceService.wsUrl` configured, or no `WebSocket` implementation exists.
+ *
+ * @example
+ * ```ts
+ * const unwatch = watchEnigmaPrices(config, {
+ *   onPrices: (ticks) => console.log(ticks.length, "ticks"),
+ *   onStatusChange: (status) => console.log(status),
+ * });
+ * ```
+ */
+export declare function watchEnigmaPrices(config: Config, parameters: WatchEnigmaPricesParameters): Unwatch;
+//# sourceMappingURL=watch-enigma-prices.d.ts.map

package/dist/websocket/prices/watch-enigma-prices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-enigma-prices.d.ts","sourceRoot":"","sources":["../../../src/websocket/prices/watch-enigma-prices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAGpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,QAAQ,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;IAC9C,gEAAgE;IAChE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAChD,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACtC;AAUD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,2BAA2B,GAAG,OAAO,CA2ClG"}

package/dist/websocket/prices/watch-enigma-prices.js

@@ -0,0 +1,44 @@
+import { SymmError as e } from "../../shared/errors/symm-error.js";
+import { createReconnectingSocket as t } from "../socket/create-reconnecting-socket.js";
+import { getSocketPool as n } from "../socket/get-socket-pool.js";
+import { parsePriceFrame as r } from "./parse-price-frame.js";
+//#region src/websocket/prices/watch-enigma-prices.ts
+function i(t) {
+	if (t instanceof e) return t;
+	let n = t instanceof Error ? t : void 0;
+	return new e("api", "PRICES_SOCKET_ERROR", `Prices socket error${n ? `: ${n.message}` : "."}`, { cause: n });
+}
+function a(a, o) {
+	let { chainId: s, onPrices: c, onStatusChange: l, onError: u } = o, { priceService: d } = a.getChainConfig(s), f = d.wsUrl;
+	if (!f) throw new e("config", "PRICES_WS_NOT_CONFIGURED", "Chain has no `priceService.wsUrl` configured.");
+	let p = a.getWebSocketConstructor(), m = `${f}|prices`;
+	return n(a).acquire(m, (e) => t({
+		url: f,
+		webSocketConstructor: p,
+		getOpenMessages: () => [],
+		onMessage: e.onMessage,
+		onStatusChange: e.onStatusChange,
+		onError: e.onError
+	}), {
+		onMessage: (e) => {
+			let t;
+			try {
+				t = r(e);
+			} catch (e) {
+				u?.(i(e));
+				return;
+			}
+			if (!(!t || t.length === 0)) try {
+				c(t);
+			} catch (e) {
+				u?.(i(e));
+			}
+		},
+		onStatusChange: l,
+		onError: (e) => u?.(i(e))
+	});
+}
+//#endregion
+export { a as watchEnigmaPrices };
+
+//# sourceMappingURL=watch-enigma-prices.js.map

package/dist/websocket/prices/watch-enigma-prices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-enigma-prices.js","names":[],"sources":["../../../src/websocket/prices/watch-enigma-prices.ts"],"sourcesContent":["import type { Config } from \"../../core/config\";\nimport { SymmError } from \"../../shared/errors/symm-error\";\nimport type { Unwatch } from \"../notifications/watch-notifications\";\nimport { createReconnectingSocket } from \"../socket/create-reconnecting-socket\";\nimport { getSocketPool } from \"../socket/get-socket-pool\";\nimport type { SocketStatus } from \"../socket/socket-status\";\nimport { parsePriceFrame } from \"./parse-price-frame\";\nimport type { EnigmaPriceTick } from \"./types\";\n\n/**\n * Parameters for {@link watchEnigmaPrices}.\n */\nexport interface WatchEnigmaPricesParameters {\n  /** Target chain id. Defaults to the config's `defaultChainId`. */\n  chainId?: number;\n  /** Called for every parsed batch of price ticks. */\n  onPrices: (prices: EnigmaPriceTick[]) => void;\n  /** Called whenever the underlying connection status changes. */\n  onStatusChange?: (status: SocketStatus) => void;\n  /** Called on a transport or parse error; does not stop the subscription. */\n  onError?: (error: SymmError) => void;\n}\n\nfunction toPricesError(event: unknown): SymmError {\n  if (event instanceof SymmError) return event;\n  const cause = event instanceof Error ? event : undefined;\n  return new SymmError(\"api\", \"PRICES_SOCKET_ERROR\", `Prices socket error${cause ? `: ${cause.message}` : \".\"}`, {\n    cause,\n  });\n}\n\n/**\n * Subscribe to the chain's Enigma lowcap price-service WebSocket.\n *\n * The endpoint is broadcast-only — there is no subscribe message; every\n * connected client receives the same price ticks. Watchers sharing the\n * same `wsUrl` share one underlying socket; it closes when the last\n * watcher unwatches.\n *\n * @param config - The SDK config.\n * @param parameters - Handlers + optional chain override.\n * @returns An unwatch function that releases this subscription.\n * @throws {SymmError} synchronously when the chain is unsupported, has no\n *   `priceService.wsUrl` configured, or no `WebSocket` implementation exists.\n *\n * @example\n * ```ts\n * const unwatch = watchEnigmaPrices(config, {\n *   onPrices: (ticks) => console.log(ticks.length, \"ticks\"),\n *   onStatusChange: (status) => console.log(status),\n * });\n * ```\n */\nexport function watchEnigmaPrices(config: Config, parameters: WatchEnigmaPricesParameters): Unwatch {\n  const { chainId, onPrices, onStatusChange, onError } = parameters;\n\n  const { priceService } = config.getChainConfig(chainId);\n  const wsUrl = priceService.wsUrl;\n  if (!wsUrl) {\n    throw new SymmError(\"config\", \"PRICES_WS_NOT_CONFIGURED\", \"Chain has no `priceService.wsUrl` configured.\");\n  }\n  const webSocketConstructor = config.getWebSocketConstructor();\n\n  const key = `${wsUrl}|prices`;\n\n  return getSocketPool(config).acquire(\n    key,\n    (handlers) =>\n      createReconnectingSocket({\n        url: wsUrl,\n        webSocketConstructor,\n        getOpenMessages: () => [],\n        onMessage: handlers.onMessage,\n        onStatusChange: handlers.onStatusChange,\n        onError: handlers.onError,\n      }),\n    {\n      onMessage: (data) => {\n        let ticks;\n        try {\n          ticks = parsePriceFrame(data);\n        } catch (err) {\n          onError?.(toPricesError(err));\n          return;\n        }\n        if (!ticks || ticks.length === 0) return;\n        try {\n          onPrices(ticks);\n        } catch (err) {\n          onError?.(toPricesError(err));\n        }\n      },\n      onStatusChange,\n      onError: (event) => onError?.(toPricesError(event)),\n    },\n  );\n}\n"],"mappings":";;;;;AAuBA,SAAS,EAAc,GAA2B;CAChD,IAAI,aAAiB,GAAW,OAAO;CACvC,IAAM,IAAQ,aAAiB,QAAQ,IAAQ,KAAA;CAC/C,OAAO,IAAI,EAAU,OAAO,uBAAuB,sBAAsB,IAAQ,KAAK,EAAM,YAAY,OAAO,EAC7G,SACF,CAAC;AACH;AAwBA,SAAgB,EAAkB,GAAgB,GAAkD;CAClG,IAAM,EAAE,YAAS,aAAU,mBAAgB,eAAY,GAEjD,EAAE,oBAAiB,EAAO,eAAe,CAAO,GAChD,IAAQ,EAAa;CAC3B,IAAI,CAAC,GACH,MAAM,IAAI,EAAU,UAAU,4BAA4B,+CAA+C;CAE3G,IAAM,IAAuB,EAAO,wBAAwB,GAEtD,IAAM,GAAG,EAAM;CAErB,OAAO,EAAc,CAAM,EAAE,QAC3B,IACC,MACC,EAAyB;EACvB,KAAK;EACL;EACA,uBAAuB,CAAC;EACxB,WAAW,EAAS;EACpB,gBAAgB,EAAS;EACzB,SAAS,EAAS;CACpB,CAAC,GACH;EACE,YAAY,MAAS;GACnB,IAAI;GACJ,IAAI;IACF,IAAQ,EAAgB,CAAI;GAC9B,SAAS,GAAK;IACZ,IAAU,EAAc,CAAG,CAAC;IAC5B;GACF;GACI,OAAC,KAAS,EAAM,WAAW,IAC/B,IAAI;IACF,EAAS,CAAK;GAChB,SAAS,GAAK;IACZ,IAAU,EAAc,CAAG,CAAC;GAC9B;EACF;EACA;EACA,UAAU,MAAU,IAAU,EAAc,CAAK,CAAC;CACpD,CACF;AACF"}

package/dist/websocket/socket/backoff.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tuning for the exponential-backoff reconnect schedule.
+ */
+export interface BackoffOptions {
+    /** Delay before the first retry (attempt 0), in ms. */
+    baseDelayMs: number;
+    /** Upper bound on any single delay, in ms. */
+    maxDelayMs: number;
+    /** Apply random jitter so reconnecting clients do not stampede. */
+    jitter: boolean;
+}
+/**
+ * Compute the delay before reconnect `attempt` (0-based).
+ *
+ * Without jitter the delay is `min(maxDelayMs, baseDelayMs · 2^attempt)`. With
+ * jitter the result is scaled by a random factor in `[0.5, 1]` (half jitter),
+ * spreading retries across a window instead of synchronizing them.
+ *
+ * @param attempt - Zero-based retry index. Attempt 0 returns ~`baseDelayMs`.
+ * @param options - Backoff tuning.
+ * @param random - Source of randomness in `[0, 1)`. Injectable for deterministic tests; defaults to `Math.random`.
+ * @returns Delay in milliseconds.
+ *
+ * @example
+ * ```ts
+ * computeBackoffDelay(0, { baseDelayMs: 500, maxDelayMs: 10_000, jitter: false }); // 500
+ * computeBackoffDelay(5, { baseDelayMs: 500, maxDelayMs: 10_000, jitter: false }); // 10_000 (capped)
+ * ```
+ */
+export declare function computeBackoffDelay(attempt: number, options: BackoffOptions, random?: () => number): number;
+//# sourceMappingURL=backoff.d.ts.map

package/dist/websocket/socket/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../src/websocket/socket/backoff.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,cAAc,EACvB,MAAM,GAAE,MAAM,MAAoB,GACjC,MAAM,CAIR"}

package/dist/websocket/socket/backoff.js

@@ -0,0 +1,9 @@
+//#region src/websocket/socket/backoff.ts
+function e(e, t, n = Math.random) {
+	let r = Math.min(t.maxDelayMs, t.baseDelayMs * 2 ** e);
+	return t.jitter ? Math.round(r * (.5 + n() * .5)) : r;
+}
+//#endregion
+export { e as computeBackoffDelay };
+
+//# sourceMappingURL=backoff.js.map

package/dist/websocket/socket/backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.js","names":[],"sources":["../../../src/websocket/socket/backoff.ts"],"sourcesContent":["/**\n * Tuning for the exponential-backoff reconnect schedule.\n */\nexport interface BackoffOptions {\n  /** Delay before the first retry (attempt 0), in ms. */\n  baseDelayMs: number;\n  /** Upper bound on any single delay, in ms. */\n  maxDelayMs: number;\n  /** Apply random jitter so reconnecting clients do not stampede. */\n  jitter: boolean;\n}\n\n/**\n * Compute the delay before reconnect `attempt` (0-based).\n *\n * Without jitter the delay is `min(maxDelayMs, baseDelayMs · 2^attempt)`. With\n * jitter the result is scaled by a random factor in `[0.5, 1]` (half jitter),\n * spreading retries across a window instead of synchronizing them.\n *\n * @param attempt - Zero-based retry index. Attempt 0 returns ~`baseDelayMs`.\n * @param options - Backoff tuning.\n * @param random - Source of randomness in `[0, 1)`. Injectable for deterministic tests; defaults to `Math.random`.\n * @returns Delay in milliseconds.\n *\n * @example\n * ```ts\n * computeBackoffDelay(0, { baseDelayMs: 500, maxDelayMs: 10_000, jitter: false }); // 500\n * computeBackoffDelay(5, { baseDelayMs: 500, maxDelayMs: 10_000, jitter: false }); // 10_000 (capped)\n * ```\n */\nexport function computeBackoffDelay(\n  attempt: number,\n  options: BackoffOptions,\n  random: () => number = Math.random,\n): number {\n  const exponential = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** attempt);\n  if (!options.jitter) return exponential;\n  return Math.round(exponential * (0.5 + random() * 0.5));\n}\n"],"mappings":";AA8BA,SAAgB,EACd,GACA,GACA,IAAuB,KAAK,QACpB;CACR,IAAM,IAAc,KAAK,IAAI,EAAQ,YAAY,EAAQ,cAAc,KAAK,CAAO;CAEnF,OADK,EAAQ,SACN,KAAK,MAAM,KAAe,KAAM,EAAO,IAAI,GAAI,IAD1B;AAE9B"}

package/dist/websocket/socket/create-reconnecting-socket.d.ts

@@ -0,0 +1,111 @@
+import { WebSocketConstructor } from '../../shared/types/websocket';
+import { SocketStatus } from './socket-status';
+/**
+ * Reconnect tuning for {@link createReconnectingSocket}. All fields optional;
+ * defaults match the SDK's notifications behavior (unlimited retries, 500ms →
+ * 10s exponential backoff with jitter).
+ */
+export interface ReconnectingSocketReconnectOptions {
+    /** Reconnect after an unclean close. Default `true`. */
+    enabled?: boolean;
+    /** Max consecutive retries before giving up. Default `Infinity`. */
+    maxAttempts?: number;
+    /** Delay before the first retry, in ms. Default `500`. */
+    baseDelayMs?: number;
+    /** Upper bound on any single retry delay, in ms. Default `10_000`. */
+    maxDelayMs?: number;
+    /** Apply random jitter to retry delays. Default `true`. */
+    jitter?: boolean;
+}
+/**
+ * Heartbeat tuning for {@link createReconnectingSocket}. Disabled by default —
+ * enable only when the server expects periodic client keepalive frames.
+ */
+export interface ReconnectingSocketHeartbeatOptions {
+    /** Send a periodic keepalive frame while open. Default `false`. */
+    enabled?: boolean;
+    /** Interval between keepalive frames, in ms. Default `30_000`. */
+    intervalMs?: number;
+    /** The keepalive frame to send. Default `"ping"`. */
+    message?: string;
+}
+/**
+ * Reason a socket closed, delivered to {@link ReconnectingSocketOptions.onClose}.
+ */
+export interface SocketCloseInfo {
+    /** WebSocket close code, if the implementation supplied one. */
+    code?: number;
+    /** WebSocket close reason, if any. */
+    reason?: string;
+    /** Whether the socket will attempt to reconnect after this close. */
+    willReconnect: boolean;
+}
+/**
+ * Options for {@link createReconnectingSocket}.
+ */
+export interface ReconnectingSocketOptions {
+    /** Endpoint URL (`ws://` / `wss://`). */
+    url: string;
+    /** Optional subprotocol(s), forwarded to the WebSocket constructor. */
+    protocols?: string | string[];
+    /** WebSocket implementation to dial with (resolve from `config.getWebSocketConstructor()`). */
+    webSocketConstructor: WebSocketConstructor;
+    /**
+     * Frames sent on every (re)open, in order, before any buffered `send`s.
+     * Put subscribe messages here so subscriptions are re-established after a
+     * reconnect without consumer involvement.
+     */
+    getOpenMessages?: () => string[];
+    /** Reconnect tuning. */
+    reconnect?: ReconnectingSocketReconnectOptions;
+    /** Heartbeat tuning. */
+    heartbeat?: ReconnectingSocketHeartbeatOptions;
+    /** Called each time the socket transitions to `open`. */
+    onOpen?: () => void;
+    /** Called each time the underlying connection closes (transient or terminal). */
+    onClose?: (info: SocketCloseInfo) => void;
+    /** Called on a transport-level error; receives the raw error event. */
+    onError?: (event: unknown) => void;
+    /** Called for each inbound frame; `data` is the raw `event.data` (usually a JSON string). */
+    onMessage?: (data: unknown) => void;
+    /** Called whenever {@link SocketStatus} changes. */
+    onStatusChange?: (status: SocketStatus) => void;
+    /** Randomness source for backoff jitter. Injectable for tests; defaults to `Math.random`. */
+    random?: () => number;
+}
+/**
+ * A managed, self-reconnecting WebSocket handle.
+ */
+export interface ReconnectingSocket {
+    /** Send a text frame now if open, otherwise buffer it until the next open. */
+    send(data: string): void;
+    /** Close permanently (no reconnect), flushing timers. Idempotent. */
+    close(): void;
+    /** Current connection status. */
+    getStatus(): SocketStatus;
+}
+/**
+ * Create a self-reconnecting WebSocket around an injected implementation.
+ *
+ * Handles the reliability concerns a raw `WebSocket` does not: exponential
+ * backoff with jitter, status transitions, outbound buffering while not open,
+ * and re-sending `getOpenMessages()` on every (re)open so subscriptions survive
+ * reconnects. Framework-agnostic — no DOM or React assumptions; the socket
+ * implementation and randomness are injected.
+ *
+ * The returned socket starts dialing immediately.
+ *
+ * @example
+ * ```ts
+ * const socket = createReconnectingSocket({
+ *   url: "wss://example/ws",
+ *   webSocketConstructor: config.getWebSocketConstructor(),
+ *   getOpenMessages: () => [JSON.stringify({ subscribe: account })],
+ *   onMessage: (data) => handle(JSON.parse(String(data))),
+ * });
+ * // later
+ * socket.close();
+ * ```
+ */
+export declare function createReconnectingSocket(options: ReconnectingSocketOptions): ReconnectingSocket;
+//# sourceMappingURL=create-reconnecting-socket.d.ts.map

package/dist/websocket/socket/create-reconnecting-socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-reconnecting-socket.d.ts","sourceRoot":"","sources":["../../../src/websocket/socket/create-reconnecting-socket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,8BAA8B,CAAC;AAExF,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD,wDAAwD;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,kCAAkC;IACjD,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B,+FAA+F;IAC/F,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;IACjC,wBAAwB;IACxB,SAAS,CAAC,EAAE,kCAAkC,CAAC;IAC/C,wBAAwB;IACxB,SAAS,CAAC,EAAE,kCAAkC,CAAC;IAC/C,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,iFAAiF;IACjF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;IAC1C,uEAAuE;IACvE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,6FAA6F;IAC7F,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,oDAAoD;IACpD,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAChD,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,qEAAqE;IACrE,KAAK,IAAI,IAAI,CAAC;IACd,iCAAiC;IACjC,SAAS,IAAI,YAAY,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAwJ/F"}

package/dist/websocket/socket/create-reconnecting-socket.js

@@ -0,0 +1,101 @@
+import { computeBackoffDelay as e } from "./backoff.js";
+import { SOCKET_READY_STATE as t } from "./socket-status.js";
+//#region src/websocket/socket/create-reconnecting-socket.ts
+function n(n) {
+	let r = {
+		enabled: n.reconnect?.enabled ?? !0,
+		maxAttempts: n.reconnect?.maxAttempts ?? Infinity,
+		baseDelayMs: n.reconnect?.baseDelayMs ?? 500,
+		maxDelayMs: n.reconnect?.maxDelayMs ?? 1e4,
+		jitter: n.reconnect?.jitter ?? !0
+	}, i = {
+		enabled: n.heartbeat?.enabled ?? !1,
+		intervalMs: n.heartbeat?.intervalMs ?? 3e4,
+		message: n.heartbeat?.message ?? "ping"
+	}, a = null, o = "connecting", s = 0, c = !1, l = [], u = null, d = null;
+	function f(e) {
+		o !== e && (o = e, n.onStatusChange?.(e));
+	}
+	function p() {
+		u !== null && (clearTimeout(u), u = null);
+	}
+	function m() {
+		d !== null && (clearInterval(d), d = null);
+	}
+	function h(e, r) {
+		try {
+			e.readyState === t.OPEN && e.send(r);
+		} catch (e) {
+			n.onError?.(e);
+		}
+	}
+	function g(e) {
+		i.enabled && (m(), d = setInterval(() => h(e, i.message), i.intervalMs));
+	}
+	function _() {
+		p(), f("connecting");
+		let e;
+		try {
+			e = new n.webSocketConstructor(n.url, n.protocols);
+		} catch (e) {
+			n.onError?.(e), v();
+			return;
+		}
+		a = e, e.onopen = () => {
+			if (a === e) {
+				s = 0, f("open"), n.onOpen?.();
+				for (let t of n.getOpenMessages?.() ?? []) h(e, t);
+				if (l.length > 0) {
+					let t = l;
+					l = [];
+					for (let n of t) h(e, n);
+				}
+				g(e);
+			}
+		}, e.onmessage = (t) => {
+			a === e && n.onMessage?.(t.data);
+		}, e.onerror = (t) => {
+			a === e && n.onError?.(t);
+		}, e.onclose = (t) => {
+			if (a !== e) return;
+			m(), a = null;
+			let i = !c && r.enabled && s < r.maxAttempts;
+			if (n.onClose?.({
+				code: t?.code,
+				reason: t?.reason,
+				willReconnect: i
+			}), !i) {
+				f("closed");
+				return;
+			}
+			v();
+		};
+	}
+	function v() {
+		f("reconnecting");
+		let t = e(s, r, n.random);
+		s += 1, u = setTimeout(_, t);
+	}
+	function y(e) {
+		a && a.readyState === t.OPEN ? h(a, e) : l.push(e);
+	}
+	function b() {
+		if (!c) if (c = !0, p(), m(), l = [], a) {
+			f("closing");
+			try {
+				a.close();
+			} catch {
+				f("closed");
+			}
+		} else f("closed");
+	}
+	return _(), {
+		send: y,
+		close: b,
+		getStatus: () => o
+	};
+}
+//#endregion
+export { n as createReconnectingSocket };
+
+//# sourceMappingURL=create-reconnecting-socket.js.map

package/dist/websocket/socket/create-reconnecting-socket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-reconnecting-socket.js","names":[],"sources":["../../../src/websocket/socket/create-reconnecting-socket.ts"],"sourcesContent":["import type { WebSocketConstructor, WebSocketLike } from \"../../shared/types/websocket\";\nimport { computeBackoffDelay } from \"./backoff\";\nimport { SOCKET_READY_STATE, type SocketStatus } from \"./socket-status\";\n\n/**\n * Reconnect tuning for {@link createReconnectingSocket}. All fields optional;\n * defaults match the SDK's notifications behavior (unlimited retries, 500ms →\n * 10s exponential backoff with jitter).\n */\nexport interface ReconnectingSocketReconnectOptions {\n  /** Reconnect after an unclean close. Default `true`. */\n  enabled?: boolean;\n  /** Max consecutive retries before giving up. Default `Infinity`. */\n  maxAttempts?: number;\n  /** Delay before the first retry, in ms. Default `500`. */\n  baseDelayMs?: number;\n  /** Upper bound on any single retry delay, in ms. Default `10_000`. */\n  maxDelayMs?: number;\n  /** Apply random jitter to retry delays. Default `true`. */\n  jitter?: boolean;\n}\n\n/**\n * Heartbeat tuning for {@link createReconnectingSocket}. Disabled by default —\n * enable only when the server expects periodic client keepalive frames.\n */\nexport interface ReconnectingSocketHeartbeatOptions {\n  /** Send a periodic keepalive frame while open. Default `false`. */\n  enabled?: boolean;\n  /** Interval between keepalive frames, in ms. Default `30_000`. */\n  intervalMs?: number;\n  /** The keepalive frame to send. Default `\"ping\"`. */\n  message?: string;\n}\n\n/**\n * Reason a socket closed, delivered to {@link ReconnectingSocketOptions.onClose}.\n */\nexport interface SocketCloseInfo {\n  /** WebSocket close code, if the implementation supplied one. */\n  code?: number;\n  /** WebSocket close reason, if any. */\n  reason?: string;\n  /** Whether the socket will attempt to reconnect after this close. */\n  willReconnect: boolean;\n}\n\n/**\n * Options for {@link createReconnectingSocket}.\n */\nexport interface ReconnectingSocketOptions {\n  /** Endpoint URL (`ws://` / `wss://`). */\n  url: string;\n  /** Optional subprotocol(s), forwarded to the WebSocket constructor. */\n  protocols?: string | string[];\n  /** WebSocket implementation to dial with (resolve from `config.getWebSocketConstructor()`). */\n  webSocketConstructor: WebSocketConstructor;\n  /**\n   * Frames sent on every (re)open, in order, before any buffered `send`s.\n   * Put subscribe messages here so subscriptions are re-established after a\n   * reconnect without consumer involvement.\n   */\n  getOpenMessages?: () => string[];\n  /** Reconnect tuning. */\n  reconnect?: ReconnectingSocketReconnectOptions;\n  /** Heartbeat tuning. */\n  heartbeat?: ReconnectingSocketHeartbeatOptions;\n  /** Called each time the socket transitions to `open`. */\n  onOpen?: () => void;\n  /** Called each time the underlying connection closes (transient or terminal). */\n  onClose?: (info: SocketCloseInfo) => void;\n  /** Called on a transport-level error; receives the raw error event. */\n  onError?: (event: unknown) => void;\n  /** Called for each inbound frame; `data` is the raw `event.data` (usually a JSON string). */\n  onMessage?: (data: unknown) => void;\n  /** Called whenever {@link SocketStatus} changes. */\n  onStatusChange?: (status: SocketStatus) => void;\n  /** Randomness source for backoff jitter. Injectable for tests; defaults to `Math.random`. */\n  random?: () => number;\n}\n\n/**\n * A managed, self-reconnecting WebSocket handle.\n */\nexport interface ReconnectingSocket {\n  /** Send a text frame now if open, otherwise buffer it until the next open. */\n  send(data: string): void;\n  /** Close permanently (no reconnect), flushing timers. Idempotent. */\n  close(): void;\n  /** Current connection status. */\n  getStatus(): SocketStatus;\n}\n\n/**\n * Create a self-reconnecting WebSocket around an injected implementation.\n *\n * Handles the reliability concerns a raw `WebSocket` does not: exponential\n * backoff with jitter, status transitions, outbound buffering while not open,\n * and re-sending `getOpenMessages()` on every (re)open so subscriptions survive\n * reconnects. Framework-agnostic — no DOM or React assumptions; the socket\n * implementation and randomness are injected.\n *\n * The returned socket starts dialing immediately.\n *\n * @example\n * ```ts\n * const socket = createReconnectingSocket({\n *   url: \"wss://example/ws\",\n *   webSocketConstructor: config.getWebSocketConstructor(),\n *   getOpenMessages: () => [JSON.stringify({ subscribe: account })],\n *   onMessage: (data) => handle(JSON.parse(String(data))),\n * });\n * // later\n * socket.close();\n * ```\n */\nexport function createReconnectingSocket(options: ReconnectingSocketOptions): ReconnectingSocket {\n  const reconnect = {\n    enabled: options.reconnect?.enabled ?? true,\n    maxAttempts: options.reconnect?.maxAttempts ?? Number.POSITIVE_INFINITY,\n    baseDelayMs: options.reconnect?.baseDelayMs ?? 500,\n    maxDelayMs: options.reconnect?.maxDelayMs ?? 10_000,\n    jitter: options.reconnect?.jitter ?? true,\n  };\n  const heartbeat = {\n    enabled: options.heartbeat?.enabled ?? false,\n    intervalMs: options.heartbeat?.intervalMs ?? 30_000,\n    message: options.heartbeat?.message ?? \"ping\",\n  };\n\n  let ws: WebSocketLike | null = null;\n  let status: SocketStatus = \"connecting\";\n  let attempt = 0;\n  let closedByUser = false;\n  let outbox: string[] = [];\n  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;\n  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;\n\n  function setStatus(next: SocketStatus): void {\n    if (status === next) return;\n    status = next;\n    options.onStatusChange?.(next);\n  }\n\n  function clearReconnectTimer(): void {\n    if (reconnectTimer !== null) {\n      clearTimeout(reconnectTimer);\n      reconnectTimer = null;\n    }\n  }\n\n  function stopHeartbeat(): void {\n    if (heartbeatTimer !== null) {\n      clearInterval(heartbeatTimer);\n      heartbeatTimer = null;\n    }\n  }\n\n  function safeSend(target: WebSocketLike, data: string): void {\n    try {\n      if (target.readyState === SOCKET_READY_STATE.OPEN) target.send(data);\n    } catch (err) {\n      options.onError?.(err);\n    }\n  }\n\n  function startHeartbeat(target: WebSocketLike): void {\n    if (!heartbeat.enabled) return;\n    stopHeartbeat();\n    heartbeatTimer = setInterval(() => safeSend(target, heartbeat.message), heartbeat.intervalMs);\n  }\n\n  function connect(): void {\n    clearReconnectTimer();\n    setStatus(\"connecting\");\n\n    let socket: WebSocketLike;\n    try {\n      socket = new options.webSocketConstructor(options.url, options.protocols);\n    } catch (err) {\n      options.onError?.(err);\n      scheduleReconnect();\n      return;\n    }\n    ws = socket;\n\n    socket.onopen = () => {\n      if (ws !== socket) return;\n      attempt = 0;\n      setStatus(\"open\");\n      options.onOpen?.();\n      for (const message of options.getOpenMessages?.() ?? []) safeSend(socket, message);\n      if (outbox.length > 0) {\n        const pending = outbox;\n        outbox = [];\n        for (const message of pending) safeSend(socket, message);\n      }\n      startHeartbeat(socket);\n    };\n\n    socket.onmessage = (event) => {\n      if (ws !== socket) return;\n      options.onMessage?.(event.data);\n    };\n\n    socket.onerror = (event) => {\n      if (ws !== socket) return;\n      options.onError?.(event);\n    };\n\n    socket.onclose = (event) => {\n      if (ws !== socket) return;\n      stopHeartbeat();\n      ws = null;\n\n      const willReconnect = !closedByUser && reconnect.enabled && attempt < reconnect.maxAttempts;\n      options.onClose?.({ code: event?.code, reason: event?.reason, willReconnect });\n\n      if (!willReconnect) {\n        setStatus(\"closed\");\n        return;\n      }\n      scheduleReconnect();\n    };\n  }\n\n  function scheduleReconnect(): void {\n    setStatus(\"reconnecting\");\n    const delay = computeBackoffDelay(attempt, reconnect, options.random);\n    attempt += 1;\n    reconnectTimer = setTimeout(connect, delay);\n  }\n\n  function send(data: string): void {\n    if (ws && ws.readyState === SOCKET_READY_STATE.OPEN) {\n      safeSend(ws, data);\n    } else {\n      outbox.push(data);\n    }\n  }\n\n  function close(): void {\n    if (closedByUser) return;\n    closedByUser = true;\n    clearReconnectTimer();\n    stopHeartbeat();\n    outbox = [];\n\n    if (ws) {\n      setStatus(\"closing\");\n      try {\n        ws.close();\n      } catch {\n        // ignore — onclose may not fire if the socket never opened\n        setStatus(\"closed\");\n      }\n    } else {\n      setStatus(\"closed\");\n    }\n  }\n\n  connect();\n\n  return {\n    send,\n    close,\n    getStatus: () => status,\n  };\n}\n"],"mappings":"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"}

package/dist/websocket/socket/get-socket-pool.d.ts

@@ -0,0 +1,13 @@
+import { Config } from '../../core/config';
+import { SocketPool } from './socket-pool';
+/**
+ * Return the shared {@link SocketPool} bound to a {@link Config}. Lazily
+ * created on first call and reused across every WebSocket watcher
+ * (notifications, TP/SL, prices) so a given URL is opened once and shared.
+ *
+ * Pools are keyed by `Config` identity via a {@link WeakMap}, so swapping
+ * configs (tests, multi-chain hosts) gets a fresh pool instead of leaking
+ * sockets between unrelated SDK instances.
+ */
+export declare function getSocketPool(config: Config): SocketPool;
+//# sourceMappingURL=get-socket-pool.d.ts.map

package/dist/websocket/socket/get-socket-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-socket-pool.d.ts","sourceRoot":"","sources":["../../../src/websocket/socket/get-socket-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAKlE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAOxD"}

package/dist/websocket/socket/get-socket-pool.js

@@ -0,0 +1,11 @@
+import { createSocketPool as e } from "./socket-pool.js";
+//#region src/websocket/socket/get-socket-pool.ts
+var t = /* @__PURE__ */ new WeakMap();
+function n(n) {
+	let r = t.get(n);
+	return r || (r = e(), t.set(n, r)), r;
+}
+//#endregion
+export { n as getSocketPool };
+
+//# sourceMappingURL=get-socket-pool.js.map

package/dist/websocket/socket/get-socket-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-socket-pool.js","names":[],"sources":["../../../src/websocket/socket/get-socket-pool.ts"],"sourcesContent":["import type { Config } from \"../../core/config\";\nimport { createSocketPool, type SocketPool } from \"./socket-pool\";\n\n/** Per-config socket pools, so connections never leak across `Config` instances. */\nconst pools = new WeakMap<Config, SocketPool>();\n\n/**\n * Return the shared {@link SocketPool} bound to a {@link Config}. Lazily\n * created on first call and reused across every WebSocket watcher\n * (notifications, TP/SL, prices) so a given URL is opened once and shared.\n *\n * Pools are keyed by `Config` identity via a {@link WeakMap}, so swapping\n * configs (tests, multi-chain hosts) gets a fresh pool instead of leaking\n * sockets between unrelated SDK instances.\n */\nexport function getSocketPool(config: Config): SocketPool {\n  let pool = pools.get(config);\n  if (!pool) {\n    pool = createSocketPool();\n    pools.set(config, pool);\n  }\n  return pool;\n}\n"],"mappings":";;AAIA,IAAM,oBAAQ,IAAI,QAA4B;AAW9C,SAAgB,EAAc,GAA4B;CACxD,IAAI,IAAO,EAAM,IAAI,CAAM;CAK3B,OAJK,MACH,IAAO,EAAiB,GACxB,EAAM,IAAI,GAAQ,CAAI,IAEjB;AACT"}

package/dist/websocket/socket/index.d.ts

@@ -0,0 +1,5 @@
+export * from './backoff';
+export * from './create-reconnecting-socket';
+export * from './socket-pool';
+export * from './socket-status';
+//# sourceMappingURL=index.d.ts.map

package/dist/websocket/socket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/websocket/socket/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}