@imbingox/acex 0.1.0-beta.2 → 0.1.0-beta.3

package/src/adapters/types.ts

@@ -1,4 +1,12 @@
-import type { Exchange, MarketDefinition } from "../types/index.ts";
+import type {
+  AccountCredentials,
+  CreateOrderType,
+  Exchange,
+  MarketDefinition,
+  OrderSide,
+  OrderStatus,
+  PositionSide,
+} from "../types/index.ts";
 
 export interface StreamHandle {
   readonly ready: Promise<void>;
@@ -41,3 +49,139 @@ export interface MarketAdapter {
     options: L1BookStreamOptions,
   ): StreamHandle;
 }
+
+export interface RawBalanceUpdate {
+  asset: string;
+  free?: string;
+  used?: string;
+  total?: string;
+  exchangeTs?: number;
+  receivedAt: number;
+}
+
+export interface RawPositionUpdate {
+  symbol: string;
+  side: PositionSide;
+  size: string;
+  entryPrice?: string;
+  markPrice?: string;
+  unrealizedPnl?: string;
+  leverage?: string;
+  liquidationPrice?: string;
+  exchangeTs?: number;
+  receivedAt: number;
+}
+
+export interface RawRiskUpdate {
+  equity?: string;
+  marginRatio?: string;
+  initialMargin?: string;
+  maintenanceMargin?: string;
+  exchangeTs?: number;
+  receivedAt: number;
+}
+
+export interface RawAccountBootstrap {
+  balances: RawBalanceUpdate[];
+  positions: RawPositionUpdate[];
+  risk?: RawRiskUpdate;
+  exchangeTs?: number;
+  receivedAt: number;
+}
+
+export interface RawAccountUpdate {
+  balances?: RawBalanceUpdate[];
+  positions?: RawPositionUpdate[];
+  risk?: RawRiskUpdate;
+  exchangeTs?: number;
+  receivedAt: number;
+}
+
+export interface RawOrderUpdate {
+  orderId?: string;
+  clientOrderId?: string;
+  symbol: string;
+  side: OrderSide;
+  type: string;
+  status: OrderStatus;
+  price?: string;
+  triggerPrice?: string;
+  amount: string;
+  filled: string;
+  remaining?: string;
+  reduceOnly?: boolean;
+  positionSide?: PositionSide;
+  avgFillPrice?: string;
+  exchangeTs?: number;
+  receivedAt: number;
+}
+
+export interface CreateOrderRequest {
+  symbol: string;
+  side: OrderSide;
+  type: CreateOrderType;
+  amount: string;
+  price?: string;
+  clientOrderId?: string;
+  reduceOnly?: boolean;
+  positionSide?: PositionSide;
+}
+
+export interface CancelOrderRequest {
+  symbol: string;
+  orderId?: string;
+  clientOrderId?: string;
+}
+
+export interface CancelAllOrdersRequest {
+  symbol: string;
+}
+
+export interface PrivateStreamCallbacks {
+  onAccountUpdate(update: RawAccountUpdate): void;
+  onOrderUpdate(update: RawOrderUpdate): void;
+  onDisconnected(): void;
+  onReconnected(): void;
+  onError(error: Error): void;
+}
+
+export interface PrivateStreamOptions {
+  openTimeoutMs: number;
+  reconnectDelayMs: number;
+  reconnectMaxDelayMs: number;
+  listenKeyKeepAliveMs: number;
+  now?: () => number;
+}
+
+export interface PrivateUserDataAdapter {
+  readonly exchange: Exchange;
+  bootstrapAccount(
+    credentials: AccountCredentials,
+    accountOptions?: Record<string, unknown>,
+  ): Promise<RawAccountBootstrap>;
+  bootstrapOpenOrders(
+    credentials: AccountCredentials,
+    accountOptions?: Record<string, unknown>,
+  ): Promise<RawOrderUpdate[]>;
+  createOrder(
+    credentials: AccountCredentials,
+    request: CreateOrderRequest,
+    accountOptions?: Record<string, unknown>,
+  ): Promise<RawOrderUpdate>;
+  cancelOrder(
+    credentials: AccountCredentials,
+    request: CancelOrderRequest,
+    accountOptions?: Record<string, unknown>,
+  ): Promise<RawOrderUpdate>;
+  cancelAllOrders(
+    credentials: AccountCredentials,
+    request: CancelAllOrdersRequest,
+    accountOptions?: Record<string, unknown>,
+  ): Promise<RawOrderUpdate[]>;
+  createPrivateStream(
+    credentials: AccountCredentials,
+    callbacks: PrivateStreamCallbacks,
+    options: PrivateStreamOptions,
+    accountOptions?: Record<string, unknown>,
+  ): StreamHandle;
+}

