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

package/src/types/order.ts

@@ -0,0 +1,142 @@
+import type { PositionSide } from "./account.ts";
+import type {
+  Exchange,
+  PrivateRuntimeStatus,
+  SubscriptionActivity,
+} from "./shared.ts";
+
+export interface OrderDataStatus {
+  accountId: string;
+  exchange: Exchange;
+  activity: SubscriptionActivity;
+  ready: boolean;
+  runtimeStatus?: PrivateRuntimeStatus;
+  lastReceivedAt?: number;
+  lastReadyAt?: number;
+  inactiveSince?: number;
+  reason?:
+    | "credentials_missing"
+    | "auth_failed"
+    | "ws_disconnected"
+    | "heartbeat_timeout"
+    | "reconciling";
+}
+
+export interface OrderStatusChangedEvent {
+  type: "order.status_changed";
+  accountId: string;
+  exchange: Exchange;
+  status: OrderDataStatus;
+  ts: number;
+}
+
+export type OrderSide = "buy" | "sell";
+
+export type OrderStatus =
+  | "open"
+  | "partially_filled"
+  | "filled"
+  | "canceled"
+  | "rejected"
+  | "expired";
+
+export interface SubscribeOrdersInput {
+  accountId: string;
+}
+
+export interface UnsubscribeOrdersInput {
+  accountId: string;
+}
+
+export interface GetOrderInput {
+  accountId: string;
+  orderId?: string;
+  clientOrderId?: string;
+}
+
+export interface OrderEventFilter {
+  accountId?: string;
+  exchange?: Exchange;
+  symbol?: string;
+}
+
+export interface OrderSnapshot {
+  accountId: string;
+  exchange: Exchange;
+  orderId?: string;
+  clientOrderId?: string;
+  symbol: string;
+  side: OrderSide;
+  type: string;
+  status: OrderStatus;
+  price?: string;
+  triggerPrice?: string;
+  amount: string;
+  filled: string;
+  remaining?: string;
+  reduceOnly?: boolean;
+  positionSide?: PositionSide;
+  avgFillPrice?: string;
+  exchangeTs?: number;
+  receivedAt: number;
+  updatedAt: number;
+  seq: number;
+}
+
+export interface OrderEventBase {
+  accountId: string;
+  exchange: Exchange;
+  symbol: string;
+  ts: number;
+}
+
+export interface OrderUpdatedEvent extends OrderEventBase {
+  type: "order.updated";
+  snapshot: OrderSnapshot;
+}
+
+export interface OrderFilledEvent extends OrderEventBase {
+  type: "order.filled";
+  snapshot: OrderSnapshot;
+}
+
+export interface OrderCanceledEvent extends OrderEventBase {
+  type: "order.canceled";
+  snapshot: OrderSnapshot;
+}
+
+export interface OrderRejectedEvent extends OrderEventBase {
+  type: "order.rejected";
+  snapshot: OrderSnapshot;
+}
+
+export interface OrderSnapshotReplacedEvent {
+  type: "order.snapshot_replaced";
+  accountId: string;
+  exchange: Exchange;
+  snapshot: OrderSnapshot[];
+  ts: number;
+}
+
+export type OrderEvent =
+  | OrderUpdatedEvent
+  | OrderFilledEvent
+  | OrderCanceledEvent
+  | OrderRejectedEvent
+  | OrderSnapshotReplacedEvent;
+
+export interface OrderEventStreams {
+  updates(filter?: OrderEventFilter): AsyncIterable<OrderEvent>;
+  status(filter?: OrderEventFilter): AsyncIterable<OrderStatusChangedEvent>;
+}
+
+export interface OrderManager {
+  readonly events: OrderEventStreams;
+
+  subscribeOrders(input: SubscribeOrdersInput): Promise<void>;
+  unsubscribeOrders(input: UnsubscribeOrdersInput): Promise<void>;
+
+  getOrder(input: GetOrderInput): OrderSnapshot | undefined;
+  getOpenOrders(accountId: string, symbol?: string): OrderSnapshot[];
+  getOrderStatus(accountId: string): OrderDataStatus | undefined;
+}

package/src/types/shared.ts

