@upbit-official/upbit-sdk 1.0.0 → 1.1.0

package/src/resources/ws-private/ws-private.ts

@@ -1,22 +1,372 @@
+import type { WebSocketMessage } from '../../internal/ws-parser';
+
+import type { WsListSubscriptionsResponse } from '../../lib/ws';
+
 import { APIResource } from '../../core/resource';
 
+import * as WsPrivateAPI from './ws-private';
+
 export class WsPrivate extends APIResource {}
 
+export interface Announcement {
+  /**
+   * Data type
+   */
+  type: 'announcement';
+
+  /**
+   * Announcement body in Markdown. Included only when include_body is true and may
+   * be null for large bodies.
+   */
+  body?: string | null;
+
+  /**
+   * Announcement category
+   */
+  category?: AnnouncementCategory;
+
+  /**
+   * Announcement event type
+   */
+  event_type?: AnnouncementEventType;
+
+  /**
+   * First publication time (KST, ISO 8601)
+   */
+  first_listed_at?: string;
+
+  /**
+   * Latest publication time (KST, ISO 8601)
+   */
+  listed_at?: string;
+
+  /**
+   * Stream type (announcement supports realtime only)
+   */
+  stream_type?: 'REALTIME';
+
+  /**
+   * Timestamp (ms)
+   */
+  timestamp?: number;
+
+  /**
+   * Announcement title
+   */
+  title?: string;
+
+  /**
+   * Announcement detail page URL
+   */
+  url?: string;
+
+  /**
+   * Announcement unique ID
+   */
+  uuid?: string;
+}
+
 /**
- * WebSocket private client event — subscription request sent to server (JWT
- * required)
+ * Announcement category
  */
