@imbingox/acex 0.3.0-beta.2 → 0.3.0-beta.4

package/src/client/venue-capabilities.ts

@@ -0,0 +1,109 @@
+import type {
+  MarketAdapter,
+  PrivateUserDataAdapter,
+} from "../adapters/types.ts";
+import type {
+  VenueAccountCapabilities,
+  VenueCapabilities,
+  VenueMarketCapabilities,
+  VenueOrderCapabilities,
+} from "../types/client.ts";
+import { SUPPORTED_VENUES, type Venue } from "../types/shared.ts";
+
+const unsupportedAccount: VenueAccountCapabilities = {
+  register: "unsupported",
+  snapshot: "unsupported",
+  updates: "unsupported",
+  balances: "unsupported",
+  positions: "unsupported",
+  risk: "unsupported",
+  lending: "unsupported",
+  credentialsRequired: false,
+};
+
+const unsupportedOrder: Omit<VenueOrderCapabilities, "reason"> = {
+  supported: false,
+  openOrders: "unsupported",
+  updates: "unsupported",
+  create: "unsupported",
+  cancel: "unsupported",
+  cancelAll: "unsupported",
+  orderTypes: [],
+  timeInForce: [],
+  postOnly: false,
+  reduceOnly: false,
+  positionSide: "unsupported",
+  clientOrderId: false,
+};
+
+const typeOnlyNotes = [
+  "Venue is declared in public types but has no runtime adapter yet.",
+];
+
+const unsupportedMarket: VenueMarketCapabilities = {
+  catalog: "unsupported",
+  l1Book: "unsupported",
+  fundingRate: "unsupported",
+  marketTypes: [],
+};
+
+export interface VenueCapabilityAdapterRegistry {
+  marketAdapters: ReadonlyMap<Venue, MarketAdapter>;
+  privateAdapters: ReadonlyMap<Venue, PrivateUserDataAdapter>;
+}
+
+export function getVenueCapabilitiesSnapshot(
+  venue: Venue,
+  registry: VenueCapabilityAdapterRegistry,
+): VenueCapabilities {
+  const marketAdapter = registry.marketAdapters.get(venue);
+  const privateAdapter = registry.privateAdapters.get(venue);
+
+  return cloneVenueCapabilities({
+    venue,
+    runtimeStatus: marketAdapter || privateAdapter ? "available" : "type_only",
+    readOnly: privateAdapter?.readOnly ?? false,
+    notes:
+      privateAdapter?.notes ??
+      (marketAdapter
+        ? [
+            "Capabilities describe the current SDK runtime, not the venue's full API surface.",
+          ]
+        : typeOnlyNotes),
+    market: marketAdapter?.marketCapabilities ?? unsupportedMarket,
+    account: privateAdapter?.accountCapabilities ?? unsupportedAccount,
+    order: privateAdapter?.orderCapabilities ?? {
+      ...unsupportedOrder,
+      reason: "not_implemented",
+    },
+  });
+}
+
+export function listVenueCapabilitiesSnapshots(
+  registry: VenueCapabilityAdapterRegistry,
+): VenueCapabilities[] {
+  return SUPPORTED_VENUES.map((venue) =>
+    getVenueCapabilitiesSnapshot(venue, registry),
+  );
+}
+
+function cloneVenueCapabilities(
+  capabilities: VenueCapabilities,
+): VenueCapabilities {
+  return {
+    ...capabilities,
+    notes: [...capabilities.notes],
+    market: {
+      ...capabilities.market,
+      marketTypes: [...capabilities.market.marketTypes],
+    },
+    account: {
+      ...capabilities.account,
+    },
+    order: {
+      ...capabilities.order,
+      orderTypes: [...capabilities.order.orderTypes],
+      timeInForce: [...capabilities.order.timeInForce],
+    },
+  };
+}

package/src/managers/account-manager.ts

@@ -277,6 +277,7 @@ export class AccountManagerImpl
     accountId: string,
     venue: Venue,
     update: RawAccountUpdate,
+    options: { preserveStatus?: boolean } = {},
   ): void {
     const record = this.getOrCreateRecord(accountId, venue);
     if (!record.subscribed) {
@@ -358,16 +359,24 @@ export class AccountManagerImpl
       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,
-    };
+    record.status = options.preserveStatus
+      ? {
+          ...record.status,
+          activity: "active",
+          lastReceivedAt: update.receivedAt,
+          lastReadyAt: record.status.lastReadyAt ?? update.receivedAt,
+          inactiveSince: undefined,
+        }
+      : {
+          ...record.status,
+          activity: "active",
+          ready: true,
+          runtimeStatus: "healthy",
+          reason: undefined,
+          lastReceivedAt: update.receivedAt,
+          lastReadyAt: update.receivedAt,
+          inactiveSince: undefined,
+        };
     this.publishStatus(record);
   }
 
