@upbit-official/upbit-sdk 0.9.0

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

@@ -0,0 +1,3 @@
+
+export { WsPrivate, type ConnectPrivateClientEvent, type ConnectPrivateServerEvent } from './ws-private';
+export { type WsPrivateWSClientOptions, type WsPrivateWSReconnectOptions } from './ws';

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

@@ -0,0 +1,99 @@
+
+import * as WsPrivateAPI from './ws-private';
+import { Upbit } from '../../client';
+import { EventEmitter } from '../../core/EventEmitter';
+import { UpbitError } from '../../core/error';
+import { stringifyQuery } from '../../internal/utils';
+
+import type { ReconnectingEvent } from '../../internal/ws';
+
+export type WsPrivateStreamMessage =
+  | { type: 'connecting' | 'open' | 'closing' | 'close' }
+  | { type: 'reconnecting'; reconnect: ReconnectingEvent }
+  | { type: 'reconnected' }
+  | { type: 'message'; message: WsPrivateAPI.ConnectPrivateServerEvent }
+  | { type: 'error'; error: WebSocketError };
+
+export class WebSocketError extends UpbitError {
+  /**
+   * The error data that the API sent back in an error event.
+   */
+  error?: unknown | undefined;
+
+  constructor(message: string, event: unknown | null) {
+    super(message);
+
+    this.error = event ?? undefined;
+  }
+}
+
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+type WebSocketEvents = Simplify<
+  {
+    close: () => void;
+    event: (event: WsPrivateAPI.ConnectPrivateServerEvent) => void;
+    error: (error: WebSocketError) => void;
+    reconnecting: (event: ReconnectingEvent) => void;
+    reconnected: () => void;
+  } & {
+    [EventType in WsPrivateAPI.ConnectPrivateServerEvent['type']]: (
+      event: Extract<WsPrivateAPI.ConnectPrivateServerEvent, { type?: EventType }>,
+    ) => unknown;
+  }
+>;
+
+export abstract class WsPrivateEmitter extends EventEmitter<WebSocketEvents> {
+  /**
+   * Send an event to the API.
+   */
+  abstract send(event: WsPrivateAPI.ConnectPrivateClientEvent): void;
+
+  /**
+   * Close the WebSocket connection.
+   */
+  abstract close(props?: { code: number; reason: string }): void;
+
+  protected _onError(event: null, message: string, cause: any): void;
+  protected _onError(event: unknown, message?: string | undefined): void;
+  protected _onError(event: unknown | null, message?: string | undefined, cause?: any): void {
+    message = message ?? safeJSONStringify(event) ?? 'unknown error';
+
+    if (!this._hasListener('error')) {
+      const error = new WebSocketError(
+        message +
+          `\n\nTo resolve these unhandled rejection errors you should bind an \`error\` callback, e.g. \`ws.on('error', (error) => ...)\` `,
+        event,
+      );
+      // @ts-ignore
+      error.cause = cause;
+      Promise.reject(error);
+      return;
+    }
+
+    const error = new WebSocketError(message, event);
+    // @ts-ignore
+    error.cause = cause;
+
+    this._emit('error', error);
+  }
+}
+
+export function buildURL(client: Upbit, query?: object | null): URL {
+  const path = '/websocket/v1/private';
+  const baseURL = client.baseURL;
+  const url = new URL(baseURL + (baseURL.endsWith('/') ? path.slice(1) : path));
+  if (query) {
+    url.search = stringifyQuery(query);
+  }
+  url.protocol = url.protocol === 'http:' ? 'ws:' : 'wss:';
+  return url;
+}
+
+function safeJSONStringify(value: unknown): string | null {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,283 @@
+
+import { APIResource } from '../../core/resource';
+
+export class WsPrivate extends APIResource {}
+
+/**
+ * WebSocket private client event — subscription request sent to server (JWT
+ * required)
+ */
+export type ConnectPrivateClientEvent =
+  | Array<
+      | ConnectPrivateClientEvent.WsTicketField
+      | ConnectPrivateClientEvent.WsMyOrderTypeField
+      | ConnectPrivateClientEvent.WsFormatField
+    >
+  | Array<
+      | ConnectPrivateClientEvent.WsTicketField
+      | ConnectPrivateClientEvent.WsMyAssetTypeField
+      | ConnectPrivateClientEvent.WsFormatField
+    >;
+
+export namespace ConnectPrivateClientEvent {
+  /**
+   * Ticket field that identifies the requester
+   */
+  export interface WsTicketField {
+    /**
+     * A value that uniquely identifies the requester (UUID recommended)
+     */
+    ticket: string;
+  }
+
+  /**
+   * MyOrder subscription type field
+   */
+  export interface WsMyOrderTypeField {
+    type: 'myOrder';
+
+    /**
+     * List of market codes. Omit or pass empty array for all markets.
+     */
+    codes?: Array<string>;
+  }
+
+  /**
+   * Response format specifier field
+   */
+  export interface WsFormatField {
+    /**
+     * Response format selector
+     */
+    format?: 'DEFAULT' | 'SIMPLE' | 'JSON_LIST' | 'SIMPLE_LIST';
+  }
+
+  /**
+   * MyAsset subscription type field (codes field is not allowed)
+   */
+  export interface WsMyAssetTypeField {
+    type: 'myAsset';
+  }
+}
+
+/**
+ * WebSocket private server event — stream message received from server (JWT
+ * required)
+ */
+export type ConnectPrivateServerEvent = ConnectPrivateServerEvent.MyOrder | ConnectPrivateServerEvent.MyAsset;
+
+export namespace ConnectPrivateServerEvent {
+  /**
+   * My order (MyOrder) stream message payload
+   */
+  export interface MyOrder {
+    /**
+     * Data type
+     */
+    type: 'myOrder';
+
+    /**
+     * Ask/bid side
+     */
+    ask_bid?: 'ASK' | 'BID';
+
+    /**
+     * Average execution price
+     */
+    avg_price?: string;
+
+    /**
+     * Market code
+     */
+    code?: string;
+
+    /**
+     * Executed trade value
+     */
+    executed_funds?: string;
+
+    /**
+     * Executed quantity
+     */
+    executed_volume?: string;
+
+    /**
+     * User-defined lookup value. Only provided for orders created after 2024-10-18.
+     */
+    identifier?: string | null;
+
+    /**
+     * Whether the executed order is a maker order. Null when state is not trade.
+     */
+    is_maker?: boolean | null;
+
+    /**
+     * Amount locked for this trade
+     */
+    locked?: string;
+
+    /**
+     * Order timestamp (ms)
+     */
+    order_timestamp?: number;
+
+    /**
+     * Order type
+     */
+    order_type?: 'limit' | 'price' | 'market' | 'best';
+
+    /**
+     * Fee already paid
+     */
+    paid_fee?: string;
+
+    /**
+     * Amount (buy) or quantity (sell) cancelled by self-match prevention
+     */
+    prevented_locked?: string | null;
+
+    /**
+     * Order quantity cancelled by self-match prevention
+     */
+    prevented_volume?: string | null;
+
+    /**
+     * Order price. When state=trade, this is the execution price.
+     */
+    price?: string;
+
+    /**
+     * Remaining fee
+     */
+    remaining_fee?: string;
+
+    /**
+     * Remaining order quantity after execution
+     */
+    remaining_volume?: string;
+
+    /**
+     * Fee reserved for this order
+     */
+    reserved_fee?: string;
+
+    /**
+     * Self-match prevention type
+     */
+    smp_type?: 'reduce' | 'cancel_maker' | 'cancel_taker' | null;
+
+    /**
+     * Order status
+     */
+    state?: 'wait' | 'watch' | 'trade' | 'done' | 'cancel' | 'prevented';
+
+    /**
+     * Stream type (snapshot or realtime)
+     */
+    stream_type?: 'SNAPSHOT' | 'REALTIME';
+
+    /**
+     * IOC/FOK/POST ONLY order condition
+     */
+    time_in_force?: 'ioc' | 'fok' | 'post_only' | null;
+
+    /**
+     * Timestamp (ms)
+     */
+    timestamp?: number;
+
+    /**
+     * Fee incurred on execution. Null when state is not trade.
+     */
+    trade_fee?: string | null;
+
+    /**
+     * Trade timestamp (ms)
+     */
+    trade_timestamp?: number | null;
+
+    /**
+     * Trade unique ID
+     */
+    trade_uuid?: string | null;
+
+    /**
+     * Number of executions for this order
+     */
+    trades_count?: number;
+
+    /**
+     * Order unique ID
+     */
+    uuid?: string;
+
+    /**
+     * Order quantity. When state=trade, this is the executed quantity.
+     */
+    volume?: string;
+  }
+
+  /**
+   * My asset (MyAsset) stream message payload
+   */
+  export interface MyAsset {
+    /**
+     * Data type
+     */
+    type: 'myAsset';
+
+    /**
+     * Asset timestamp (ms)
+     */
+    asset_timestamp?: number;
+
+    /**
+     * Asset unique ID
+     */
+    asset_uuid?: string;
+
+    /**
+     * List of asset entries
+     */
+    assets?: Array<MyAsset.Asset>;
+
+    /**
+     * Stream type (snapshot or realtime)
+     */
+    stream_type?: 'SNAPSHOT' | 'REALTIME';
+
+    /**
+     * Timestamp (ms)
+     */
+    timestamp?: number;
+  }
+
+  export namespace MyAsset {
+    /**
+     * Asset entry
+     */
+    export interface Asset {
+      /**
+       * Available balance
+       */
+      balance?: string;
+
+      /**
+       * Currency code (uppercase)
+       */
+      currency?: string;
+
+      /**
+       * Balance locked in open orders
+       */
+      locked?: string;
+    }
+  }
+}
+
+export declare namespace WsPrivate {
+  export {
+    type ConnectPrivateClientEvent as ConnectPrivateClientEvent,
+    type ConnectPrivateServerEvent as ConnectPrivateServerEvent,
+  };
+}