@imbingox/acex 0.3.0 → 0.4.0-beta.1

package/src/managers/account-manager.ts

@@ -15,6 +15,7 @@ import type {
   PrivateSubscriptionState,
 } from "../client/context.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
+import { toCanonical } from "../internal/decimal.ts";
 import { matchesAccountFilter } from "../internal/filters.ts";
 import type {
   AccountDataStatus,
@@ -56,6 +57,10 @@ function getBigNumber(
   return value === undefined ? fallback : new BigNumber(value);
 }
 
+function isZeroDecimal(value: string): boolean {
+  return new BigNumber(value).isZero();
+}
+
 export class AccountManagerImpl
   implements
     AccountManager,
@@ -322,7 +327,7 @@ export class AccountManagerImpl
         positions.get(key),
       );
 
-      if (nextPosition.size.isZero()) {
+      if (isZeroDecimal(nextPosition.size)) {
         positions.delete(key);
       } else {
         positions.set(key, nextPosition);
@@ -461,7 +466,7 @@ export class AccountManagerImpl
     );
     const positions = bootstrap.positions
       .map((position) => this.createPosition(accountId, venue, position))
-      .filter((position) => !position.size.isZero());
+      .filter((position) => !isZeroDecimal(position.size));
     const risk = bootstrap.risk
       ? this.createRisk(accountId, venue, bootstrap.risk)
       : undefined;
@@ -499,9 +504,12 @@ export class AccountManagerImpl
     input: RawBalanceUpdate,
     previous?: BalanceSnapshot,
   ): BalanceSnapshot {
-    const previousFree = previous?.free ?? new BigNumber(0);
-    const previousUsed = previous?.used ?? new BigNumber(0);
-    const previousTotal = previous?.total ?? previousFree.plus(previousUsed);
+    const previousFree = new BigNumber(previous?.free ?? 0);
+    const previousUsed = new BigNumber(previous?.used ?? 0);
+    const previousTotal =
+      previous?.total === undefined
+        ? previousFree.plus(previousUsed)
+        : new BigNumber(previous.total);
     const free = getBigNumber(input.free, previousFree);
     const total = getBigNumber(input.total, previousTotal);
     const used =
@@ -515,27 +523,27 @@ export class AccountManagerImpl
       accountId,
       venue,
       asset: input.asset,
-      free,
-      used,
-      total,
+      free: toCanonical(free),
+      used: toCanonical(used),
+      total: toCanonical(total),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
       seq: (previous?.seq ?? 0) + 1,
       lending: input.lending
         ? {
-            supplied: new BigNumber(input.lending.supplied),
-            borrowed: new BigNumber(input.lending.borrowed),
-            interest: new BigNumber(input.lending.interest),
-            netAsset: new BigNumber(input.lending.netAsset),
+            supplied: toCanonical(input.lending.supplied),
+            borrowed: toCanonical(input.lending.borrowed),
+            interest: toCanonical(input.lending.interest),
+            netAsset: toCanonical(input.lending.netAsset),
             supplyAPY:
               input.lending.supplyAPY === undefined
                 ? undefined
-                : new BigNumber(input.lending.supplyAPY),
+                : toCanonical(input.lending.supplyAPY),
             borrowAPY:
               input.lending.borrowAPY === undefined
                 ? undefined
-                : new BigNumber(input.lending.borrowAPY),
+                : toCanonical(input.lending.borrowAPY),
           }
         : previous?.lending,
     };
@@ -552,27 +560,27 @@ export class AccountManagerImpl
       venue,
       symbol: input.symbol,
       side: input.side,
-      size: new BigNumber(input.size),
+      size: toCanonical(input.size),
       entryPrice:
         input.entryPrice === undefined
           ? previous?.entryPrice
-          : new BigNumber(input.entryPrice),
+          : toCanonical(input.entryPrice),
       markPrice:
         input.markPrice === undefined
           ? previous?.markPrice
-          : new BigNumber(input.markPrice),
+          : toCanonical(input.markPrice),
       unrealizedPnl:
         input.unrealizedPnl === undefined
           ? previous?.unrealizedPnl
-          : new BigNumber(input.unrealizedPnl),
+          : toCanonical(input.unrealizedPnl),
       leverage:
         input.leverage === undefined
           ? previous?.leverage
-          : new BigNumber(input.leverage),
+          : toCanonical(input.leverage),
       liquidationPrice:
         input.liquidationPrice === undefined
           ? previous?.liquidationPrice
-          : new BigNumber(input.liquidationPrice),
+          : toCanonical(input.liquidationPrice),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -592,27 +600,27 @@ export class AccountManagerImpl
       netEquity:
         input.netEquity === undefined
           ? previous?.netEquity