@@ -0,0 +1,78 @@
+export const SUPPORTED_EXCHANGES = ["binance", "okx", "bybit", "gate"] as const;
+
+export type Exchange = (typeof SUPPORTED_EXCHANGES)[number];
+
+export type ClientStatus =
+  | "idle"
+  | "starting"
+  | "running"
+  | "stopping"
+  | "stopped";
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface Logger {
+  debug(msg: string, context?: Record<string, unknown>): void;
+  info(msg: string, context?: Record<string, unknown>): void;
+  warn(msg: string, context?: Record<string, unknown>): void;
+  error(msg: string, context?: Record<string, unknown>): void;
+}
+
+export interface MarketRuntimeOptions {
+  l1InitialMessageTimeoutMs?: number;
+  l1StaleAfterMs?: number;
+  l1ReconnectDelayMs?: number;
+  l1ReconnectMaxDelayMs?: number;
+}
+
+export interface CreateClientOptions {
+  sandbox?: boolean;
+  logger?: Logger;
+  logLevel?: LogLevel;
+  market?: MarketRuntimeOptions;
+}
+
+export interface AccountCredentials {
+  apiKey?: string;
+  secret?: string;
+  password?: string;
+  extra?: Record<string, string>;
+}
+
+export interface RegisterAccountInput {
+  accountId: string;
+  exchange: Exchange;
+  credentials?: AccountCredentials;
+  options?: Record<string, unknown>;
+}
+
+export interface RegisterAccountResult {
+  accountId: string;
+  exchange: Exchange;
+}
+
+export interface StopOptions {
+  graceful?: boolean;
+  timeoutMs?: number;
+}
+
+export interface AcexInternalError {
+  source: "client" | "market" | "account" | "order" | "adapter" | "runtime";
+  exchange?: Exchange;
+  accountId?: string;
+  symbol?: string;
+  error: Error;
+  ts: number;
+}
+
+export type SubscriptionActivity = "active" | "inactive";
+
+export type MarketFreshness = "fresh" | "stale" | "reconciling";
+
+export type PrivateRuntimeStatus =
+  | "bootstrap_pending"
+  | "healthy"
+  | "degraded"
+  | "reconnecting"
+  | "reconciling"
+  | "stopped";

package/dist/adapters/ccxt/aster-ccxt-adapter.d.ts

