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

package/src/errors.ts

@@ -1,5 +1,6 @@
 export type AcexErrorCode =
   | "ACCOUNT_ALREADY_EXISTS"
+  | "ACCOUNT_BOOTSTRAP_FAILED"
   | "ACCOUNT_NOT_FOUND"
   | "CLIENT_NOT_STARTED"
   | "CREDENTIALS_MISSING"
@@ -7,7 +8,12 @@ export type AcexErrorCode =
   | "MARKET_CATALOG_LOAD_FAILED"
   | "MARKET_INACTIVE"
   | "MARKET_NOT_FOUND"
-  | "MARKET_STREAM_TIMEOUT";
+  | "MARKET_STREAM_TIMEOUT"
+  | "ORDER_BOOTSTRAP_FAILED"
+  | "ORDER_CANCEL_ALL_FAILED"
+  | "ORDER_CANCEL_FAILED"
+  | "ORDER_CREATE_FAILED"
+  | "ORDER_INPUT_INVALID";
 
 export class AcexError extends Error {
   readonly code: AcexErrorCode;

package/src/index.ts

@@ -1,3 +1,4 @@
+export { BigNumber } from "bignumber.js";
 export { createClient } from "./client/create-client.ts";
 export type { AcexErrorCode } from "./errors.ts";
 export { AcexError } from "./errors.ts";

package/src/internal/filters.ts

@@ -95,24 +95,22 @@ export function matchesHealthFilter(
     }
   }
 