@@ -588,6 +597,10 @@ export class AccountManagerImpl
         input.riskRatio === undefined
           ? previous?.riskRatio
           : new BigNumber(input.riskRatio),
+      actualLeverage:
+        input.actualLeverage === undefined
+          ? previous?.actualLeverage
+          : new BigNumber(input.actualLeverage),
       initialMargin:
         input.initialMargin === undefined
           ? previous?.initialMargin

package/src/types/account.ts

@@ -93,6 +93,7 @@ export interface RiskSnapshot {
   venue: Venue;
   equity?: BigNumber;
   riskRatio?: BigNumber;
+  actualLeverage?: BigNumber;
   initialMargin?: BigNumber;
   maintenanceMargin?: BigNumber;
   exchangeTs?: number;

package/src/types/client.ts

@@ -7,8 +7,10 @@ import type {
   MarketDataStatus,
   MarketManager,
   MarketStatusChangedEvent,
+  MarketType,
 } from "./market.ts";
 import type {
+  CreateOrderType,
   OrderDataStatus,
   OrderManager,
   OrderStatusChangedEvent,
@@ -56,6 +58,73 @@ export interface ClientEventStreams {
   errors(): AsyncIterable<AcexInternalError>;
 }
 
+export type VenueRuntimeStatus = "available" | "type_only" | "reserved";
+
+export type VenueCapabilitySupport = "supported" | "unsupported";
+
+export type VenueCapabilityReason =
+  | "not_implemented"
+  | "read_only"
+  | "market_type_unsupported"
+  | "sdk_reserved";
+
+export type FundingRateCapability = VenueCapabilitySupport | "market_dependent";
+
+export type PrivateUpdateCapability = "websocket" | "polling" | "unsupported";
+
+export type CancelAllOrdersCapability = "symbol" | "account" | "unsupported";
+
+export type PositionSideCapability =
+  | "optional"
+  | "required_for_hedge"
+  | "unsupported";
+
+export type OrderTimeInForceCapability = "gtc" | "post_only";
+
+export interface VenueMarketCapabilities {
+  catalog: VenueCapabilitySupport;
+  l1Book: VenueCapabilitySupport;
+  fundingRate: FundingRateCapability;
+  marketTypes: MarketType[];
+}
+
+export interface VenueAccountCapabilities {
+  register: VenueCapabilitySupport;
+  snapshot: VenueCapabilitySupport;
+  updates: PrivateUpdateCapability;
+  balances: VenueCapabilitySupport;
+  positions: VenueCapabilitySupport;
+  risk: VenueCapabilitySupport;
+  lending: VenueCapabilitySupport;
+  credentialsRequired: boolean;
+}
+
+export interface VenueOrderCapabilities {
+  supported: boolean;
+  openOrders: VenueCapabilitySupport;
+  updates: PrivateUpdateCapability;
+  create: VenueCapabilitySupport;
+  cancel: VenueCapabilitySupport;
+  cancelAll: CancelAllOrdersCapability;
+  orderTypes: CreateOrderType[];
+  timeInForce: OrderTimeInForceCapability[];
+  postOnly: boolean;
+  reduceOnly: boolean;
+  positionSide: PositionSideCapability;
+  clientOrderId: boolean;
+  reason?: VenueCapabilityReason;
+}
+
+export interface VenueCapabilities {
+  venue: Venue;
+  runtimeStatus: VenueRuntimeStatus;
+  readOnly: boolean;
+  notes: string[];
+  market: VenueMarketCapabilities;
+  account: VenueAccountCapabilities;
+  order: VenueOrderCapabilities;
+}
+
 export interface AcexClient {
   readonly market: MarketManager;
   readonly account: AccountManager;
@@ -64,6 +133,8 @@ export interface AcexClient {
 
   getStatus(): ClientStatus;
   getHealth(): ClientHealthSnapshot;
+  getVenueCapabilities(venue: Venue): VenueCapabilities;
+  listVenueCapabilities(): VenueCapabilities[];
 
   registerAccount(input: RegisterAccountInput): Promise<RegisterAccountResult>;
   updateAccountCredentials(

package/src/types/shared.ts

@@ -36,6 +36,9 @@ export interface AccountRuntimeOptions {
   streamReconnectDelayMs?: number;
   streamReconnectMaxDelayMs?: number;
   listenKeyKeepAliveMs?: number;
+  binance?: {
+    riskPollIntervalMs?: number;
+  };
   juplend?: {
     pollIntervalMs?: number;
   };