-export type ConnectPrivateClientEvent =
-  | Array<
-      | ConnectPrivateClientEvent.WsTicketField
-      | ConnectPrivateClientEvent.WsMyOrderTypeField
-      | ConnectPrivateClientEvent.WsFormatField
-    >
-  | Array<
-      | ConnectPrivateClientEvent.WsTicketField
-      | ConnectPrivateClientEvent.WsMyAssetTypeField
-      | ConnectPrivateClientEvent.WsFormatField
-    >;
+export type AnnouncementCategory =
+  | 'notice'
+  | 'trade'
+  | 'wallet'
+  | 'maintenance'
+  | 'digital_asset'
+  | 'nft'
+  | 'service'
+  | 'event'
+  | 'note'
+  | 'trading'
+  | 'airdrop'
+  | 'feature'
+  | 'disclosure';
+
+export type AnnouncementEventType = 'CREATED' | 'UPDATED';
+
+export interface SimpleAnnouncement {
+  /**
+   * Data type
+   */
+  ty: 'announcement';
+
+  /**
+   * Announcement body in Markdown. Included only when include_body is true and may
+   * be null for large bodies.
+   */
+  bd?: string | null;
+
+  /**
+   * Announcement category
+   */
+  cat?:
+    | 'notice'
+    | 'trade'
+    | 'wallet'
+    | 'maintenance'
+    | 'digital_asset'
+    | 'nft'
+    | 'service'
+    | 'event'
+    | 'note'
+    | 'trading'
+    | 'airdrop'
+    | 'feature'
+    | 'disclosure';
+
+  /**
+   * Announcement event type
+   */
+  et?: 'CREATED' | 'UPDATED';
+
+  /**
+   * First publication time (KST, ISO 8601)
+   */
+  flat?: string;
+
+  /**
+   * Latest publication time (KST, ISO 8601)
+   */
+  lat?: string;
+
+  /**
+   * Stream type (announcement supports realtime only)
+   */
+  st?: 'REALTIME';
+
+  /**
+   * Timestamp (ms)
+   */
+  tms?: number;
+
+  /**
+   * Announcement title
+   */
+  tt?: string;
+
+  /**
+   * Announcement unique ID
+   */
+  uid?: string;
+
+  /**
+   * Announcement detail page URL
+   */
+  url?: string;
+}
+
+export interface SimpleMyAsset {
+  /**
+   * Data type
+   */
+  ty: 'myAsset';
+
+  /**
+   * List of asset entries
+   */
+  ast?: Array<SimpleMyAsset.Ast>;
+
+  /**
+   * Asset timestamp (ms)
+   */
+  asttms?: number;
+
+  /**
+   * Asset unique ID
+   */
+  astuid?: string;
+
+  /**
+   * Stream type (snapshot or realtime)
+   */
+  st?: 'SNAPSHOT' | 'REALTIME';
+
+  /**
+   * Timestamp (ms)
+   */
+  tms?: number;
+}
+
+export namespace SimpleMyAsset {
+  /**
+   * Asset entry
+   */
+  export interface Ast {
+    /**
+     * Available balance
+     */
+    b?: string;
+
+    /**
+     * Currency code (uppercase)
+     */
+    cu?: string;
+
+    /**
+     * Balance locked in open orders
+     */
+    l?: string;
+  }
+}
+
+export interface SimpleMyOrder {
+  /**
+   * Data type
+   */
+  ty: 'myOrder';
+
+  /**
+   * User-defined lookup value. Only provided for orders created after 2024-10-18.
+   */
+  id?: string | null;
+
+  /**
+   * Ask/bid side
+   */
+  ab?: 'ASK' | 'BID';
+
+  /**
+   * Average execution price
+   */
+  ap?: string;
+
+  /**
+   * Market code
+   */
+  cd?: string;
+
+  /**
+   * Executed trade value
+   */
+  ef?: string;
+
+  /**
+   * Executed quantity
+   */
+  ev?: string;
+
+  /**
+   * Whether the executed order is a maker order. Null when state is not trade.
+   */
+  im?: boolean | null;
+
+  /**
+   * Amount locked for this trade
+   */
+  l?: string;
+
+  /**
+   * Order type
+   */
+  ot?: 'limit' | 'price' | 'market' | 'best';
+
+  /**
+   * Order timestamp (ms)
+   */
+  otms?: number;
+
+  /**
+   * Order price. When state=trade, this is the execution price.
+   */
+  p?: string;
+
+  /**
+   * Fee already paid
+   */
+  pf?: string;
+
+  /**
+   * Amount (buy) or quantity (sell) cancelled by self-match prevention
+   */
+  pl?: string | null;
+
+  /**
+   * Order quantity cancelled by self-match prevention
+   */
+  pv?: string | null;
+
+  /**
+   * Remaining fee
+   */
+  rmf?: string;
+
+  /**
+   * Fee reserved for this order
+   */
+  rsf?: string;
+
+  /**
+   * Remaining order quantity after execution
+   */
+  rv?: string;
+
+  /**
+   * Order status
+   */
+  s?: 'wait' | 'watch' | 'trade' | 'done' | 'cancel' | 'prevented';
+
+  /**
+   * Self-match prevention type
+   */
+  smpt?: 'reduce' | 'cancel_maker' | 'cancel_taker' | null;
+
+  /**
+   * Stream type (snapshot or realtime)
+   */
+  st?: 'SNAPSHOT' | 'REALTIME';
+
+  /**
+   * Number of executions for this order
+   */
+  tc?: number;
+
+  /**
+   * Fee incurred on execution. Null when state is not trade.
+   */
+  tf?: string | null;
+
+  /**
+   * IOC/FOK/POST ONLY order condition
+   */
+  tif?: 'ioc' | 'fok' | 'post_only' | null;
+
+  /**
+   * Timestamp (ms)
+   */
+  tms?: number;
+
+  /**
+   * Trade timestamp (ms)
+   */
+  ttms?: number | null;
+
+  /**
+   * Trade unique ID
+   */
+  tuid?: string | null;
+
+  /**
+   * Order unique ID
+   */
+  uid?: string;
+
+  /**
+   * Order quantity. When state=trade, this is the executed quantity.
+   */
+  v?: string;
+}
+
+export type SimplePrivateServerEvent = SimpleAnnouncement | SimpleMyOrder | SimpleMyAsset;
+
+export type ConnectPrivateClientEvent = Array<
+  | ConnectPrivateClientEvent.WsTicketField
+  | ConnectPrivateClientEvent.WsAnnouncementTypeField
+  | ConnectPrivateClientEvent.WsMyOrderTypeField
+  | ConnectPrivateClientEvent.WsMyAssetTypeField
+  | ConnectPrivateClientEvent.WsFormatField
+>;
 
 export namespace ConnectPrivateClientEvent {
   /**
@@ -29,6 +379,44 @@ export namespace ConnectPrivateClientEvent {
     ticket: string;
   }
 
+  /**
+   * Announcement subscription type field
+   */
+  export interface WsAnnouncementTypeField {
+    type: 'announcement';
+
+    /**
+     * Announcement categories to receive. Omit this field to receive announcements
+     * from all categories.
+     */
+    categories?: Array<WsPrivateAPI.AnnouncementCategory>;
+
+    /**
+     * Whether to include the announcement body in stream messages
+     */
+    include_body?: boolean;
+  }
+
+  /**
+   * Response format specifier field
+   */
+  export interface WsFormatField {
+    /**
+     * Response format selector
+     */
+    format?: 'DEFAULT' | 'SIMPLE' | 'JSON_LIST' | 'SIMPLE_LIST';
+  }
+
+  /**
+   * Ticket field that identifies the requester
+   */
+  export interface WsTicketField {
+    /**
+     * A value that uniquely identifies the requester (UUID recommended)
+     */
+    ticket: string;
+  }
+
   /**
    * MyOrder subscription type field
    */
@@ -59,11 +447,10 @@ export namespace ConnectPrivateClientEvent {
   }
 }
 