-          : new BigNumber(input.netEquity),
+          : toCanonical(input.netEquity),
       riskEquity:
         input.riskEquity === undefined
           ? previous?.riskEquity
-          : new BigNumber(input.riskEquity),
+          : toCanonical(input.riskEquity),
       riskRatio:
         input.riskRatio === undefined
           ? previous?.riskRatio
-          : new BigNumber(input.riskRatio),
+          : toCanonical(input.riskRatio),
       riskLeverage:
         input.riskLeverage === undefined
           ? previous?.riskLeverage
-          : new BigNumber(input.riskLeverage),
+          : toCanonical(input.riskLeverage),
       initialMargin:
         input.initialMargin === undefined
           ? previous?.initialMargin
-          : new BigNumber(input.initialMargin),
+          : toCanonical(input.initialMargin),
       maintenanceMargin:
         input.maintenanceMargin === undefined
           ? previous?.maintenanceMargin
-          : new BigNumber(input.maintenanceMargin),
+          : toCanonical(input.maintenanceMargin),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -622,27 +630,27 @@ export class AccountManagerImpl
             marginLevel:
               input.lending.marginLevel === undefined
                 ? undefined
-                : new BigNumber(input.lending.marginLevel),
+                : toCanonical(input.lending.marginLevel),
             healthFactor:
               input.lending.healthFactor === undefined
                 ? undefined
-                : new BigNumber(input.lending.healthFactor),
+                : toCanonical(input.lending.healthFactor),
             ltv:
               input.lending.ltv === undefined
                 ? undefined
-                : new BigNumber(input.lending.ltv),
+                : toCanonical(input.lending.ltv),
             liquidationThreshold:
               input.lending.liquidationThreshold === undefined
                 ? undefined
-                : new BigNumber(input.lending.liquidationThreshold),
+                : toCanonical(input.lending.liquidationThreshold),
             totalCollateralUSD:
               input.lending.totalCollateralUSD === undefined
                 ? undefined
-                : new BigNumber(input.lending.totalCollateralUSD),
+                : toCanonical(input.lending.totalCollateralUSD),
             totalDebtUSD:
               input.lending.totalDebtUSD === undefined
                 ? undefined
-                : new BigNumber(input.lending.totalDebtUSD),
+                : toCanonical(input.lending.totalDebtUSD),
           }
         : previous?.lending,
     };

package/src/managers/market-manager.ts

@@ -16,6 +16,7 @@ import type {
 } from "../client/context.ts";
 import { AcexError } 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,
@@ -100,35 +101,33 @@ 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>
 {
   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 +161,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> {
@@ -258,20 +259,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)) {
@@ -290,7 +307,7 @@ export class MarketManagerImpl
       };
     }
 
