@imbingox/acex 0.3.1-beta.0 → 0.4.0-beta.10

package/src/managers/market-manager.ts

@@ -14,14 +14,20 @@ import type {
   HealthReporter,
   ManagerLifecycle,
 } from "../client/context.ts";
-import { AcexError } from "../errors.ts";
+import {
+  AcexError,
+  buildAcexErrorDetails,
+  formatAcexErrorMessage,
+} from "../errors.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
+import { toCanonical } from "../internal/decimal.ts";
 import { matchesMarketFilter } from "../internal/filters.ts";
 import type {
   FundingRateSnapshot,
   FundingRateUpdatedEvent,
   L1Book,
   L1BookUpdatedEvent,
+  MarketCatalogReloadSummary,
   MarketDataStatus,
   MarketDataStreamStatus,
   MarketDefinition,
@@ -36,6 +42,7 @@ import type {
   SubscribeL1BookInput,
   SubscriptionActivity,
   Venue,
+  VenueServerTime,
 } from "../types/index.ts";
 
 export interface MarketManagerOptions {
@@ -62,6 +69,13 @@ interface MarketRecord {
   fundingRateStream?: StreamHandle;
 }
 
+interface CatalogFetchResult {
+  venue: Venue;
+  added: string[];
+  removed: string[];
+  total: number;
+}
+
 const DEFAULT_INITIAL_L1_TIMEOUT_MS = 15_000;
 const DEFAULT_L1_STALE_AFTER_MS = 15_000;
 const DEFAULT_L1_RECONNECT_DELAY_MS = 1_000;
@@ -100,10 +114,6 @@ function floorToStep(value: BigNumber, step: BigNumber): BigNumber {
   return value.dividedToIntegerBy(step).multipliedBy(step);
 }
 
-function normalizeDecimalInput(value: BigNumber): string {
-  return value.isFinite() ? value.toFixed() : value.toString();
-}
-
 export class MarketManagerImpl
   implements MarketManager, ManagerLifecycle, HealthReporter<MarketDataStatus>
 {
@@ -117,7 +127,10 @@ export class MarketManagerImpl
   private readonly definitions = new Map<string, MarketDefinition>();
   private readonly records = new Map<string, MarketRecord>();
   private readonly loadedCatalogVenues = new Set<Venue>();
-  private readonly catalogPromises = new Map<Venue, Promise<void>>();
+  private readonly catalogPromises = new Map<
+    Venue,
+    Promise<CatalogFetchResult>
+  >();
   private readonly initialL1TimeoutMs: number;
   private readonly l1StaleAfterMs: number;
   private readonly l1ReconnectDelayMs: number;
@@ -169,6 +182,48 @@ export class MarketManagerImpl
     );
   }
 
+  async reloadMarkets(venue?: Venue): Promise<MarketCatalogReloadSummary[]> {
+    if (venue !== undefined) {
+      this.assertSupportedVenue(venue);
+      return [await this.reloadVenue(venue)];
+    }
+
+    const venues = [...this.adapters.keys()];
+    const settled = await Promise.allSettled(
+      venues.map((registeredVenue) => this.reloadVenue(registeredVenue)),
+    );
+    const summaries: MarketCatalogReloadSummary[] = [];
+
+    for (const result of settled) {
+      if (result.status === "fulfilled") {
+        summaries.push(result.value);
+        continue;
+      }
+
+      throw result.reason;
+    }
+
+    return summaries;
+  }
+
+  async fetchServerTime(venue: Venue): Promise<VenueServerTime> {
+    const adapter = this.getMarketAdapter(venue);
+    if (!adapter.fetchServerTime) {
+      throw this.createError(
+        "VENUE_NOT_SUPPORTED",
+        `Venue is not supported yet: ${venue}`,
+        { venue },
+        "client",
+      );
+    }
+
+    try {
+      return await adapter.fetchServerTime();
+    } catch (error) {
+      throw this.createServerTimeFetchError(venue, error);
+    }
+  }
+
   async subscribeL1Book(input: SubscribeL1BookInput): Promise<void> {
     this.context.assertStarted();
     const market = await this.resolveMarketDefinition(input);
@@ -262,20 +317,36 @@ export class MarketManagerImpl
     const market = this.resolveLoadedMarket(input);
     const rawPrice = new BigNumber(input.price);
     const rawAmount = new BigNumber(input.amount);
-    const price = floorToStep(rawPrice, market.priceStep);
-    const amount = floorToStep(rawAmount, market.amountStep);
+    const priceStep = new BigNumber(market.priceStep);
+    const amountStep = new BigNumber(market.amountStep);
+    const minAmount =
+      market.minAmount === undefined
+        ? undefined
+        : new BigNumber(market.minAmount);
+    const minNotional =
+      market.minNotional === undefined
+        ? undefined
+        : new BigNumber(market.minNotional);
+    const price = floorToStep(rawPrice, priceStep);
+    const amount = floorToStep(rawAmount, amountStep);
+
+    // normalizeOrderInput rejects non-finite input gracefully (see the
+    // isFinite checks below), so its echoed numeric fields fall back to the
+    // raw string instead of throwing the way toCanonical now does.
+    const echoDecimal = (value: BigNumber): string =>
+      value.isFinite() ? toCanonical(value) : value.toString();
 
     const normalized: NormalizedOrderInput = {
-      price: normalizeDecimalInput(price),
-      amount: normalizeDecimalInput(amount),
-      rawPrice: normalizeDecimalInput(rawPrice),
-      rawAmount: normalizeDecimalInput(rawAmount),
+      price: echoDecimal(price),
+      amount: echoDecimal(amount),
+      rawPrice: echoDecimal(rawPrice),
+      rawAmount: echoDecimal(rawAmount),
       adjusted: !price.isEqualTo(rawPrice) || !amount.isEqualTo(rawAmount),
       accepted: true,
-      priceStep: market.priceStep.toFixed(),
-      amountStep: market.amountStep.toFixed(),
-      minAmount: market.minAmount?.toFixed(),
-      minNotional: market.minNotional?.toFixed(),
+      priceStep: market.priceStep,
+      amountStep: market.amountStep,
+      minAmount: market.minAmount,
+      minNotional: market.minNotional,
     };
 
     if (!price.isFinite() || price.isLessThanOrEqualTo(0)) {
@@ -294,7 +365,7 @@ export class MarketManagerImpl
       };
     }
 
-    if (market.minAmount && amount.isLessThan(market.minAmount)) {
+    if (minAmount && amount.isLessThan(minAmount)) {
       return {
         ...normalized,
         accepted: false,
@@ -302,9 +373,9 @@ export class MarketManagerImpl
       };
     }
 
-    if (market.minNotional) {
+    if (minNotional) {
       const notional = amount.multipliedBy(price);
-      if (notional.isLessThan(market.minNotional)) {
+      if (notional.isLessThan(minNotional)) {
         return {
           ...normalized,
           accepted: false,
@@ -425,51 +496,163 @@ export class MarketManagerImpl
       return;
     }
 
-    let catalogPromise = this.catalogPromises.get(venue);
-    if (!catalogPromise) {
-      catalogPromise = this.fetchAndStoreMarketCatalog(venue);
-      this.catalogPromises.set(venue, catalogPromise);
-    }
+    await this.fetchCatalogCoalesced(venue);
+  }
 
+  private async reloadVenue(venue: Venue): Promise<MarketCatalogReloadSummary> {
     try {
-      await catalogPromise;
+      const result = await this.fetchCatalogCoalesced(venue);
+      return { ...result, ok: true };
     } catch (error) {
-      this.catalogPromises.delete(venue);
+      if (
+        error instanceof AcexError &&
+        error.code === "MARKET_CATALOG_LOAD_FAILED"
+      ) {
+        return {
+          venue,
+          added: [],
+          removed: [],
+          total: this.countVenueMarkets(venue),
+          ok: false,
+          error,
+        };
+      }
+
       throw error;
     }
   }
 
-  private async fetchAndStoreMarketCatalog(venue: Venue): Promise<void> {
+  private async fetchCatalogCoalesced(
+    venue: Venue,
+  ): Promise<CatalogFetchResult> {
+    let catalogPromise = this.catalogPromises.get(venue);
+    if (!catalogPromise) {
+      catalogPromise = this.fetchAndStoreMarketCatalog(venue).finally(() => {
+        this.catalogPromises.delete(venue);
+      });
+      this.catalogPromises.set(venue, catalogPromise);
+    }
+
+    return await catalogPromise;
+  }
+
+  private async fetchAndStoreMarketCatalog(
+    venue: Venue,
+  ): Promise<CatalogFetchResult> {
     const adapter = this.getMarketAdapter(venue);
+    let markets: MarketDefinition[];
 
     try {
-      const markets = await adapter.loadMarkets();
+      markets = await adapter.loadMarkets();
+    } catch (error) {
+      throw this.createCatalogLoadError(venue, error);
+    }
 
-      for (const [key, market] of this.definitions) {
-        if (market.venue === venue) {
-          this.definitions.delete(key);
-        }
+    const mismatchedMarket = markets.find((market) => market.venue !== venue);
+    if (mismatchedMarket) {
+      throw this.createCatalogLoadError(
+        venue,
+        new Error(
+          `Market catalog from ${venue} included ${mismatchedMarket.venue} market: ${mismatchedMarket.symbol}`,
+        ),
+      );
+    }
+
+    const previousKeys = this.getVenueMarketKeys(venue);
+
+    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);
+    }
 
-      for (const market of markets) {
-        this.definitions.set(marketKey(market), market);
+    this.loadedCatalogVenues.add(venue);
+
+    const currentKeys = this.getVenueMarketKeys(venue);
+    return {
+      venue,
+      added: this.diffMarketSymbols(venue, currentKeys, previousKeys),
+      removed: this.diffMarketSymbols(venue, previousKeys, currentKeys),
+      total: currentKeys.size,
+    };
+  }
+
+  private getVenueMarketKeys(venue: Venue): Set<string> {
+    const keys = new Set<string>();
+
+    for (const [key, market] of this.definitions) {
+      if (market.venue === venue) {
+        keys.add(key);
       }
+    }
 
-      this.loadedCatalogVenues.add(venue);
-    } catch (error) {
-      const wrapped = new AcexError(
-        "MARKET_CATALOG_LOAD_FAILED",
+    return keys;
+  }
+
+  private countVenueMarkets(venue: Venue): number {
+    return this.getVenueMarketKeys(venue).size;
+  }
+
+  private diffMarketSymbols(
+    venue: Venue,
+    left: Set<string>,
+    right: Set<string>,
+  ): string[] {
+    const prefix = `${venue}:`;
+    return [...left]
+      .filter((key) => !right.has(key))
+      .map((key) => key.slice(prefix.length))
+      .sort((leftSymbol, rightSymbol) => leftSymbol.localeCompare(rightSymbol));
+  }
+
+  private createCatalogLoadError(venue: Venue, error: unknown): AcexError {
+    const details = buildAcexErrorDetails({ venue }, error);
+    const wrapped = new AcexError(
+      "MARKET_CATALOG_LOAD_FAILED",
+      formatAcexErrorMessage(
         `Failed to load market catalog from ${venue}`,
-      );
-      this.context.publishRuntimeError(
-        "adapter",
-        error instanceof Error
-          ? error
-          : new Error("Unknown catalog load failure"),
-        { venue },
-      );
-      throw wrapped;
-    }
+        details,
+      ),
+      {
+        cause: error,
+        details,
+      },
+    );
+    this.context.publishRuntimeError(
+      "adapter",
+      error instanceof Error
+        ? error
+        : new Error("Unknown catalog load failure"),
+      { venue },
+    );
+    return wrapped;
+  }
+
+  private createServerTimeFetchError(venue: Venue, error: unknown): AcexError {
+    const details = buildAcexErrorDetails({ venue }, error);
+    const wrapped = new AcexError(
+      "MARKET_SERVER_TIME_FETCH_FAILED",
+      formatAcexErrorMessage(
+        `Failed to fetch server time from ${venue}`,
+        details,
+      ),
+      {
+        cause: error,
+        details,
+      },
+    );
+    this.context.publishRuntimeError(
+      "adapter",
+      error instanceof Error
+        ? error
+        : new Error("Unknown server time fetch failure"),
+      { venue },
+    );
+    return wrapped;
   }
 
   private async resolveMarketDefinition(input: {
@@ -595,11 +778,20 @@ export class MarketManagerImpl
 
     try {
       await record.l1BookStream.ready;
-    } catch {
+    } catch (error) {
+      record.l1BookStream.close();
       record.l1BookStream = undefined;
+      const details = buildAcexErrorDetails(
+        { venue: market.venue, symbol: market.symbol },
+        error,
+      );
       const timeoutError = new AcexError(
         "MARKET_STREAM_TIMEOUT",
         `Timed out waiting for market data: ${market.symbol}`,
+        {
+          cause: error,
+          details,
+        },
       );
       this.context.publishRuntimeError("runtime", timeoutError, {
         venue: market.venue,
@@ -623,11 +815,20 @@ export class MarketManagerImpl
 
     try {
       await record.fundingRateStream.ready;
-    } catch {
+    } catch (error) {
+      record.fundingRateStream.close();
       record.fundingRateStream = undefined;
+      const details = buildAcexErrorDetails(
+        { venue: market.venue, symbol: market.symbol },
+        error,
+      );
       const timeoutError = new AcexError(
         "MARKET_STREAM_TIMEOUT",
         `Timed out waiting for market data: ${market.symbol}`,
+        {
+          cause: error,
+          details,
+        },
       );
       this.context.publishRuntimeError("runtime", timeoutError, {
         venue: market.venue,
@@ -774,10 +975,10 @@ export class MarketManagerImpl
     return {
       venue,
       symbol,
-      bidPrice: new BigNumber(input.bidPrice),
-      bidSize: new BigNumber(input.bidSize),
-      askPrice: new BigNumber(input.askPrice),
-      askSize: new BigNumber(input.askSize),
+      bidPrice: toCanonical(input.bidPrice),
+      bidSize: toCanonical(input.bidSize),
+      askPrice: toCanonical(input.askPrice),
+      askSize: toCanonical(input.askSize),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -801,12 +1002,10 @@ export class MarketManagerImpl
     return {
       venue,
       symbol,
-      fundingRate: new BigNumber(input.fundingRate),
+      fundingRate: toCanonical(input.fundingRate),
       nextFundingTime: input.nextFundingTime,
-      markPrice: input.markPrice ? new BigNumber(input.markPrice) : undefined,
-      indexPrice: input.indexPrice
-        ? new BigNumber(input.indexPrice)
-        : undefined,
+      markPrice: input.markPrice ? toCanonical(input.markPrice) : undefined,
+      indexPrice: input.indexPrice ? toCanonical(input.indexPrice) : undefined,
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -1028,7 +1227,9 @@ export class MarketManagerImpl
     metadata?: { venue?: Venue; symbol?: string },
     source: "market" | "client" = "market",
   ): AcexError {
-    const error = new AcexError(code, message);
+    const error = new AcexError(code, message, {
+      details: buildAcexErrorDetails(metadata),
+    });
     this.context.publishRuntimeError(source, error, metadata);
     return error;
   }