-/**
- * WebSocket private server event — stream message received from server (JWT
- * required)
- */
-export type ConnectPrivateServerEvent = ConnectPrivateServerEvent.MyOrder | ConnectPrivateServerEvent.MyAsset;
+export type ConnectPrivateServerEvent =
+  | Announcement
+  | ConnectPrivateServerEvent.MyOrder
+  | ConnectPrivateServerEvent.MyAsset;
 
 export namespace ConnectPrivateServerEvent {
   /**
@@ -276,7 +663,22 @@ export namespace ConnectPrivateServerEvent {
 
 export declare namespace WsPrivate {
   export {
+    type Announcement as Announcement,
+    type AnnouncementCategory as AnnouncementCategory,
+    type AnnouncementEventType as AnnouncementEventType,
+    type SimpleAnnouncement as SimpleAnnouncement,
+    type SimpleMyAsset as SimpleMyAsset,
+    type SimpleMyOrder as SimpleMyOrder,
+    type SimplePrivateServerEvent as SimplePrivateServerEvent,
     type ConnectPrivateClientEvent as ConnectPrivateClientEvent,
+    type ConnectPrivateServerMessage as ConnectPrivateServerMessage,
     type ConnectPrivateServerEvent as ConnectPrivateServerEvent,
   };
 }
+
+export type ConnectPrivateServerMessage =
+  | WebSocketMessage<ConnectPrivateServerEvent | SimplePrivateServerEvent>
+  | WsListSubscriptionsResponse
+  | Array<
+      WebSocketMessage<ConnectPrivateServerEvent | SimplePrivateServerEvent> | WsListSubscriptionsResponse
+    >;

package/src/resources/ws-private/ws.ts

@@ -3,10 +3,10 @@ import { WsPrivateEmitter, WsPrivateStreamMessage, WebSocketError, buildURL } fr
 import { InternalEventEmitter } from '../../core/EventEmitter';
 import { sleep } from '../../internal/utils/sleep';
 import { isRecoverableClose, type ReconnectingEvent, type ReconnectingOverrides } from '../../internal/ws';
-import * as WsPrivateAPI from './ws-private';
-import { Upbit } from '../../client';
-import { jsonParseFloat } from '../../lib/jsonParseFloat';
+import type * as WsPrivateAPI from './ws-private';
+import type { Upbit } from '../../client';
 import { createJwtToken } from '../../lib/jwtAuth';
+import { isRecord, parseWebSocketValue } from '../../internal/ws-parser';
 
 export interface WsPrivateWSReconnectOptions {
   /**
@@ -69,7 +69,7 @@ export class WsPrivateWS extends WsPrivateEmitter {
   ) {
     super();
     this._client = client;
-    this._parameters = undefined;
+    this._parameters = parameters;
     const { reconnect, ...wsOptions } = options ?? {};
     this._wsOptions = wsOptions;
     this._reconnectOptions = reconnect ?? null;
@@ -147,7 +147,7 @@ export class WsPrivateWS extends WsPrivateEmitter {
       push({ type: 'message', message: event });
     };
 
-    // All errors (API + socket) funnel through _onError → 'error' event
+    // Connection and transport errors funnel through _onError → 'error' event
     const onEmitterError = (err: WebSocketError) => {
       push({ type: 'error', error: err });
     };
@@ -272,27 +272,20 @@ export class WsPrivateWS extends WsPrivateEmitter {
 
     const socket = new WS.WebSocket(this.url, {
       ...this._wsOptions,
-      headers: {
-        ...this._authHeaders(),
-        ...this._wsOptions?.headers,
-      },
+      headers: this._client._buildWebSocketHandshakeHeaders(this._authHeaders(), this._wsOptions?.headers),
     });
 
     socket.on('message', (wsEvent) => {
-      const event = (() => {
-        try {
-          return jsonParseFloat(wsEvent.toString()) as WsPrivateAPI.ConnectPrivateServerEvent;
-        } catch (err) {
-          this._onError(null, 'could not parse websocket event', err);
-          return null;
-        }
-      })();
-
-      if (event) {
-        this._emit('event', event);
-
-        // @ts-ignore TS isn't smart enough to get the relationship right here
-        this._emit(event.type, event);
+      let event: unknown;
+      try {
+        event = parseWebSocketValue(wsEvent.toString());
+      } catch (error) {
+        this._onError(null, 'could not parse WebSocket message', new SyntaxError('Invalid WebSocket JSON'));
+        return;
+      }
+      this._emit('event', event as WsPrivateAPI.ConnectPrivateServerEvent);
+      if (isRecord(event) && typeof event['type'] === 'string') {
+        this._emit(event['type'] as any, event as any);
       }
     });
 

package/src/resources/ws-public/index.ts

@@ -1,2 +1,17 @@
-export { WsPublic, type ConnectPublicClientEvent, type ConnectPublicServerEvent } from './ws-public';
+export {
+  WsPublic,
+  type ConnectPublicClientEvent,
+  type ConnectPublicServerEvent,
+  type ListSubscriptionsResponse,
+  type ListSubscriptionsServerResponse,
+  type SimpleListSubscriptionsResponse,
+} from './ws-public';
 export { type WsPublicWSClientOptions, type WsPublicWSReconnectOptions } from './ws';
+
+export type { SimplePublicServerEvent } from '../../internal/ws-simple-types';
+export type {
+  SimpleTicker,
+  SimpleTrade,
+  SimpleOrderbook,
+  SimpleCandle,
+} from '../../internal/ws-simple-types';

package/src/resources/ws-public/internal-base.ts

@@ -5,7 +5,6 @@ import { UpbitError } from '../../core/error';
 import { stringifyQuery } from '../../internal/utils';
 
 import type { ReconnectingEvent } from '../../internal/ws';
-
 export type WsPublicStreamMessage =
   | { type: 'connecting' | 'open' | 'closing' | 'close' }
   | { type: 'reconnecting'; reconnect: ReconnectingEvent }