@upbit-official/upbit-sdk 1.0.0 → 1.1.0

package/src/lib/ws.ts

@@ -1,14 +1,31 @@
 import * as WS from 'ws';
 import { uuid4 } from '../internal/utils/uuid';
 import { createJwtToken } from './jwtAuth';
-import { jsonParseFloat } from './jsonParseFloat';
 import { buildURL as buildPublicURL } from '../resources/ws-public/internal-base';
 import { buildURL as buildPrivateURL } from '../resources/ws-private/internal-base';
+import { buildURL as buildInfoURL } from '../resources/ws-info/internal-base';
 import type { ConnectPublicServerEvent } from '../resources/ws-public/ws-public';
-import type { ConnectPrivateServerEvent } from '../resources/ws-private/ws-private';
+import type {
+  ListSubscriptionsResponse,
+  ListSubscriptionsServerResponse,
+  SimpleListSubscriptionsResponse,
+} from '../resources/ws-public/ws-public';
+import type { AnnouncementCategory, ConnectPrivateServerEvent } from '../resources/ws-private/ws-private';
+import type { ConnectInfoServerEvent } from '../resources/ws-info/ws-info';
+import type { ConnectInfoClientEvent } from '../resources/ws-info/ws-info';
+import {
+  parseWebSocketValue,
+  isListSubscriptionsResponse,
+  type InfoWebSocketUnknownMessage,
+  type WebSocketMessage,
+} from '../internal/ws-parser';
+import type { SimpleWebSocketEvent } from '../internal/ws-simple-types';
+import type { SimpleWebSocketEvent as ExtensibleSimpleEvent } from '../internal/ws-parser';
 import type { Upbit } from '../client';
 
 export interface WsStreamOptions {
+  /** Response format (default: DEFAULT). Preserved for queries and reconnects. */
+  format?: WsStreamFormat;
   /** Maximum number of reconnection attempts (default: 5) */
   maxRetries?: number;
   /** Reconnection delay in ms (default: 1000) */
@@ -19,55 +36,220 @@ export interface WsStreamOptions {
   onReconnect?: () => void;
 }
 
+export type WsStreamFormat = 'DEFAULT' | 'SIMPLE' | 'JSON_LIST' | 'SIMPLE_LIST';
+
+export enum WsEndpoint {
+  Public = 'public',
+  Private = 'private',
+  Info = 'info',
+}
+
+function requiresAuth(endpoint: WsEndpoint): boolean {
+  return endpoint !== WsEndpoint.Public;
+}
+
+export type WsDefaultListSubscriptionsResponse = ListSubscriptionsResponse;
+
+export type WsSimpleListSubscriptionsResponse = SimpleListSubscriptionsResponse;
+
+export type WsListSubscriptionsResponse = ListSubscriptionsServerResponse;
+
+export interface WsAnnouncementOptions extends WsStreamOptions {
+  /** Response format (default: DEFAULT). */
+  format?: WsStreamFormat;
+  /** Announcement categories to receive. Omit to receive all categories. */
+  categories?: AnnouncementCategory[];
+  /** Whether to include the announcement body in stream messages. */
+  includeBody?: boolean;
+}
+
+export type WsIndicatorSubscription = Omit<Extract<InfoSubscription, { type: 'indicator' }>, 'type'>;
+
+export interface WsIndicatorOptions extends Omit<WsIndicatorSubscription, 'codes'>, WsStreamOptions {
+  format?: WsStreamFormat;
+}
+
+export type WsIndicatorSignalSubscription = Omit<
+  Extract<InfoSubscription, { type: 'indicator_signal' }>,
+  'type'
+>;
+export interface WsIndicatorSignalOptions
+  extends Omit<WsIndicatorSignalSubscription, 'codes'>,
+    WsStreamOptions {
+  format?: WsStreamFormat;
+}
+
 type PublicSubscriptionType =
   | { type: 'ticker'; codes: string[] }
   | { type: 'trade'; codes: string[] }
   | { type: 'orderbook'; codes: string[] }
   | { type: string; codes: string[] }; // candle.{interval}
 
-type PrivateSubscriptionType = { type: 'myOrder'; codes?: string[] } | { type: 'myAsset' };
-
-type AnySubscriptionType = PublicSubscriptionType | PrivateSubscriptionType;
-
-function buildSubscriptionMessage(types: AnySubscriptionType[]): string {
+type AnnouncementSubscriptionType = {
+  type: 'announcement';
+  categories?: AnnouncementCategory[];
+  include_body?: boolean;
+};
+
+type PrivateSubscriptionType =
+  | AnnouncementSubscriptionType
+  | { type: 'myOrder'; codes?: string[] }
+  | { type: 'myAsset' };
+
+export type InfoSubscription = Extract<
+  ConnectInfoClientEvent[number],
+  { type: 'indicator' | 'indicator_signal' }
+>;
+
+type AnySubscriptionType = PublicSubscriptionType | PrivateSubscriptionType | InfoSubscription;
+type WsServerEvent =
+  | ConnectPublicServerEvent
+  | ConnectPrivateServerEvent
+  | ConnectInfoServerEvent
+  | InfoWebSocketUnknownMessage;
+export type WsSimpleEvent = SimpleWebSocketEvent;
+export type WsStreamEvent =
+  | WebSocketMessage<WsServerEvent | WsSimpleEvent | ExtensibleSimpleEvent>
+  | WsListSubscriptionsResponse
+  | Array<
+      WebSocketMessage<WsServerEvent | WsSimpleEvent | ExtensibleSimpleEvent> | WsListSubscriptionsResponse
+    >;
+
+type PublicEvent<Type extends ConnectPublicServerEvent['type']> = Extract<
+  ConnectPublicServerEvent,
+  { type: Type }
+>;
+type CandleEvent = Exclude<ConnectPublicServerEvent, PublicEvent<'ticker' | 'trade' | 'orderbook'>>;
+type PrivateEvent<Type extends ConnectPrivateServerEvent['type']> = Extract<
+  ConnectPrivateServerEvent,
+  { type: Type }
+>;
+type InfoEvent<Type extends ConnectInfoServerEvent['type']> = Extract<ConnectInfoServerEvent, { type: Type }>;
+
+export function buildSubscriptionMessage(types: AnySubscriptionType[], format?: WsStreamFormat): string {
   const fields: object[] = [{ ticket: uuid4() }];
   for (const t of types) {
-    if ('codes' in t && t.codes) {
-      fields.push({ type: t.type, codes: t.codes });
-    } else {
-      fields.push({ type: t.type });
-    }
+    fields.push(t);
   }
+  if (format !== undefined) fields.push({ format });
+  return JSON.stringify(fields);
+}
+
+export function buildListSubscriptionsMessage(format?: WsStreamFormat): string {
+  const fields: object[] = [{ ticket: uuid4() }, { method: 'LIST_SUBSCRIPTIONS' }];
+  if (format !== undefined) fields.push({ format });
   return JSON.stringify(fields);
 }
 
+export function parseWsMessage(data: string): unknown {
+  return parseWebSocketValue(data);
+}
+
+function buildAnnouncementSubscription(
+  categories?: AnnouncementCategory[],
+  includeBody?: boolean,
+): AnnouncementSubscriptionType {
+  const subscription: AnnouncementSubscriptionType = { type: 'announcement' };
+  if (categories !== undefined) subscription.categories = categories;
+  if (includeBody !== undefined) subscription.include_body = includeBody;
+  return subscription;
+}
+
 /**
  * Manages a WebSocket stream as an AsyncIterable.
  *
  * Use with `for await (const event of manager) { ... }`.
  */
-export class WsStreamManager implements AsyncIterable<ConnectPublicServerEvent | ConnectPrivateServerEvent> {
+export class WsStreamManager<Event = ConnectPublicServerEvent | ConnectPrivateServerEvent>
+  implements AsyncIterable<Event>
+{
   private readonly client: Upbit;
   private readonly types: AnySubscriptionType[];
-  private readonly isPrivate: boolean;
+  private readonly endpoint: WsEndpoint;
+  private readonly format: WsStreamFormat | undefined;
   private readonly maxRetries: number;
   private readonly retryDelayMs: number;
   private readonly onDisconnect: WsStreamOptions['onDisconnect'];
   private readonly onReconnect: WsStreamOptions['onReconnect'];
   private _currentWs: WS.WebSocket | null = null;
-
-  constructor(client: Upbit, types: AnySubscriptionType[], isPrivate: boolean, opts: WsStreamOptions = {}) {
+  private _pendingListSubscriptions:
+    | {
+        resolve: (value: WsListSubscriptionsResponse) => void;
+        reject: (reason: Error) => void;
+        timer: ReturnType<typeof setTimeout>;
+        socket: WS.WebSocket;
+        ticket: string;
+      }
+    | undefined;
+
+  constructor(
+    client: Upbit,
+    types: AnySubscriptionType[],
+    privateConnection: boolean,
+    opts?: WsStreamOptions & { format?: WsStreamFormat },
+  );
+  constructor(
+    client: Upbit,
+    types: AnySubscriptionType[],
+    endpoint: WsEndpoint,
+    opts?: WsStreamOptions & { format?: WsStreamFormat },
+  );
+  constructor(
+    client: Upbit,
+    types: AnySubscriptionType[],
+    endpoint: WsEndpoint | boolean,
+    opts: WsStreamOptions & { format?: WsStreamFormat } = {},
+  ) {
     this.client = client;
     this.types = types;
-    this.isPrivate = isPrivate;
+    this.endpoint =
+      typeof endpoint === 'boolean' ?
+        endpoint ? WsEndpoint.Private
+        : WsEndpoint.Public
+      : endpoint;
+    this.format = opts.format;
     this.maxRetries = opts.maxRetries ?? 5;
     this.retryDelayMs = opts.retryDelayMs ?? 1000;
     if (opts.onDisconnect) this.onDisconnect = opts.onDisconnect;
     if (opts.onReconnect) this.onReconnect = opts.onReconnect;
   }
 
+  /**
+   * Returns subscriptions for this stream's currently open connection.
+   * Start consuming the iterator before calling; calls before connection reject.
+   * The response format is unchanged. Responses are matched by request ticket.
+   */
+  listSubscriptions(timeoutMs = 5000): Promise<WsListSubscriptionsResponse> {
+    const ws = this._currentWs;
+    if (!ws || ws.readyState !== WS.WebSocket.OPEN) {
+      return Promise.reject(new Error('WebSocket connection is not open'));
+    }
+    if (this._pendingListSubscriptions) {
+      return Promise.reject(new Error('LIST_SUBSCRIPTIONS request is already pending'));
+    }
+    return new Promise((resolve, reject) => {
+      const message = buildListSubscriptionsMessage(this.format);
+      const ticket: string = JSON.parse(message)[0].ticket;
+      const timer = setTimeout(() => {
+        if (this._pendingListSubscriptions?.ticket === ticket) {
+          this._settlePendingListSubscriptions(
+            ws,
+            new Error('LIST_SUBSCRIPTIONS response not received within timeout'),
+          );
+        }
+      }, timeoutMs);
+      this._pendingListSubscriptions = { resolve, reject, timer, socket: ws, ticket };
+      try {
+        ws.send(message);
+      } catch (error) {
+        this._settlePendingListSubscriptions(ws, error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+
   /** Closes the current WebSocket connection. */
   close(): void {
+    if (this._currentWs) this._settlePendingListSubscriptions(this._currentWs, new Error('WebSocket closed'));
     if (
       this._currentWs &&
       (this._currentWs.readyState === WS.WebSocket.OPEN ||
@@ -77,47 +259,73 @@ export class WsStreamManager implements AsyncIterable<ConnectPublicServerEvent |
     }
   }
 
-  [Symbol.asyncIterator](): AsyncGenerator<ConnectPublicServerEvent | ConnectPrivateServerEvent> {
-    return this._iterate();
+  [Symbol.asyncIterator](): AsyncGenerator<Event> {
+    const iterator = this._iterate();
+    const finish = iterator.return.bind(iterator);
+    iterator.return = (value) => {
+      if (this._currentWs)
+        this._settlePendingListSubscriptions(this._currentWs, new Error('WebSocket iterator ended'));
+      this.close();
+      return finish(value);
+    };
+    return iterator;
   }
 
-  private async *_iterate(): AsyncGenerator<ConnectPublicServerEvent | ConnectPrivateServerEvent> {
+  private async *_iterate(): AsyncGenerator<Event> {
     let retries = 0;
 
     while (true) {
-      const queue: Array<ConnectPublicServerEvent | ConnectPrivateServerEvent> = [];
+      const queue: WsStreamEvent[] = [];
       let resolve: (() => void) | null = null;
       let reject: ((err: Error) => void) | null = null;
       let done = false;
       let closeCode = 1000;
       let closeReason = '';
+      let pingTimer: ReturnType<typeof setInterval> | undefined;
 
       const ws = await this._connect();
       this._currentWs = ws;
 
       ws.on('message', (data: WS.RawData) => {
+        let parsed: unknown;
         try {
-          const parsed = jsonParseFloat(data.toString()) as
-            | ConnectPublicServerEvent
-            | ConnectPrivateServerEvent;
-          queue.push(parsed);
-          resolve?.();
-          resolve = null;
+          parsed = parseWebSocketValue(data);
         } catch {
-          // ignore JSON parse errors
+          return; // Preserve the stream's existing handling of malformed JSON.
         }
+        const items = Array.isArray(parsed) ? parsed : [parsed];
+        const remaining = items.filter((item) => {
+          if (!isListSubscriptionsResponse(item)) return true;
+          return !this._settlePendingListSubscriptions(ws, item);
+        });
+        if (remaining.length > 0 || (Array.isArray(parsed) && parsed.length === 0)) {
+          // Preserve the single versus list envelope for every endpoint.
+          queue.push((Array.isArray(parsed) ? remaining : remaining[0]) as WsStreamEvent);
+        }
+        resolve?.();
+        resolve = null;
       });
 
+      if (this.endpoint === WsEndpoint.Info) {
+        pingTimer = setInterval(() => {
+          if (ws.readyState === WS.WebSocket.OPEN) ws.ping();
+        }, 30_000);
+      }
+
       ws.on('close', (code: number, reason: Buffer) => {
+        if (pingTimer !== undefined) clearInterval(pingTimer);
         done = true;
         closeCode = code;
         closeReason = reason.toString();
+        this._settlePendingListSubscriptions(ws, new Error(`WebSocket disconnected (code=${code})`));
         resolve?.();
         resolve = null;
       });
 
       ws.on('error', (err: Error) => {
+        if (pingTimer !== undefined) clearInterval(pingTimer);
         done = true;
+        this._settlePendingListSubscriptions(ws, err);
         reject?.(err);
         reject = null;
         resolve?.();
@@ -133,11 +341,13 @@ export class WsStreamManager implements AsyncIterable<ConnectPublicServerEvent |
             });
           }
           while (queue.length > 0) {
-            yield queue.shift()!;
+            yield queue.shift()! as Event;
           }
         }
       } finally {
-        this._currentWs = null;
+        if (pingTimer !== undefined) clearInterval(pingTimer);
+        this._settlePendingListSubscriptions(ws, new Error('WebSocket iterator ended'));
+        if (this._currentWs === ws) this._currentWs = null;
         if (ws.readyState === WS.WebSocket.OPEN || ws.readyState === WS.WebSocket.CONNECTING) {
           ws.close();
         }
@@ -165,25 +375,30 @@ export class WsStreamManager implements AsyncIterable<ConnectPublicServerEvent |
   }
 
   private async _connect(): Promise<WS.WebSocket> {
-    const url = this.isPrivate ? buildPrivateURL(this.client) : buildPublicURL(this.client);
+    const url =
+      this.endpoint === WsEndpoint.Info ? buildInfoURL(this.client)
+      : this.endpoint === WsEndpoint.Private ? buildPrivateURL(this.client)
+      : buildPublicURL(this.client);
 
-    const headers: Record<string, string> = {};
+    let authHeaders: Record<string, string> | undefined;
 
-    if (this.isPrivate) {
+    if (requiresAuth(this.endpoint)) {
       const { accessKey, secretKey } = this.client;
       if (!accessKey || !secretKey) {
-        throw new Error('Private WebSocket requires accessKey and secretKey');
+        throw new Error(`${this.endpoint} WebSocket requires accessKey and secretKey`);
       }
       const token = createJwtToken(accessKey, secretKey);
-      headers['Authorization'] = `Bearer ${token}`;
+      authHeaders = { Authorization: `Bearer ${token}` };
     }
 
+    const headers = this.client._buildWebSocketHandshakeHeaders(authHeaders);
+
     return new Promise<WS.WebSocket>((resolve, reject) => {
       const ws = new WS.WebSocket(url.toString(), { headers });
 
       const onOpen = () => {
         ws.removeListener('error', onError);
-        ws.send(buildSubscriptionMessage(this.types));
+        ws.send(buildSubscriptionMessage(this.types, this.format));
         resolve(ws);
       };
 
@@ -196,6 +411,23 @@ export class WsStreamManager implements AsyncIterable<ConnectPublicServerEvent |
       ws.once('error', onError);
     });
   }
+
+  private _settlePendingListSubscriptions(
+    ws: WS.WebSocket,
+    result: Error | WsListSubscriptionsResponse,
+  ): boolean {
+    const pending = this._pendingListSubscriptions;
+    if (!pending || pending.socket !== ws) return false;
+    if (!(result instanceof Error)) {
+      const ticket = 'ticket' in result ? result.ticket : result.tckt;
+      if (pending.ticket !== ticket) return false;
+    }
+    this._pendingListSubscriptions = undefined;
+    clearTimeout(pending.timer);
+    if (result instanceof Error) pending.reject(result);
+    else pending.resolve(result);
+    return true;
+  }
 }
 
 /**
@@ -208,34 +440,67 @@ export class WsStream {
   constructor(private readonly client: Upbit) {}
 
   /** Subscribe to the ticker (current price) stream. */
-  ticker(codes: string[], opts?: WsStreamOptions): WsStreamManager {
-    return new WsStreamManager(this.client, [{ type: 'ticker', codes }], false, opts);
+  ticker(codes: string[], opts?: WsStreamOptions): WsStreamManager<PublicEvent<'ticker'>> {
+    return new WsStreamManager(this.client, [{ type: 'ticker', codes }], WsEndpoint.Public, opts);
   }
 
   /** Subscribe to the trade (executed order) stream. */
-  trade(codes: string[], opts?: WsStreamOptions): WsStreamManager {
-    return new WsStreamManager(this.client, [{ type: 'trade', codes }], false, opts);
+  trade(codes: string[], opts?: WsStreamOptions): WsStreamManager<PublicEvent<'trade'>> {
+    return new WsStreamManager(this.client, [{ type: 'trade', codes }], WsEndpoint.Public, opts);
   }
 
   /** Subscribe to the orderbook stream. */
-  orderbook(codes: string[], opts?: WsStreamOptions): WsStreamManager {
-    return new WsStreamManager(this.client, [{ type: 'orderbook', codes }], false, opts);
+  orderbook(codes: string[], opts?: WsStreamOptions): WsStreamManager<PublicEvent<'orderbook'>> {
+    return new WsStreamManager(this.client, [{ type: 'orderbook', codes }], WsEndpoint.Public, opts);
   }
 
   /** Subscribe to the candle stream. */
-  candle(codes: string[], opts?: { interval?: string } & WsStreamOptions): WsStreamManager {
+  candle(codes: string[], opts?: { interval?: string } & WsStreamOptions): WsStreamManager<CandleEvent> {
     const { interval = '1m', ...streamOpts } = opts ?? {};
-    return new WsStreamManager(this.client, [{ type: `candle.${interval}`, codes }], false, streamOpts);
+    return new WsStreamManager(
+      this.client,
+      [{ type: `candle.${interval}`, codes }],
+      WsEndpoint.Public,
+      streamOpts,
+    );
   }
 
   /** Subscribe to the myOrder (my orders) stream. Requires authentication. */
-  myOrder(codes: string[], opts?: WsStreamOptions): WsStreamManager {
-    return new WsStreamManager(this.client, [{ type: 'myOrder', codes }], true, opts);
+  myOrder(codes: string[], opts?: WsStreamOptions): WsStreamManager<PrivateEvent<'myOrder'>> {
+    return new WsStreamManager(this.client, [{ type: 'myOrder', codes }], WsEndpoint.Private, opts);
   }
 
   /** Subscribe to the myAsset (my assets) stream. Requires authentication. */
-  myAsset(opts?: WsStreamOptions): WsStreamManager {
-    return new WsStreamManager(this.client, [{ type: 'myAsset' }], true, opts);
+  myAsset(opts?: WsStreamOptions): WsStreamManager<PrivateEvent<'myAsset'>> {
+    return new WsStreamManager(this.client, [{ type: 'myAsset' }], WsEndpoint.Private, opts);
+  }
+
+  /** Subscribe to the announcement stream. Requires authentication. */
+  announcement(opts?: WsAnnouncementOptions): WsStreamManager<PrivateEvent<'announcement'>> {
+    const { categories, includeBody, ...streamOpts } = opts ?? {};
+    return new WsStreamManager(
+      this.client,
+      [buildAnnouncementSubscription(categories, includeBody)],
+      WsEndpoint.Private,
+      streamOpts,
+    );
+  }
+
+  /** Subscribe to calculated indicator values. Requires authentication. */
+  indicator(codes: string[], opts: WsIndicatorOptions): WsStreamManager<InfoEvent<'indicator'>> {
+    const { timeframe, indicators, format = 'DEFAULT', ...streamOpts } = opts;
+    const subscription: InfoSubscription = { type: 'indicator', codes, timeframe, indicators };
+    return new WsStreamManager(this.client, [subscription], WsEndpoint.Info, { ...streamOpts, format });
+  }
+
+  /** Subscribe to technical indicator condition transitions. Requires authentication. */
+  indicatorSignal(
+    codes: string[],
+    opts: WsIndicatorSignalOptions,
+  ): WsStreamManager<InfoEvent<'indicator_signal'>> {
+    const { timeframe, indicators, format = 'DEFAULT', ...streamOpts } = opts;
+    const subscription: InfoSubscription = { type: 'indicator_signal', codes, timeframe, indicators };
+    return new WsStreamManager(this.client, [subscription], WsEndpoint.Info, { ...streamOpts, format });
   }
 
   /** Subscribe to multiple public streams at once. */
@@ -246,37 +511,84 @@ export class WsStream {
       orderbook?: string[];
       candle?: { codes: string[]; interval?: string };
     } & WsStreamOptions,
-  ): WsStreamManager {
-    const { ticker, trade, orderbook, candle, maxRetries, retryDelayMs, onDisconnect, onReconnect } = opts;
+  ): WsStreamManager<ConnectPublicServerEvent> {
+    const { ticker, trade, orderbook, candle, format, maxRetries, retryDelayMs, onDisconnect, onReconnect } =
+      opts;
     const types: AnySubscriptionType[] = [];
     if (ticker) types.push({ type: 'ticker', codes: ticker });
     if (trade) types.push({ type: 'trade', codes: trade });
     if (orderbook) types.push({ type: 'orderbook', codes: orderbook });
     if (candle) types.push({ type: `candle.${candle.interval ?? '1m'}`, codes: candle.codes });
     const streamOpts: WsStreamOptions = {};
+    if (format !== undefined) streamOpts.format = format;
     if (maxRetries !== undefined) streamOpts.maxRetries = maxRetries;
     if (retryDelayMs !== undefined) streamOpts.retryDelayMs = retryDelayMs;
     if (onDisconnect) streamOpts.onDisconnect = onDisconnect;
     if (onReconnect) streamOpts.onReconnect = onReconnect;
-    return new WsStreamManager(this.client, types, false, streamOpts);
+    return new WsStreamManager(this.client, types, WsEndpoint.Public, streamOpts);
   }
 
   /** Subscribe to multiple private streams at once. Requires authentication. */
   subscribePrivate(
     opts: {
+      announcement?: boolean | Pick<WsAnnouncementOptions, 'categories' | 'includeBody'>;
       myOrder?: string[];
       myAsset?: boolean;
     } & WsStreamOptions,
-  ): WsStreamManager {
-    const { myOrder, myAsset, maxRetries, retryDelayMs, onDisconnect, onReconnect } = opts;
+  ): WsStreamManager<ConnectPrivateServerEvent> {
+    const { announcement, myOrder, myAsset, format, maxRetries, retryDelayMs, onDisconnect, onReconnect } =
+      opts;
     const types: AnySubscriptionType[] = [];
+    if (announcement) {
+      types.push(
+        buildAnnouncementSubscription(
+          announcement === true ? undefined : announcement.categories,
+          announcement === true ? undefined : announcement.includeBody,
+        ),
+      );
+    }
     if (myOrder) types.push({ type: 'myOrder', codes: myOrder });
     if (myAsset) types.push({ type: 'myAsset' });
-    const streamOpts: WsStreamOptions = {};
+    const streamOpts: WsStreamOptions & { format?: WsStreamFormat } = {};
+    if (format !== undefined) streamOpts.format = format;
+    if (maxRetries !== undefined) streamOpts.maxRetries = maxRetries;
+    if (retryDelayMs !== undefined) streamOpts.retryDelayMs = retryDelayMs;
+    if (onDisconnect) streamOpts.onDisconnect = onDisconnect;
+    if (onReconnect) streamOpts.onReconnect = onReconnect;
+    return new WsStreamManager(this.client, types, WsEndpoint.Private, streamOpts);
+  }
+
+  /** Subscribe to multiple info streams at once. Requires authentication. */
+  subscribeInfo(
+    opts: {
+      indicator?: WsIndicatorSubscription | WsIndicatorSubscription[];
+      indicatorSignal?: WsIndicatorSignalSubscription | WsIndicatorSignalSubscription[];
+    } & WsStreamOptions,
+  ): WsStreamManager<ConnectInfoServerEvent> {
+    const { indicator, indicatorSignal, format, maxRetries, retryDelayMs, onDisconnect, onReconnect } = opts;
+    const subscriptions: InfoSubscription[] = [
+      ...(indicator ?
+        Array.isArray(indicator) ?
+          indicator
+        : [indicator]
+      : []
+      ).map((item): InfoSubscription => ({ ...item, type: 'indicator' })),
+      ...(indicatorSignal ?
+        Array.isArray(indicatorSignal) ?
+          indicatorSignal
+        : [indicatorSignal]
+      : []
+      ).map((item): InfoSubscription => ({ ...item, type: 'indicator_signal' })),
+    ];
+    if (subscriptions.length === 0) {
+      throw new Error('At least one subscription type must be specified');
+    }
+    const streamOpts: WsStreamOptions & { format?: WsStreamFormat } = {};
+    if (format !== undefined) streamOpts.format = format;
     if (maxRetries !== undefined) streamOpts.maxRetries = maxRetries;
     if (retryDelayMs !== undefined) streamOpts.retryDelayMs = retryDelayMs;
     if (onDisconnect) streamOpts.onDisconnect = onDisconnect;
     if (onReconnect) streamOpts.onReconnect = onReconnect;
-    return new WsStreamManager(this.client, types, true, streamOpts);
+    return new WsStreamManager(this.client, subscriptions, WsEndpoint.Info, streamOpts);
   }
 }

package/src/resources/index.ts

@@ -120,5 +120,45 @@ export {
   type WithdrawRetrieveChanceParams,
   type WithdrawsUuidCursorIDPage,
 } from './withdraws';
-export { WsPrivate, type ConnectPrivateClientEvent, type ConnectPrivateServerEvent } from './ws-private';
-export { WsPublic, type ConnectPublicClientEvent, type ConnectPublicServerEvent } from './ws-public';
+export {
+  WsInfo,
+  type BollingerBandsIndicator,
+  type BollingerBandsIndicatorSignal,
+  type Indicator,
+  type IndicatorSignal,
+  type IndicatorTimeframe,
+  type IndicatorType,
+  type MaCrossoverIndicator,
+  type MaCrossoverIndicatorSignal,
+  type MacdIndicator,
+  type MacdIndicatorSignal,
+  type MovingAverageIndicator,
+  type MovingAverageIndicatorSignal,
+  type RsiIndicator,
+  type RsiIndicatorSignal,
+  type RsiOverboughtIndicatorSignal,
+  type RsiOverboughtIndicatorSignalRequest,
+  type RsiOversoldIndicatorSignal,
+  type RsiOversoldIndicatorSignalRequest,
+  type VolumeIndicator,
+  type VolumeIndicatorSignal,
+  type ConnectInfoClientEvent,
+  type ConnectInfoServerEvent,
+} from './ws-info';
+export {
+  WsPrivate,
+  type Announcement,
+  type AnnouncementCategory,
+  type AnnouncementEventType,
+  type ConnectPrivateClientEvent,
+  type ConnectPrivateServerEvent,
+  type ConnectPrivateServerMessage,
+} from './ws-private';
+export {
+  WsPublic,
+  type ConnectPublicClientEvent,
+  type ConnectPublicServerEvent,
+  type ListSubscriptionsResponse,
+  type ListSubscriptionsServerResponse,
+  type SimpleListSubscriptionsResponse,
+} from './ws-public';