-    if (market.minAmount && amount.isLessThan(market.minAmount)) {
+    if (minAmount && amount.isLessThan(minAmount)) {
       return {
         ...normalized,
         accepted: false,
@@ -298,9 +315,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,
@@ -414,43 +431,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 +490,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 +529,7 @@ export class MarketManagerImpl
   }
 
   private assertSupportedVenue(venue: Venue): void {
-    if (venue === this.adapter.venue) {
+    if (this.adapters.has(venue)) {
       return;
     }
 
@@ -512,6 +541,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 +707,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 +768,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(
@@ -736,10 +787,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,
@@ -763,12 +814,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,

package/src/managers/order-manager.ts

@@ -10,6 +10,7 @@ import type {
 } from "../client/context.ts";
 import { AcexError } from "../errors.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
+import { toCanonical } from "../internal/decimal.ts";
 import { matchesOrderFilter } from "../internal/filters.ts";
 import type {
   CancelAllOrdersInput,
@@ -546,22 +547,20 @@ export class OrderManagerImpl
       type: input.type,
       status: input.status,
       price:
-        input.price === undefined
-          ? previous?.price
-          : new BigNumber(input.price),
+        input.price === undefined ? previous?.price : toCanonical(input.price),
       triggerPrice:
         input.triggerPrice === undefined
           ? previous?.triggerPrice
-          : new BigNumber(input.triggerPrice),
-      amount,
-      filled,
-      remaining,
+          : toCanonical(input.triggerPrice),
+      amount: toCanonical(amount),
+      filled: toCanonical(filled),
+      remaining: toCanonical(remaining),
       reduceOnly: input.reduceOnly ?? previous?.reduceOnly,
       positionSide: input.positionSide ?? previous?.positionSide,
       avgFillPrice:
         input.avgFillPrice === undefined
           ? previous?.avgFillPrice
-          : new BigNumber(input.avgFillPrice),
+          : toCanonical(input.avgFillPrice),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,

package/src/types/account.ts

@@ -1,4 +1,3 @@
-import type BigNumber from "bignumber.js";
 import type {
   PrivateRuntimeReason,
   PrivateRuntimeStatus,
@@ -52,9 +51,9 @@ export interface BalanceSnapshot {
   accountId: string;
   venue: Venue;
   asset: string;
-  free: BigNumber;
-  used: BigNumber;
-  total: BigNumber;
+  free: string;
+  used: string;
+  total: string;
   exchangeTs?: number;
   receivedAt: number;
   updatedAt: number;
@@ -63,12 +62,12 @@ export interface BalanceSnapshot {
 }
 
 export interface LendingBalanceFacet {
-  supplied: BigNumber;
-  borrowed: BigNumber;
-  interest: BigNumber;
-  netAsset: BigNumber;
-  supplyAPY?: BigNumber;
-  borrowAPY?: BigNumber;
+  supplied: string;
+  borrowed: string;
+  interest: string;
+  netAsset: string;
+  supplyAPY?: string;
+  borrowAPY?: string;
 }
 
 export interface PositionSnapshot {
@@ -76,12 +75,12 @@ export interface PositionSnapshot {
   venue: Venue;
   symbol: string;
   side: PositionSide;
-  size: BigNumber;
-  entryPrice?: BigNumber;
-  markPrice?: BigNumber;
-  unrealizedPnl?: BigNumber;
-  leverage?: BigNumber;
-  liquidationPrice?: BigNumber;
+  size: string;
+  entryPrice?: string;
+  markPrice?: string;
+  unrealizedPnl?: string;
+  leverage?: string;
+  liquidationPrice?: string;
   exchangeTs?: number;
   receivedAt: number;
   updatedAt: number;
@@ -91,12 +90,12 @@ export interface PositionSnapshot {
 export interface RiskSnapshot {
   accountId: string;
   venue: Venue;
-  netEquity?: BigNumber;
-  riskEquity?: BigNumber;
-  riskRatio?: BigNumber;
-  riskLeverage?: BigNumber;
-  initialMargin?: BigNumber;
-  maintenanceMargin?: BigNumber;
+  netEquity?: string;
+  riskEquity?: string;
+  riskRatio?: string;
+  riskLeverage?: string;
+  initialMargin?: string;
+  maintenanceMargin?: string;
   exchangeTs?: number;
   receivedAt: number;
   updatedAt: number;
@@ -105,12 +104,12 @@ export interface RiskSnapshot {
 }
 
 export interface LendingRiskFacet {
-  marginLevel?: BigNumber;
-  healthFactor?: BigNumber;
-  ltv?: BigNumber;
-  liquidationThreshold?: BigNumber;
-  totalCollateralUSD?: BigNumber;
-  totalDebtUSD?: BigNumber;
+  marginLevel?: string;
+  healthFactor?: string;
+  ltv?: string;
+  liquidationThreshold?: string;
+  totalCollateralUSD?: string;
+  totalDebtUSD?: string;
 }
 
 export interface AccountSnapshot {

package/src/types/market.ts

@@ -15,13 +15,13 @@ export interface MarketDefinition {
   contract: boolean;
   linear?: boolean;
   inverse?: boolean;
-  contractSize?: BigNumber;
+  contractSize?: string;
   pricePrecision: number;
   amountPrecision: number;
-  priceStep: BigNumber;
-  amountStep: BigNumber;
-  minAmount?: BigNumber;
-  minNotional?: BigNumber;
+  priceStep: string;
+  amountStep: string;
+  minAmount?: string;
+  minNotional?: string;
   expiry?: number;
   raw: Record<string, unknown>;
 }
@@ -92,10 +92,10 @@ export interface MarketEventFilter {
 export interface L1Book {
   venue: Venue;
   symbol: string;
-  bidPrice: BigNumber;
-  bidSize: BigNumber;
-  askPrice: BigNumber;
-  askSize: BigNumber;
+  bidPrice: string;
+  bidSize: string;
+  askPrice: string;
+  askSize: string;
   exchangeTs?: number;
   receivedAt: number;
   updatedAt: number;
@@ -106,10 +106,10 @@ export interface L1Book {
 export interface FundingRateSnapshot {
   venue: Venue;
   symbol: string;
-  fundingRate: BigNumber;
+  fundingRate: string;
   nextFundingTime?: number;
-  markPrice?: BigNumber;
-  indexPrice?: BigNumber;
+  markPrice?: string;
+  indexPrice?: string;
   exchangeTs?: number;
   receivedAt: number;
   updatedAt: number;