package/src/client/context.ts

@@ -1,8 +1,18 @@
+import type {
+  RawAccountBootstrap,
+  RawAccountUpdate,
+  RawOrderUpdate,
+} from "../adapters/types.ts";
 import type {
   AccountCredentials,
   AcexInternalError,
+  CancelAllOrdersInput,
+  CancelOrderInput,
+  CreateOrderInput,
   Exchange,
   HealthEvent,
+  PrivateRuntimeReason,
+  PrivateRuntimeStatus,
 } from "../types/index.ts";
 
 export interface RegisteredAccountRecord {
@@ -17,6 +27,13 @@ export interface ClientContext {
   assertStarted(): void;
   getRegisteredAccount(accountId: string): RegisteredAccountRecord;
   ensurePrivateCredentials(accountId: string): void;
+  subscribePrivateAccountFeed(accountId: string): Promise<void>;
+  unsubscribePrivateAccountFeed(accountId: string): void;
+  subscribePrivateOrderFeed(accountId: string): Promise<void>;
+  unsubscribePrivateOrderFeed(accountId: string): void;
+  createOrder(input: CreateOrderInput): Promise<RawOrderUpdate>;
+  cancelOrder(input: CancelOrderInput): Promise<RawOrderUpdate>;
+  cancelAllOrders(input: CancelAllOrdersInput): Promise<RawOrderUpdate[]>;
   publishRuntimeError(
     source: AcexInternalError["source"],
     error: Error,
@@ -39,6 +56,52 @@ export interface HealthReporter<T> {
   getStatuses(): T[];
 }
 
+export interface PrivateSubscriptionState {
+  runtimeStatus: PrivateRuntimeStatus;
+  ready: boolean;
+  reason?: PrivateRuntimeReason;
+  lastReceivedAt?: number;
+  lastReadyAt?: number;
+}
+
+export interface PrivateAccountDataConsumer {
+  onPrivateAccountPending(accountId: string, exchange: Exchange): void;
+  onPrivateAccountBootstrap(
+    accountId: string,
+    exchange: Exchange,
+    bootstrap: RawAccountBootstrap,
+  ): void;
+  onPrivateAccountUpdate(
+    accountId: string,
+    exchange: Exchange,
+    update: RawAccountUpdate,
+  ): void;
+  onPrivateAccountStreamState(
+    accountId: string,
+    exchange: Exchange,
+    state: PrivateSubscriptionState,
+  ): void;
+}
+
+export interface PrivateOrderDataConsumer {
+  onPrivateOrderPending(accountId: string, exchange: Exchange): void;
+  onPrivateOrderBootstrap(
+    accountId: string,
+    exchange: Exchange,
+    snapshots: RawOrderUpdate[],
+  ): void;
+  onPrivateOrderUpdate(
+    accountId: string,
+    exchange: Exchange,
+    update: RawOrderUpdate,
+  ): void;
+  onPrivateOrderStreamState(
+    accountId: string,
+    exchange: Exchange,
+    state: PrivateSubscriptionState,
+  ): void;
+}
+
 export function hasPrivateCredentials(
   credentials?: AccountCredentials,
 ): boolean {