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

package/src/client/runtime.ts

@@ -1,9 +1,11 @@
 import { BinanceMarketAdapter } from "../adapters/binance/adapter.ts";
 import { BinancePrivateAdapter } from "../adapters/binance/private-adapter.ts";
+import { JuplendPrivateAdapter } from "../adapters/juplend/private-adapter.ts";
 import type {
   CancelAllOrdersRequest,
   CancelOrderRequest,
   CreateOrderRequest,
+  MarketAdapter,
   PrivateUserDataAdapter,
   RawOrderUpdate,
 } from "../adapters/types.ts";
@@ -33,6 +35,8 @@ import type {
   RegisterAccountInput,
   RegisterAccountResult,
   StopOptions,
+  Venue,
+  VenueCapabilities,
 } from "../types/index.ts";
 import {
   type ClientContext,
@@ -43,6 +47,10 @@ import {
   type RegisteredAccountRecord,
 } from "./context.ts";
 import { PrivateSubscriptionCoordinator } from "./private-subscription-coordinator.ts";
+import {
+  getVenueCapabilitiesSnapshot,
+  listVenueCapabilitiesSnapshots,
+} from "./venue-capabilities.ts";
 
 const activeClients = new Set<AcexClientImpl>();
 
@@ -87,14 +95,22 @@ export class AcexClientImpl implements AcexClient, ClientContext {
   private readonly marketManager: MarketManagerImpl;
   private readonly accountManager: AccountManagerImpl;
   private readonly orderManager: OrderManagerImpl;
-  private readonly privateAdapter: PrivateUserDataAdapter;
+  private readonly marketAdapters: Map<Venue, MarketAdapter>;
+  private readonly privateAdapters: Map<Venue, PrivateUserDataAdapter>;
   private readonly privateCoordinator: PrivateSubscriptionCoordinator;
 
   constructor(options: CreateClientOptions = {}) {
     activeClients.add(this);
 
     const marketAdapter = new BinanceMarketAdapter();
-    this.privateAdapter = new BinancePrivateAdapter();
+    this.marketAdapters = new Map([[marketAdapter.venue, marketAdapter]]);
+    const privateAdapters = [
+      new BinancePrivateAdapter(),
+      new JuplendPrivateAdapter(),
+    ];
+    this.privateAdapters = new Map(
+      privateAdapters.map((adapter) => [adapter.venue, adapter]),
+    );
 
     this.marketManager = new MarketManagerImpl(this, marketAdapter, {
       initialL1TimeoutMs: options.market?.l1InitialMessageTimeoutMs,
@@ -106,7 +122,7 @@ export class AcexClientImpl implements AcexClient, ClientContext {
     this.orderManager = new OrderManagerImpl(this);
     this.privateCoordinator = new PrivateSubscriptionCoordinator(
       this,
-      this.privateAdapter,
+      privateAdapters,
       this.accountManager as PrivateAccountDataConsumer,
       this.orderManager as PrivateOrderDataConsumer,
       options.account,
@@ -134,6 +150,20 @@ export class AcexClientImpl implements AcexClient, ClientContext {
     };
   }
 
+  getVenueCapabilities(venue: Venue): VenueCapabilities {
+    return getVenueCapabilitiesSnapshot(venue, {
+      marketAdapters: this.marketAdapters,
+      privateAdapters: this.privateAdapters,
+    });
+  }
+
+  listVenueCapabilities(): VenueCapabilities[] {
+    return listVenueCapabilitiesSnapshots({
+      marketAdapters: this.marketAdapters,
+      privateAdapters: this.privateAdapters,
+    });
+  }
+
   async registerAccount(
     input: RegisterAccountInput,
   ): Promise<RegisterAccountResult> {
@@ -141,20 +171,20 @@ export class AcexClientImpl implements AcexClient, ClientContext {
       throw this.createError(
         "ACCOUNT_ALREADY_EXISTS",
         `Account already exists: ${input.accountId}`,
-        { accountId: input.accountId, exchange: input.exchange },
+        { accountId: input.accountId, venue: input.venue },
       );
     }
 
     this.registeredAccounts.set(input.accountId, {
       accountId: input.accountId,
-      exchange: input.exchange,
+      venue: input.venue,
       credentials: input.credentials,
-      options: input.options,
+      options: input.options as Record<string, unknown> | undefined,
     });
 
     return {
       accountId: input.accountId,
-      exchange: input.exchange,
+      venue: input.venue,
     };
   }
 
@@ -177,8 +207,8 @@ export class AcexClientImpl implements AcexClient, ClientContext {
       return;
     }
 
-    this.accountManager.onCredentialsUpdated(accountId, account.exchange);
-    this.orderManager.onCredentialsUpdated(accountId, account.exchange);
+    this.accountManager.onCredentialsUpdated(accountId, account.venue);
+    this.orderManager.onCredentialsUpdated(accountId, account.venue);
     this.privateCoordinator.onCredentialsUpdated(accountId);
   }
 
@@ -262,14 +292,14 @@ export class AcexClientImpl implements AcexClient, ClientContext {
 
   ensurePrivateCredentials(accountId: string): void {
     const account = this.getRegisteredAccount(accountId);
-    if (hasPrivateCredentials(account.credentials)) {
+    if (hasPrivateCredentials(account.credentials, account.venue)) {
       return;
     }
 
     throw this.createError(
       "CREDENTIALS_MISSING",
       `Account credentials are required for private subscriptions: ${accountId}`,
-      { accountId, exchange: account.exchange },
+      { accountId, venue: account.venue },
     );
   }
 
@@ -303,7 +333,7 @@ export class AcexClientImpl implements AcexClient, ClientContext {
       positionSide: input.positionSide,
     };
 
-    return this.privateAdapter.createOrder(
+    return this.getPrivateAdapter(account.venue).createOrder(
       account.credentials ?? {},
       request,
       account.options,
@@ -318,7 +348,7 @@ export class AcexClientImpl implements AcexClient, ClientContext {
       clientOrderId: input.clientOrderId,
     };
 
-    return this.privateAdapter.cancelOrder(
+    return this.getPrivateAdapter(account.venue).cancelOrder(
       account.credentials ?? {},
       request,
       account.options,
@@ -331,7 +361,7 @@ export class AcexClientImpl implements AcexClient, ClientContext {
       symbol: input.symbol,
     };
 
-    return this.privateAdapter.cancelAllOrders(
+    return this.getPrivateAdapter(account.venue).cancelAllOrders(
       account.credentials ?? {},
       request,
       account.options,
@@ -390,22 +420,36 @@ export class AcexClientImpl implements AcexClient, ClientContext {
 
   private getPrivateCommandAccount(accountId: string): RegisteredAccountRecord {
     const account = this.getRegisteredAccount(accountId);
-    if (account.exchange !== this.privateAdapter.exchange) {
+    const adapter = this.getPrivateAdapter(account.venue);
+    if (adapter.venue === "juplend") {
       throw this.createError(
-        "EXCHANGE_NOT_SUPPORTED",
-        `Exchange is not supported yet: ${account.exchange}`,
-        { accountId, exchange: account.exchange },
+        "VENUE_NOT_SUPPORTED",
+        `Venue does not support private order commands: ${account.venue}`,
+        { accountId, venue: account.venue },
       );
     }
 
-    if (!hasPrivateCredentials(account.credentials)) {
+    if (!hasPrivateCredentials(account.credentials, account.venue)) {
       throw this.createError(
         "CREDENTIALS_MISSING",
         `Account credentials are required for private order commands: ${accountId}`,
-        { accountId, exchange: account.exchange },
+        { accountId, venue: account.venue },
       );
     }
 
     return account;
   }
+
+  private getPrivateAdapter(venue: Venue): PrivateUserDataAdapter {
+    const adapter = this.privateAdapters.get(venue);
+    if (!adapter) {
+      throw this.createError(
+        "VENUE_NOT_SUPPORTED",
+        `Venue is not supported yet: ${venue}`,
+        { venue },
+      );
+    }
+
+    return adapter;
+  }
 }

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/errors.ts

@@ -4,7 +4,7 @@ export type AcexErrorCode =
   | "ACCOUNT_NOT_FOUND"
   | "CLIENT_NOT_STARTED"
   | "CREDENTIALS_MISSING"
-  | "EXCHANGE_NOT_SUPPORTED"
+  | "VENUE_NOT_SUPPORTED"
   | "MARKET_CATALOG_LOAD_FAILED"
   | "MARKET_INACTIVE"
   | "MARKET_FUNDING_RATE_UNSUPPORTED"

package/src/internal/filters.ts

@@ -1,21 +1,21 @@
 import type {
   AccountEventFilter,
-  Exchange,
   HealthEvent,
   HealthEventFilter,
   MarketEventFilter,
   OrderEventFilter,
+  Venue,
 } from "../types/index.ts";
 
 export function matchesMarketFilter(
-  event: { exchange: Exchange; symbol: string },
+  event: { venue: Venue; symbol: string },
   filter?: MarketEventFilter,
 ): boolean {
   if (!filter) {
     return true;
   }
 
-  if (filter.exchange && event.exchange !== filter.exchange) {
+  if (filter.venue && event.venue !== filter.venue) {
     return false;
   }
 
@@ -27,7 +27,7 @@ export function matchesMarketFilter(
 }
 
 export function matchesAccountFilter(
-  event: { accountId: string; exchange: Exchange; symbol?: string },
+  event: { accountId: string; venue: Venue; symbol?: string },
   filter?: AccountEventFilter,
 ): boolean {
   if (!filter) {
@@ -38,7 +38,7 @@ export function matchesAccountFilter(
     return false;
   }
 
-  if (filter.exchange && event.exchange !== filter.exchange) {
+  if (filter.venue && event.venue !== filter.venue) {
     return false;
   }
 
@@ -50,7 +50,7 @@ export function matchesAccountFilter(
 }
 
 export function matchesOrderFilter(
-  event: { accountId: string; exchange: Exchange; symbol?: string },
+  event: { accountId: string; venue: Venue; symbol?: string },
   filter?: OrderEventFilter,
 ): boolean {
   if (!filter) {
@@ -61,7 +61,7 @@ export function matchesOrderFilter(
     return false;
   }
 
-  if (filter.exchange && event.exchange !== filter.exchange) {
+  if (filter.venue && event.venue !== filter.venue) {
     return false;
   }
 
@@ -95,8 +95,8 @@ export function matchesHealthFilter(
     }
   }
 
-  if (filter.exchange) {
-    if (!("exchange" in event) || event.exchange !== filter.exchange) {
+  if (filter.venue) {
+    if (!("venue" in event) || event.venue !== filter.venue) {
       return false;
     }
   }