-  if (
-    "exchange" in event &&
-    filter.exchange &&
-    event.exchange !== filter.exchange
-  ) {
-    return false;
+  if (filter.exchange) {
+    if (!("exchange" in event) || event.exchange !== filter.exchange) {
+      return false;
+    }
   }
 
-  if (
-    "accountId" in event &&
-    filter.accountId &&
-    event.accountId !== filter.accountId
-  ) {
-    return false;
+  if (filter.accountId) {
+    if (!("accountId" in event) || event.accountId !== filter.accountId) {
+      return false;
+    }
   }
 
-  if ("symbol" in event && filter.symbol && event.symbol !== filter.symbol) {
-    return false;
+  if (filter.symbol) {
+    if (!("symbol" in event) || event.symbol !== filter.symbol) {
+      return false;
+    }
   }
 
   return true;

package/src/internal/managed-websocket.ts

@@ -11,14 +11,17 @@ export interface ManagedWebSocketReconnectOptions {
   initialDelayMs: number;
   maxDelayMs: number;
   backoffMultiplier?: number;
+  reconnectWithoutMessages?: boolean;
 }
 
 export interface ManagedWebSocketOptions<TMessage> {
   url: string;
   initialMessageTimeoutMs: number;
+  readyWhen?: "message" | "open";
   parseMessage(data: string): TMessage | undefined;
   onMessage(message: TMessage, receivedAt: number): void;
   onUnexpectedClose(event: CloseEvent): void;
+  onOpen?(): void;
   onError?(event: Event): void;
   messageWatchdog?: ManagedWebSocketWatchdogOptions;
   reconnect?: ManagedWebSocketReconnectOptions;
@@ -52,6 +55,7 @@ export function createManagedWebSocket<TMessage>(
   const messageWatchdog = options.messageWatchdog;
   const reconnect = options.reconnect;
   const reconnectMultiplier = reconnect?.backoffMultiplier ?? 2;
+  const readyWhen = options.readyWhen ?? "message";
 
   let closed = false;
   let staleNotified = false;
@@ -131,7 +135,12 @@ export function createManagedWebSocket<TMessage>(
   };
 
   const scheduleReconnect = () => {
-    if (closed || !reconnect || !hasMessage || reconnectTimeout) {
+    if (
+      closed ||
+      !reconnect ||
+      reconnectTimeout ||
+      (!hasMessage && !reconnect.reconnectWithoutMessages)
+    ) {
       return;
     }
 
@@ -171,6 +180,17 @@ export function createManagedWebSocket<TMessage>(
       scheduleStaleTimeout();
     }
 
+    socket.addEventListener("open", () => {
+      if (closed || activeSocket !== socket) {
+        return;
+      }
+
+      options.onOpen?.();
+      if (readyWhen === "open") {
+        resolveIfPending();
+      }
+    });
+
     socket.addEventListener("message", (event) => {
       if (closed || activeSocket !== socket || typeof event.data !== "string") {
         return;
@@ -206,7 +226,9 @@ export function createManagedWebSocket<TMessage>(
         scheduleStaleTimeout();
       }
       options.onMessage(parsed, lastMessageAt);
-      resolveIfPending();
+      if (readyWhen === "message") {
+        resolveIfPending();
+      }
     });
 
     socket.addEventListener("error", (event) => {

package/src/managers/account-manager.ts

@@ -1,8 +1,18 @@
+import BigNumber from "bignumber.js";
+import type {
+  RawAccountBootstrap,
+  RawAccountUpdate,
+  RawBalanceUpdate,
+  RawPositionUpdate,
+  RawRiskUpdate,
+} from "../adapters/types.ts";
 import type {
   AccountAwareManager,
   ClientContext,
   HealthReporter,
   ManagerLifecycle,
+  PrivateAccountDataConsumer,
+  PrivateSubscriptionState,
 } from "../client/context.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { matchesAccountFilter } from "../internal/filters.ts";
@@ -35,12 +45,24 @@ function cloneAccountStatus(status: AccountDataStatus): AccountDataStatus {
   return { ...status };
 }
 
+function positionKey(symbol: string, side: PositionSnapshot["side"]): string {
+  return `${symbol}:${side}`;
+}
+
+function getBigNumber(
+  value: string | undefined,
+  fallback: BigNumber,
+): BigNumber {
+  return value === undefined ? fallback : new BigNumber(value);
+}
+
 export class AccountManagerImpl
   implements
     AccountManager,
     ManagerLifecycle,
     AccountAwareManager,
-    HealthReporter<AccountDataStatus>
+    HealthReporter<AccountDataStatus>,
+    PrivateAccountDataConsumer
 {
   readonly events: AccountEventStreams;
 
@@ -84,28 +106,13 @@ export class AccountManagerImpl
 
     const record = this.getOrCreateRecord(input.accountId, account.exchange);
     record.subscribed = true;
-    record.snapshot ??= this.createEmptySnapshot(
-      input.accountId,
-      account.exchange,
-    );
-    record.status = {
-      ...this.createStatus(input.accountId, account.exchange, "active"),
-      ready: true,
-      runtimeStatus: "healthy",
-      lastReceivedAt: record.snapshot.updatedAt,
-      lastReadyAt: record.snapshot.updatedAt,
-    };
-
-    const event: AccountSnapshotReplacedEvent = {
-      type: "account.snapshot_replaced",
-      accountId: record.accountId,
-      exchange: record.exchange,
-      snapshot: record.snapshot,
-      ts: this.context.now(),
-    };
 
-    this.accountBus.publish(event);
-    this.publishStatus(record);
+    try {
+      await this.context.subscribePrivateAccountFeed(input.accountId);
+    } catch (error) {
+      record.subscribed = false;
+      throw error;
+    }
   }
 
   async unsubscribeAccount(input: UnsubscribeAccountInput): Promise<void> {
@@ -114,11 +121,13 @@ export class AccountManagerImpl
       return;
     }
 
+    this.context.unsubscribePrivateAccountFeed(input.accountId);
     record.subscribed = false;
     record.status = {
       ...record.status,
       activity: "inactive",
       runtimeStatus: "stopped",
+      reason: undefined,
       inactiveSince: this.context.now(),
     };
     this.publishStatus(record);
@@ -162,31 +171,7 @@ export class AccountManagerImpl
 
   // --- ManagerLifecycle ---
 
-  onClientStarted(): void {
-    const now = this.context.now();
-
-    for (const [accountId, record] of this.records) {
-      if (!record.subscribed) {
-        continue;
-      }
-
-      const account = this.context.getRegisteredAccount(accountId);
-      const creds = account.credentials;
-      if (!creds?.apiKey || !creds.secret) {
-        continue;
-      }
-
-      record.snapshot ??= this.createEmptySnapshot(accountId, account.exchange);
-      record.status = {
-        ...this.createStatus(accountId, account.exchange, "active"),
-        ready: true,
-        runtimeStatus: "healthy",
-        lastReceivedAt: now,
-        lastReadyAt: record.snapshot.updatedAt,
-      };
-      this.publishStatus(record);
-    }
-  }
+  onClientStarted(): void {}
 
   onClientStopping(now: number): void {
     for (const record of this.records.values()) {
@@ -198,6 +183,7 @@ export class AccountManagerImpl
         ...record.status,
         activity: "inactive",
         runtimeStatus: "stopped",
+        reason: undefined,
         inactiveSince: now,
       };
       this.publishStatus(record);
@@ -217,6 +203,7 @@ export class AccountManagerImpl
       ...record.status,
       activity: "inactive",
       runtimeStatus: "stopped",
+      reason: undefined,
       inactiveSince: now,
     };
     this.publishStatus(record);
@@ -229,11 +216,185 @@ export class AccountManagerImpl
       return;
     }
 
-    record.status = this.createStatus(accountId, exchange, "active");
-    record.status.ready = Boolean(record.snapshot);
-    record.status.runtimeStatus = "healthy";
-    record.status.lastReadyAt =
-      record.snapshot?.updatedAt ?? this.context.now();
+    this.onPrivateAccountPending(accountId, exchange);
+  }
+
+  // --- PrivateAccountDataConsumer ---
+
+  onPrivateAccountPending(accountId: string, exchange: Exchange): void {
+    const record = this.getOrCreateRecord(accountId, exchange);
+    if (!record.subscribed) {
+      return;
+    }
+
+    record.status = {
+      ...this.createStatus(accountId, exchange, "active"),
+      ready: Boolean(record.snapshot),
+      runtimeStatus: "bootstrap_pending",
+      reason: undefined,
+      lastReceivedAt: record.snapshot?.updatedAt,
+      lastReadyAt: record.snapshot?.updatedAt,
+      inactiveSince: undefined,
+    };
+    this.publishStatus(record);
+  }
+
+  onPrivateAccountBootstrap(
+    accountId: string,
+    exchange: Exchange,
+    bootstrap: RawAccountBootstrap,
+  ): void {
+    const record = this.getOrCreateRecord(accountId, exchange);
+    if (!record.subscribed) {
+      return;
+    }
+
+    record.snapshot = this.createBootstrapSnapshot(
+      accountId,
+      exchange,
+      bootstrap,
+    );
+    record.status = {
+      ...record.status,
+      activity: "active",
+      ready: true,
+      runtimeStatus: "healthy",
+      reason: undefined,
+      lastReceivedAt: record.snapshot.receivedAt,
+      lastReadyAt: record.snapshot.updatedAt,
+      inactiveSince: undefined,
+    };
+
+    const event: AccountSnapshotReplacedEvent = {
+      type: "account.snapshot_replaced",
+      accountId,
+      exchange,
+      snapshot: record.snapshot,
+      ts: this.context.now(),
+    };
+
+    this.accountBus.publish(event);
+    this.publishStatus(record);
+  }
+
+  onPrivateAccountUpdate(
+    accountId: string,
+    exchange: Exchange,
+    update: RawAccountUpdate,
+  ): void {
+    const record = this.getOrCreateRecord(accountId, exchange);
+    if (!record.subscribed) {
+      return;
+    }
+
+    const previous =
+      record.snapshot ?? this.createEmptySnapshot(accountId, exchange);
+    const balances = { ...previous.balances };
+    const positions = new Map(
+      previous.positions.map((position) => [
+        positionKey(position.symbol, position.side),
+        position,
+      ]),
+    );
+    let risk = previous.risk;
+
+    for (const balance of update.balances ?? []) {
+      const nextBalance = this.createBalance(
+        accountId,
+        exchange,
+        balance,
+        balances[balance.asset],
+      );
+      balances[balance.asset] = nextBalance;
+      this.accountBus.publish({
+        type: "balance.updated",
+        accountId,
+        exchange,
+        asset: balance.asset,
+        snapshot: nextBalance,
+        ts: this.context.now(),
+      });
+    }
+
+    for (const position of update.positions ?? []) {
+      const key = positionKey(position.symbol, position.side);
+      const nextPosition = this.createPosition(
+        accountId,
+        exchange,
+        position,
+        positions.get(key),
+      );
+
+      if (nextPosition.size.isZero()) {
+        positions.delete(key);
+      } else {
+        positions.set(key, nextPosition);
+      }
+
+      this.accountBus.publish({
+        type: "position.updated",
+        accountId,
+        exchange,
+        symbol: position.symbol,
+        snapshot: nextPosition,
+        ts: this.context.now(),
+      });
+    }
+
+    if (update.risk) {
+      risk = this.createRisk(accountId, exchange, update.risk, previous.risk);
+      this.accountBus.publish({
+        type: "risk.updated",
+        accountId,
+        exchange,
+        snapshot: risk,
+        ts: this.context.now(),
+      });
+    }
+
+    record.snapshot = {
+      accountId,
+      exchange,
+      balances,
+      positions: [...positions.values()],
+      risk,
+      exchangeTs: update.exchangeTs ?? previous.exchangeTs,
+      receivedAt: update.receivedAt,
+      updatedAt: update.receivedAt,
+    };
+    record.status = {
+      ...record.status,
+      activity: "active",
+      ready: true,
+      runtimeStatus: "healthy",
+      reason: undefined,
+      lastReceivedAt: update.receivedAt,
+      lastReadyAt: update.receivedAt,
+      inactiveSince: undefined,
+    };
+    this.publishStatus(record);
+  }
+
+  onPrivateAccountStreamState(
+    accountId: string,
+    exchange: Exchange,
+    state: PrivateSubscriptionState,
+  ): void {
+    const record = this.getOrCreateRecord(accountId, exchange);
+    if (!record.subscribed) {
+      return;
+    }
+
+    record.status = {
+      ...record.status,
+      activity: "active",
+      ready: state.ready,
+      runtimeStatus: state.runtimeStatus,
+      reason: state.reason,
+      lastReceivedAt: state.lastReceivedAt ?? record.status.lastReceivedAt,
+      lastReadyAt: state.lastReadyAt ?? record.status.lastReadyAt,
+      inactiveSince: undefined,
+    };
     this.publishStatus(record);
   }
 
@@ -285,6 +446,36 @@ export class AccountManagerImpl
     };
   }
 
+  private createBootstrapSnapshot(
+    accountId: string,
+    exchange: Exchange,
+    bootstrap: RawAccountBootstrap,
+  ): AccountSnapshot {
+    const balances = Object.fromEntries(
+      bootstrap.balances.map((balance) => [
+        balance.asset,
+        this.createBalance(accountId, exchange, balance),
+      ]),
+    );
+    const positions = bootstrap.positions
+      .map((position) => this.createPosition(accountId, exchange, position))
+      .filter((position) => !position.size.isZero());
+    const risk = bootstrap.risk
+      ? this.createRisk(accountId, exchange, bootstrap.risk)
+      : undefined;
+
+    return {
+      accountId,
+      exchange,
+      balances,
+      positions,
+      risk,
+      exchangeTs: bootstrap.exchangeTs,
+      receivedAt: bootstrap.receivedAt,
+      updatedAt: bootstrap.receivedAt,
+    };
+  }
+
   private createEmptySnapshot(
     accountId: string,
     exchange: Exchange,
@@ -300,6 +491,109 @@ export class AccountManagerImpl
     };
   }
 
+  private createBalance(
+    accountId: string,
+    exchange: Exchange,
+    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 free = getBigNumber(input.free, previousFree);
+    const total = getBigNumber(input.total, previousTotal);
+    const used =
+      input.used !== undefined
+        ? new BigNumber(input.used)
+        : input.total !== undefined || input.free !== undefined
+          ? total.minus(free)
+          : previousUsed;
+
+    return {
+      accountId,
+      exchange,
+      asset: input.asset,
+      free,
+      used,
+      total,
+      exchangeTs: input.exchangeTs,
+      receivedAt: input.receivedAt,
+      updatedAt: input.receivedAt,
+      seq: (previous?.seq ?? 0) + 1,
+    };
+  }
+
+  private createPosition(
+    accountId: string,
+    exchange: Exchange,
+    input: RawPositionUpdate,
+    previous?: PositionSnapshot,
+  ): PositionSnapshot {
+    return {
+      accountId,
+      exchange,
+      symbol: input.symbol,
+      side: input.side,
+      size: new BigNumber(input.size),
+      entryPrice:
+        input.entryPrice === undefined
+          ? previous?.entryPrice
+          : new BigNumber(input.entryPrice),
+      markPrice:
+        input.markPrice === undefined
+          ? previous?.markPrice
+          : new BigNumber(input.markPrice),
+      unrealizedPnl:
+        input.unrealizedPnl === undefined
+          ? previous?.unrealizedPnl
+          : new BigNumber(input.unrealizedPnl),
+      leverage:
+        input.leverage === undefined
+          ? previous?.leverage
+          : new BigNumber(input.leverage),
+      liquidationPrice:
+        input.liquidationPrice === undefined
+          ? previous?.liquidationPrice
+          : new BigNumber(input.liquidationPrice),
+      exchangeTs: input.exchangeTs,
+      receivedAt: input.receivedAt,
+      updatedAt: input.receivedAt,
+      seq: (previous?.seq ?? 0) + 1,
+    };
+  }
+
+  private createRisk(
+    accountId: string,
+    exchange: Exchange,
+    input: RawRiskUpdate,
+    previous?: RiskSnapshot,
+  ): RiskSnapshot {
+    return {
+      accountId,
+      exchange,
+      equity:
+        input.equity === undefined
+          ? previous?.equity
+          : new BigNumber(input.equity),
+      marginRatio:
+        input.marginRatio === undefined
+          ? previous?.marginRatio
+          : new BigNumber(input.marginRatio),
+      initialMargin:
+        input.initialMargin === undefined
+          ? previous?.initialMargin
+          : new BigNumber(input.initialMargin),
+      maintenanceMargin:
+        input.maintenanceMargin === undefined
+          ? previous?.maintenanceMargin
+          : new BigNumber(input.maintenanceMargin),
+      exchangeTs: input.exchangeTs,
+      receivedAt: input.receivedAt,
+      updatedAt: input.receivedAt,
+      seq: (previous?.seq ?? 0) + 1,
+    };
+  }
+
   private publishStatus(record: AccountRecord): void {
     const event: AccountStatusChangedEvent = {
       type: "account.status_changed",

package/src/managers/market-manager.ts

@@ -1,3 +1,4 @@
+import BigNumber from "bignumber.js";
 import type {
   L1BookStreamCallbacks,
   L1BookStreamOptions,
@@ -208,13 +209,23 @@ export class MarketManagerImpl
     this.updateActivity(record);
   }
 
-  getMarket(symbol: string): MarketDefinition | undefined {
-    const market = this.definitions.get(symbol);
+  getMarket(exchange: Exchange, symbol: string): MarketDefinition | undefined {
+    const market = this.definitions.get(marketKey({ exchange, symbol }));
     return market ? cloneMarketDefinition(market) : undefined;
   }
 
-  listMarkets(): MarketDefinition[] {
+  findMarkets(symbol: string): MarketDefinition[] {
     return [...this.definitions.values()]
+      .filter((market) => market.symbol === symbol)
+      .map((market) => cloneMarketDefinition(market));
+  }
+
+  listMarkets(exchange?: Exchange): MarketDefinition[] {
+    const values = [...this.definitions.values()];
+    const filtered = exchange
+      ? values.filter((market) => market.exchange === exchange)
+      : values;
+    return filtered
       .sort((left, right) => left.symbol.localeCompare(right.symbol))
       .map((market) => cloneMarketDefinition(market));
   }
@@ -319,7 +330,7 @@ export class MarketManagerImpl
       this.definitions.clear();
 
       for (const market of markets) {
-        this.definitions.set(market.symbol, market);
+        this.definitions.set(marketKey(market), market);
       }
     } catch (error) {
       const wrapped = new AcexError(
@@ -344,7 +355,7 @@ export class MarketManagerImpl
     this.assertSupportedExchange(input.exchange);
     await this.loadMarketCatalog();
 
-    const market = this.definitions.get(input.symbol);
+    const market = this.definitions.get(marketKey(input));
     if (!market) {
       throw this.createError(
         "MARKET_NOT_FOUND",
@@ -517,10 +528,10 @@ export class MarketManagerImpl
     return {
       exchange,
       symbol,
-      bidPrice: input.bidPrice,
-      bidSize: input.bidSize,
-      askPrice: input.askPrice,
-      askSize: input.askSize,
+      bidPrice: new BigNumber(input.bidPrice),
+      bidSize: new BigNumber(input.bidSize),
+      askPrice: new BigNumber(input.askPrice),
+      askSize: new BigNumber(input.askSize),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -538,7 +549,7 @@ export class MarketManagerImpl
     return {
       exchange,
       symbol,
-      fundingRate: previous?.fundingRate ?? "0",
+      fundingRate: previous?.fundingRate ?? new BigNumber(0),
       nextFundingTime: previous?.nextFundingTime,
       markPrice: previous?.markPrice,
       indexPrice: previous?.indexPrice,