@@ -1,157 +0,0 @@
-import type { AdapterAccountBaseline, ExchangeCapabilities, NormalizedAccountEvent, NormalizedMarketEvent, NormalizedOrderEvent } from "../types.js";
-interface CcxtTickerLike {
-    symbol: string;
-    bid: number | string | undefined;
-    bidVolume: number | string | undefined;
-    ask: number | string | undefined;
-    askVolume: number | string | undefined;
-    timestamp?: number;
-}
-interface CcxtMarketLike {
-    symbol: string;
-    base: string;
-    quote: string;
-    type: string;
-    precision: {
-        price: number;
-        amount: number;
-    };
-    active: boolean;
-}
-interface CcxtOrderLike {
-    id?: string;
-    clientOrderId?: string;
-    symbol?: string;
-    side?: string;
-    type?: string;
-    status?: string;
-    amount?: number | string;
-    filled?: number | string;
-    price?: number | string;
-    timestamp?: number;
-}
-interface CcxtBalanceLike {
-    free?: Record<string, number | string | undefined>;
-    used?: Record<string, number | string | undefined>;
-    total?: Record<string, number | string | undefined>;
-}
-interface CcxtExchangeLike {
-    watchTicker(symbol: string): Promise<CcxtTickerLike>;
-    fetchMarkets(): Promise<CcxtMarketLike[]>;
-    fetchBalance(params?: Record<string, unknown>): Promise<CcxtBalanceLike>;
-    fetchOpenOrders(symbol?: string, since?: number, limit?: number, params?: Record<string, unknown>): Promise<CcxtOrderLike[]>;
-    createOrder(symbol: string, type: string, side: "buy" | "sell", amount: number, price?: number, params?: Record<string, unknown>): Promise<CcxtOrderLike>;
-    cancelOrder(id?: string, symbol?: string, params?: Record<string, unknown>): Promise<CcxtOrderLike>;
-}
-export interface CreateCcxtAsterAdapterInput {
-    exchange: CcxtExchangeLike;
-}
-export declare class CcxtAsterAdapter {
-    #private;
-    readonly exchange = "aster";
-    readonly capabilities: ExchangeCapabilities;
-    constructor(input: CreateCcxtAsterAdapterInput);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    subscribeL1Book(input: {
-        exchange: string;
-        symbol: string;
-    }): Promise<void>;
-    subscribeFundingRate(): Promise<void>;
-    watchMarketEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedMarketEvent>;
-    setMarketEventSink(sink: ((event: NormalizedMarketEvent) => void) | undefined): void;
-    watchInternalErrors(): import("../../runtime/async-queue.js").AsyncQueue<Error>;
-    subscribeOrders(): Promise<void>;
-    watchOrderEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedOrderEvent>;
-    setOrderEventSink(sink: ((event: NormalizedOrderEvent) => void) | undefined): void;
-    watchAccountEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedAccountEvent>;
-    setAccountEventSink(sink: ((event: NormalizedAccountEvent) => void) | undefined): void;
-    mapTickerToL1(symbol: string): Promise<{
-        receivedAt: number;
-        exchangeTs?: number;
-        exchange: string;
-        symbol: string;
-        bidPrice: string;
-        bidSize: string;
-        askPrice: string;
-        askSize: string;
-    }>;
-    fetchMarketInfo(): Promise<{
-        exchange: string;
-        symbol: string;
-        baseAsset: string;
-        quoteAsset: string;
-        marketType: string;
-        pricePrecision: number;
-        amountPrecision: number;
-        active: boolean;
-    }[]>;
-    fetchAccountBaseline(accountId: string): Promise<AdapterAccountBaseline>;
-    fetchOpenOrdersBaseline(accountId: string): Promise<{
-        clientOrderId?: string;
-        orderId?: string;
-        seq: number;
-        receivedAt: number;
-        updatedAt: number;
-        price?: string;
-        accountId: string;
-        exchange: string;
-        symbol: string;
-        side: "buy" | "sell";
-        type: string;
-        status: string;
-        amount: string;
-        filled: string;
-    }[]>;
-    placeOrder(input: {
-        accountId: string;
-        exchange: string;
-        symbol: string;
-        side: "buy" | "sell";
-        amount: string;
-        clientOrderId: string;
-        type: string;
-        price?: string;
-        reduceOnly?: boolean;
-    }): Promise<{
-        receivedAt: number;
-        orderId?: string;
-        clientOrderId: string;
-    }>;
-    amendOrder(input: {
-        accountId: string;
-        exchange: string;
-        clientOrderId?: string;
-        orderId?: string;
-        symbol?: string;
-        newPrice?: string;
-    }): Promise<{
-        receivedAt: number;
-        orderId?: string;
-        clientOrderId?: string;
-    }>;
-    cancelOrder(input: {
-        accountId: string;
-        exchange: string;
-        clientOrderId?: string;
-        orderId?: string;
-    }): Promise<{
-        receivedAt: number;
-        orderId?: string;
-        clientOrderId?: string;
-    }>;
-    cancelAllOrders(input: {
-        accountId: string;
-        exchange: string;
-    }): Promise<{
-        accountId: string;
-        exchange: string;
-        canceledCount: number;
-    }>;
-    getHealth(): {
-        exchange: string;
-        status: string;
-        wsConnected: boolean;
-    };
-}
-export {};

package/dist/adapters/ccxt/aster-ccxt-adapter.js

