@imbingox/acex 0.3.0-beta.6 → 0.3.1-beta.0

package/src/managers/market-manager.ts

@@ -110,25 +110,27 @@ export class MarketManagerImpl
   readonly events: MarketEventStreams;
 
   private readonly context: ClientContext;
-  private readonly adapter: MarketAdapter;
+  private readonly adapters: Map<Venue, MarketAdapter>;
   private readonly marketBus = new AsyncEventBus<MarketEvent>();
   private readonly marketStatusBus =
     new AsyncEventBus<MarketStatusChangedEvent>();
   private readonly definitions = new Map<string, MarketDefinition>();
   private readonly records = new Map<string, MarketRecord>();
-  private catalogPromise: Promise<void> | undefined;
+  private readonly loadedCatalogVenues = new Set<Venue>();
+  private readonly catalogPromises = new Map<Venue, Promise<void>>();
   private readonly initialL1TimeoutMs: number;
   private readonly l1StaleAfterMs: number;
   private readonly l1ReconnectDelayMs: number;
   private readonly l1ReconnectMaxDelayMs: number;
+  private readonly streamNow = (): number => this.context.now();
 
   constructor(
     context: ClientContext,
-    adapter: MarketAdapter,
+    adapters: Map<Venue, MarketAdapter>,
     options: MarketManagerOptions = {},
   ) {
     this.context = context;
-    this.adapter = adapter;
+    this.adapters = new Map(adapters);
     this.initialL1TimeoutMs =
       options.initialL1TimeoutMs ?? DEFAULT_INITIAL_L1_TIMEOUT_MS;
     this.l1StaleAfterMs = options.l1StaleAfterMs ?? DEFAULT_L1_STALE_AFTER_MS;
@@ -162,7 +164,9 @@ export class MarketManagerImpl
   // --- MarketManager public API ---
 
   async loadMarkets(): Promise<void> {
-    await this.loadMarketCatalog();
+    await Promise.all(
+      [...this.adapters.keys()].map((venue) => this.loadMarketCatalog(venue)),
+    );
   }
 
   async subscribeL1Book(input: SubscribeL1BookInput): Promise<void> {
@@ -414,43 +418,55 @@ export class MarketManagerImpl
 
   // --- Internal helpers ---
 
-  private async loadMarketCatalog(): Promise<void> {
-    if (this.definitions.size > 0) {
+  private async loadMarketCatalog(venue: Venue): Promise<void> {
+    this.assertSupportedVenue(venue);
+
+    if (this.loadedCatalogVenues.has(venue)) {
       return;
     }
 
-    if (!this.catalogPromise) {
-      this.catalogPromise = this.fetchAndStoreMarketCatalog();
+    let catalogPromise = this.catalogPromises.get(venue);
+    if (!catalogPromise) {
+      catalogPromise = this.fetchAndStoreMarketCatalog(venue);
+      this.catalogPromises.set(venue, catalogPromise);
     }
 
     try {
-      await this.catalogPromise;
-    } finally {
-      if (this.definitions.size === 0) {
-        this.catalogPromise = undefined;
-      }
+      await catalogPromise;
+    } catch (error) {
+      this.catalogPromises.delete(venue);
+      throw error;
     }
   }
 
-  private async fetchAndStoreMarketCatalog(): Promise<void> {
+  private async fetchAndStoreMarketCatalog(venue: Venue): Promise<void> {
+    const adapter = this.getMarketAdapter(venue);
+
     try {
-      const markets = await this.adapter.loadMarkets();
-      this.definitions.clear();
+      const markets = await adapter.loadMarkets();
+
+      for (const [key, market] of this.definitions) {
+        if (market.venue === venue) {
+          this.definitions.delete(key);
+        }
+      }
 
       for (const market of markets) {
         this.definitions.set(marketKey(market), market);
       }
+
+      this.loadedCatalogVenues.add(venue);
     } catch (error) {
       const wrapped = new AcexError(
         "MARKET_CATALOG_LOAD_FAILED",
-        "Failed to load market catalog from Binance",
+        `Failed to load market catalog from ${venue}`,
       );
       this.context.publishRuntimeError(
         "adapter",
         error instanceof Error
           ? error
           : new Error("Unknown catalog load failure"),
-        { venue: this.adapter.venue },
+        { venue },
       );
       throw wrapped;
     }
@@ -461,7 +477,7 @@ export class MarketManagerImpl
     symbol: string;
   }): Promise<MarketDefinition> {
     this.assertSupportedVenue(input.venue);
-    await this.loadMarketCatalog();
+    await this.loadMarketCatalog(input.venue);
 
     const market = this.definitions.get(marketKey(input));
     if (!market) {
@@ -500,7 +516,7 @@ export class MarketManagerImpl
   }
 
   private assertSupportedVenue(venue: Venue): void {
-    if (venue === this.adapter.venue) {
+    if (this.adapters.has(venue)) {
       return;
     }
 
@@ -512,6 +528,20 @@ export class MarketManagerImpl
     );
   }
 
+  private getMarketAdapter(venue: Venue): MarketAdapter {
+    const adapter = this.adapters.get(venue);
+    if (!adapter) {
+      throw this.createError(
+        "VENUE_NOT_SUPPORTED",
+        `Venue is not supported yet: ${venue}`,
+        { venue },
+        "client",
+      );
+    }
+
+    return adapter;
+  }
+
   private assertFundingRateSupported(market: MarketDefinition): void {
     if (market.contract && market.type === "swap") {
       return;
@@ -664,10 +694,14 @@ export class MarketManagerImpl
       staleAfterMs: this.l1StaleAfterMs,
       reconnectDelayMs: this.l1ReconnectDelayMs,
       reconnectMaxDelayMs: this.l1ReconnectMaxDelayMs,
-      now: () => this.context.now(),
+      now: this.streamNow,
     };
 
-    return this.adapter.createL1BookStream(market, callbacks, options);
+    return this.getMarketAdapter(market.venue).createL1BookStream(
+      market,
+      callbacks,
+      options,
+    );
   }
 
   private createFundingRateStream(
@@ -721,10 +755,14 @@ export class MarketManagerImpl
       staleAfterMs: this.l1StaleAfterMs,
       reconnectDelayMs: this.l1ReconnectDelayMs,
       reconnectMaxDelayMs: this.l1ReconnectMaxDelayMs,
-      now: () => this.context.now(),
+      now: this.streamNow,
     };
 
-    return this.adapter.createFundingRateStream(market, callbacks, options);
+    return this.getMarketAdapter(market.venue).createFundingRateStream(
+      market,
+      callbacks,
+      options,
+    );
   }
 
   private createL1Book(

package/src/adapters/binance/book-ticker.ts

@@ -1,123 +0,0 @@
-import { createManagedWebSocket } from "../../internal/managed-websocket.ts";
-import type { BinanceMarketDefinition } from "./market-catalog.ts";
-
-export interface BinanceL1BookUpdate {
-  bidPrice: string;
-  bidSize: string;
-  askPrice: string;
-  askSize: string;
-  exchangeTs?: number;
-  receivedAt: number;
-}
-
-export interface BinanceBookTickerSubscription {
-  readonly ready: Promise<void>;
-  close(): void;
-}
-
-export interface BinanceBookTickerCallbacks {
-  onBookTicker(update: BinanceL1BookUpdate): void;
-  onFreshnessChange(
-    freshness: "fresh" | "stale",
-    reason?: "heartbeat_timeout",
-  ): void;
-  onDisconnected(): void;
-  onError?(error: Error): void;
-}
-
-export interface BinanceBookTickerOptions {
-  initialMessageTimeoutMs: number;
-  staleAfterMs: number;
-  reconnectDelayMs: number;
-  reconnectMaxDelayMs: number;
-  now?: () => number;
-}
-
-interface BinanceBookTickerMessage {
-  b?: string;
-  B?: string;
-  a?: string;
-  A?: string;
-  T?: number;
-}
-
-const BINANCE_SPOT_WS_BASE_URL = "wss://stream.binance.com:9443/ws";
-const BINANCE_USDM_WS_BASE_URL = "wss://fstream.binance.com/ws";
-const BINANCE_COINM_WS_BASE_URL = "wss://dstream.binance.com/ws";
-
-function getWsBaseUrl(market: BinanceMarketDefinition): string {
-  switch (market.family) {
-    case "spot":
-      return BINANCE_SPOT_WS_BASE_URL;
-    case "usdm":
-      return BINANCE_USDM_WS_BASE_URL;
-    case "coinm":
-      return BINANCE_COINM_WS_BASE_URL;
-  }
-}
-
-function buildBookTickerUrl(market: BinanceMarketDefinition): string {
-  return `${getWsBaseUrl(market)}/${market.id.toLowerCase()}@bookTicker`;
-}
-
-function parseBookTickerMessage(
-  data: string,
-): BinanceBookTickerMessage | undefined {
-  const parsed = JSON.parse(data) as BinanceBookTickerMessage;
-  if (!parsed.b || !parsed.B || !parsed.a || !parsed.A) {
-    return undefined;
-  }
-
-  return parsed;
-}
-
-export function subscribeBinanceBookTicker(
-  market: BinanceMarketDefinition,
-  callbacks: BinanceBookTickerCallbacks,
-  options: BinanceBookTickerOptions,
-): BinanceBookTickerSubscription {
-  const session = createManagedWebSocket<BinanceBookTickerMessage>({
-    url: buildBookTickerUrl(market),
-    initialMessageTimeoutMs: options.initialMessageTimeoutMs,
-    now: options.now,
-    messageWatchdog: {
-      staleAfterMs: options.staleAfterMs,
-      onStale() {
-        callbacks.onFreshnessChange("stale", "heartbeat_timeout");
-      },
-    },
-    reconnect: {
-      initialDelayMs: options.reconnectDelayMs,
-      maxDelayMs: options.reconnectMaxDelayMs,
-    },
-    parseMessage: parseBookTickerMessage,
-    onMessage(message, receivedAt) {
-      if (!message.b || !message.B || !message.a || !message.A) {
-        return;
-      }
-
-      callbacks.onBookTicker({
-        bidPrice: message.b,
-        bidSize: message.B,
-        askPrice: message.a,
-        askSize: message.A,
-        exchangeTs: message.T,
-        receivedAt,
-      });
-      callbacks.onFreshnessChange("fresh");
-    },
-    onUnexpectedClose() {
-      callbacks.onDisconnected();
-    },
-    onError() {
-      callbacks.onError?.(new Error(`WebSocket error for ${market.symbol}`));
-    },
-  });
-
-  return {
-    ready: session.ready,
-    close() {
-      session.close();
-    },
-  };
-}

package/src/adapters/binance/mark-price.ts

@@ -1,126 +0,0 @@
-import { createManagedWebSocket } from "../../internal/managed-websocket.ts";
-import type { BinanceMarketDefinition } from "./market-catalog.ts";
-
-export interface BinanceFundingRateUpdate {
-  fundingRate: string;
-  nextFundingTime?: number;
-  markPrice?: string;
-  indexPrice?: string;
-  exchangeTs?: number;
-  receivedAt: number;
-}
-
-export interface BinanceMarkPriceSubscription {
-  readonly ready: Promise<void>;
-  close(): void;
-}
-
-export interface BinanceMarkPriceCallbacks {
-  onFundingRate(update: BinanceFundingRateUpdate): void;
-  onFreshnessChange(
-    freshness: "fresh" | "stale",
-    reason?: "heartbeat_timeout",
-  ): void;
-  onDisconnected(): void;
-  onError?(error: Error): void;
-}
-
-export interface BinanceMarkPriceOptions {
-  initialMessageTimeoutMs: number;
-  staleAfterMs: number;
-  reconnectDelayMs: number;
-  reconnectMaxDelayMs: number;
-  now?: () => number;
-}
-
-interface BinanceMarkPriceMessage {
-  e?: string;
-  E?: number;
-  s?: string;
-  p?: string;
-  i?: string;
-  r?: string;
-  T?: number;
-}
-
-const BINANCE_USDM_MARKET_WS_BASE_URL = "wss://fstream.binance.com/market/ws";
-const BINANCE_COINM_WS_BASE_URL = "wss://dstream.binance.com/ws";
-
-function getWsBaseUrl(market: BinanceMarketDefinition): string {
-  switch (market.family) {
-    case "usdm":
-      return BINANCE_USDM_MARKET_WS_BASE_URL;
-    case "coinm":
-      return BINANCE_COINM_WS_BASE_URL;
-    case "spot":
-      throw new Error(
-        `Funding rate is not supported for spot market: ${market.symbol}`,
-      );
-  }
-}
-
-function buildMarkPriceUrl(market: BinanceMarketDefinition): string {
-  return `${getWsBaseUrl(market)}/${market.id.toLowerCase()}@markPrice`;
-}
-
-function parseMarkPriceMessage(
-  data: string,
-): BinanceMarkPriceMessage | undefined {
-  const parsed = JSON.parse(data) as BinanceMarkPriceMessage;
-  if (!parsed.r) {
-    return undefined;
-  }
-
-  return parsed;
-}
-
-export function subscribeBinanceMarkPrice(
-  market: BinanceMarketDefinition,
-  callbacks: BinanceMarkPriceCallbacks,
-  options: BinanceMarkPriceOptions,
-): BinanceMarkPriceSubscription {
-  const session = createManagedWebSocket<BinanceMarkPriceMessage>({
-    url: buildMarkPriceUrl(market),
-    initialMessageTimeoutMs: options.initialMessageTimeoutMs,
-    now: options.now,
-    messageWatchdog: {
-      staleAfterMs: options.staleAfterMs,
-      onStale() {
-        callbacks.onFreshnessChange("stale", "heartbeat_timeout");
-      },
-    },
-    reconnect: {
-      initialDelayMs: options.reconnectDelayMs,
-      maxDelayMs: options.reconnectMaxDelayMs,
-    },
-    parseMessage: parseMarkPriceMessage,
-    onMessage(message, receivedAt) {
-      if (!message.r) {
-        return;
-      }
-
-      callbacks.onFundingRate({
-        fundingRate: message.r,
-        nextFundingTime: message.T,
-        markPrice: message.p,
-        indexPrice: message.i,
-        exchangeTs: message.E,
-        receivedAt,
-      });
-      callbacks.onFreshnessChange("fresh");
-    },
-    onUnexpectedClose() {
-      callbacks.onDisconnected();
-    },
-    onError() {
-      callbacks.onError?.(new Error(`WebSocket error for ${market.symbol}`));
-    },
-  });
-
-  return {
-    ready: session.ready,
-    close() {
-      session.close();
-    },
-  };
-}