@@ -1,272 +0,0 @@
-import { createAsyncQueue } from "../../runtime/async-queue.js";
-export class CcxtAsterAdapter {
-    exchange = "aster";
-    capabilities = {
-        publicWs: true,
-        privateWs: true,
-        l1BookStream: true,
-        fundingRateStream: false,
-        accountStream: true,
-        orderStream: true,
-        fetchMarketInfo: true,
-        fetchBalances: true,
-        fetchPositions: false,
-        fetchRisk: false,
-        fetchOpenOrders: true,
-        fetchMyTrades: false,
-        fetchOrderById: false,
-    };
-    #exchange;
-    #started = false;
-    #marketQueue = createAsyncQueue({ maxBufferSize: 100 });
-    #marketEventSink;
-    #internalErrorQueue = createAsyncQueue({ maxBufferSize: 20 });
-    #orderQueue = createAsyncQueue({ maxBufferSize: 100 });
-    #orderEventSink;
-    #accountQueue = createAsyncQueue({ maxBufferSize: 100 });
-    #accountEventSink;
-    constructor(input) {
-        this.#exchange = input.exchange;
-    }
-    async start() {
-        this.#started = true;
-    }
-    async stop() {
-        this.#started = false;
-        this.#marketQueue.close();
-        this.#internalErrorQueue.close();
-        this.#orderQueue.close();
-        this.#accountQueue.close();
-    }
-    async subscribeL1Book(input) {
-        try {
-            const snapshot = await this.mapTickerToL1(input.symbol);
-            this.#emitMarketEvent({
-                type: "l1_book.updated",
-                exchange: snapshot.exchange,
-                symbol: snapshot.symbol,
-                bidPrice: snapshot.bidPrice,
-                bidSize: snapshot.bidSize,
-                askPrice: snapshot.askPrice,
-                askSize: snapshot.askSize,
-                ...(snapshot.exchangeTs === undefined ? {} : { exchangeTs: snapshot.exchangeTs }),
-                receivedAt: snapshot.receivedAt,
-            });
-        }
-        catch (error) {
-            this.#emitInternalError(asError(error));
-            throw error;
-        }
-    }
-    async subscribeFundingRate() { }
-    watchMarketEvents() {
-        return this.#marketQueue;
-    }
-    setMarketEventSink(sink) {
-        this.#marketEventSink = sink;
-    }
-    watchInternalErrors() {
-        return this.#internalErrorQueue;
-    }
-    async subscribeOrders() { }
-    watchOrderEvents() {
-        return this.#orderQueue;
-    }
-    setOrderEventSink(sink) {
-        this.#orderEventSink = sink;
-    }
-    watchAccountEvents() {
-        return this.#accountQueue;
-    }
-    setAccountEventSink(sink) {
-        this.#accountEventSink = sink;
-    }
-    async mapTickerToL1(symbol) {
-        const ticker = await this.#exchange.watchTicker(symbol);
-        if (ticker.bid === undefined ||
-            ticker.bidVolume === undefined ||
-            ticker.ask === undefined ||
-            ticker.askVolume === undefined) {
-            throw new Error("missing required ticker fields");
-        }
-        return {
-            exchange: this.exchange,
-            symbol: ticker.symbol,
-            bidPrice: String(ticker.bid),
-            bidSize: String(ticker.bidVolume),
-            askPrice: String(ticker.ask),
-            askSize: String(ticker.askVolume),
-            ...(ticker.timestamp === undefined ? {} : { exchangeTs: ticker.timestamp }),
-            receivedAt: Date.now(),
-        };
-    }
-    async fetchMarketInfo() {
-        const markets = await this.#exchange.fetchMarkets();
-        return markets.map((market) => {
-            return {
-                exchange: this.exchange,
-                symbol: market.symbol,
-                baseAsset: market.base,
-                quoteAsset: market.quote,
-                marketType: market.type,
-                pricePrecision: market.precision.price,
-                amountPrecision: market.precision.amount,
-                active: market.active,
-            };
-        });
-    }
-    async fetchAccountBaseline(accountId) {
-        const balance = await this.#exchange.fetchBalance();
-        const assets = new Set([
-            ...Object.keys(balance.free ?? {}),
-            ...Object.keys(balance.used ?? {}),
-            ...Object.keys(balance.total ?? {}),
-        ]);
-        const now = Date.now();
-        const balances = Object.fromEntries([...assets].map((asset) => {
-            return [
-                asset,
-                {
-                    accountId,
-                    exchange: this.exchange,
-                    asset,
-                    free: valueToString(balance.free?.[asset]),
-                    used: valueToString(balance.used?.[asset]),
-                    total: valueToString(balance.total?.[asset]),
-                    seq: 0,
-                    receivedAt: now,
-                    updatedAt: now,
-                },
-            ];
-        }));
-        return {
-            balances,
-            positions: [],
-        };
-    }
-    async fetchOpenOrdersBaseline(accountId) {
-        const orders = await this.#exchange.fetchOpenOrders();
-        const now = Date.now();
-        return orders.map((order) => {
-            const symbol = requiredString(order.symbol, "symbol");
-            const side = requiredOrderSide(order.side);
-            const type = requiredString(order.type, "type");
-            const status = requiredString(order.status, "status");
-            const amount = valueToRequiredString(order.amount, "amount");
-            const filled = valueToRequiredString(order.filled, "filled");
-            const updatedAt = order.timestamp ?? now;
-            return {
-                accountId,
-                exchange: this.exchange,
-                symbol,
-                side,
-                type,
-                status,
-                amount,
-                filled,
-                ...(order.price === undefined ? {} : { price: String(order.price) }),
-                seq: 0,
-                receivedAt: now,
-                updatedAt,
-                ...(order.id === undefined ? {} : { orderId: order.id }),
-                ...(order.clientOrderId === undefined ? {} : { clientOrderId: order.clientOrderId }),
-            };
-        });
-    }
-    async placeOrder(input) {
-        const amount = parseFiniteNumber(input.amount, "amount");
-        const price = input.price === undefined ? undefined : parseFiniteNumber(input.price, "price");
-        const order = await this.#exchange.createOrder(input.symbol, input.type, input.side, amount, price, {
-            clientOrderId: input.clientOrderId,
-        });
-        return {
-            ...(order.clientOrderId === undefined
-                ? { clientOrderId: input.clientOrderId }
-                : { clientOrderId: order.clientOrderId }),
-            ...(order.id === undefined ? {} : { orderId: order.id }),
-            receivedAt: Date.now(),
-        };
-    }
-    async amendOrder(input) {
-        return {
-            ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
-            ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
-            receivedAt: Date.now(),
-        };
-    }
-    async cancelOrder(input) {
-        if (input.orderId === undefined && input.clientOrderId === undefined) {
-            return { receivedAt: Date.now() };
-        }
-        const order = await this.#exchange.cancelOrder(input.orderId, undefined, {
-            ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
-        });
-        return {
-            ...(order.clientOrderId === undefined
-                ? input.clientOrderId === undefined
-                    ? {}
-                    : { clientOrderId: input.clientOrderId }
-                : { clientOrderId: order.clientOrderId }),
-            ...(order.id === undefined ? {} : { orderId: order.id }),
-            receivedAt: Date.now(),
-        };
-    }
-    async cancelAllOrders(input) {
-        return {
-            accountId: input.accountId,
-            exchange: input.exchange,
-            canceledCount: 0,
-        };
-    }
-    getHealth() {
-        return {
-            exchange: this.exchange,
-            status: this.#started ? "healthy" : "idle",
-            wsConnected: this.#started,
-        };
-    }
-    #emitMarketEvent(event) {
-        if (this.#marketEventSink !== undefined) {
-            this.#marketEventSink(event);
-            return;
-        }
-        this.#marketQueue.push(event);
-    }
-    #emitInternalError(error) {
-        this.#internalErrorQueue.push(error);
-    }
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}
-function requiredString(value, field) {
-    if (value === undefined || value.trim().length === 0) {
-        throw new Error(`missing required order fields: ${field}`);
-    }
-    return value;
-}
-function requiredOrderSide(value) {
-    if (value !== "buy" && value !== "sell") {
-        throw new Error("missing required order fields: side");
-    }
-    return value;
-}
-function valueToRequiredString(value, field) {
-    if (value === undefined) {
-        throw new Error(`missing required order fields: ${field}`);
-    }
-    return String(value);
-}
-function valueToString(value) {
-    return value === undefined ? "0" : String(value);
-}
-function parseFiniteNumber(value, field) {
-    if (value.trim().length === 0) {
-        throw new Error(`invalid order ${field}`);
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed)) {
-        throw new Error(`invalid order ${field}`);
-    }
-    return parsed;
-}