@imbingox/acex 0.1.0-beta.0

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

@@ -0,0 +1,283 @@
+import { createAsyncQueue } from "../../runtime/async-queue.js";
+export class FakeAsterAdapter {
+    exchange = "aster";
+    capabilities = {
+        publicWs: true,
+        privateWs: true,
+        l1BookStream: true,
+        fundingRateStream: true,
+        accountStream: true,
+        orderStream: true,
+        fetchMarketInfo: true,
+        fetchBalances: true,
+        fetchPositions: true,
+        fetchRisk: true,
+        fetchOpenOrders: true,
+        fetchMyTrades: true,
+        fetchOrderById: true,
+    };
+    #started = false;
+    #marketQueue = createAsyncQueue({ maxBufferSize: 100 });
+    #marketEventSink;
+    #internalErrorQueue = createAsyncQueue({ maxBufferSize: 10 });
+    #orderQueue = createAsyncQueue({ maxBufferSize: 100 });
+    #orderEventSink;
+    #orders = new Map();
+    #accountQueue = createAsyncQueue({ maxBufferSize: 100 });
+    #accountEventSink;
+    #accountBaselines = new Map();
+    async start() {
+        this.#started = true;
+    }
+    async stop() {
+        this.#started = false;
+        this.#marketQueue.close();
+        this.#internalErrorQueue.close();
+        this.#orderQueue.close();
+        this.#accountQueue.close();
+    }
+    async subscribeL1Book() { }
+    async subscribeFundingRate() { }
+    watchMarketEvents() {
+        return this.#marketQueue;
+    }
+    setMarketEventSink(sink) {
+        this.#marketEventSink = sink;
+    }
+    emitL1Book(event) {
+        this.#emitMarketEvent(event);
+    }
+    emitFundingRate(event) {
+        this.#emitMarketEvent(event);
+    }
+    emitMarketDisconnect(input) {
+        this.#emitMarketEvent({
+            type: "market.disconnected",
+            exchange: input.exchange,
+            symbol: input.symbol,
+            receivedAt: Date.now(),
+        });
+    }
+    emitMarketReconnect(input) {
+        this.#emitMarketEvent({
+            type: "market.reconnecting",
+            exchange: input.exchange,
+            symbol: input.symbol,
+            receivedAt: Date.now(),
+        });
+    }
+    watchInternalErrors() {
+        return this.#internalErrorQueue;
+    }
+    emitInternalError(error) {
+        this.#internalErrorQueue.push(error);
+    }
+    async subscribeOrders() { }
+    setAccountBaseline(accountId, baseline) {
+        this.#accountBaselines.set(accountId, baseline);
+    }
+    async fetchAccountBaseline(accountId) {
+        return (this.#accountBaselines.get(accountId) ?? {
+            balances: {},
+            positions: [],
+        });
+    }
+    watchAccountEvents() {
+        return this.#accountQueue;
+    }
+    setAccountEventSink(sink) {
+        this.#accountEventSink = sink;
+    }
+    emitBalanceUpdate(event) {
+        const nextEvent = {
+            type: "balance.updated",
+            ...event,
+        };
+        const baseline = this.#accountBaselines.get(event.accountId);
+        this.#accountBaselines.set(event.accountId, {
+            balances: {
+                ...(baseline?.balances ?? {}),
+                [event.asset]: event.snapshot,
+            },
+            positions: baseline?.positions ?? [],
+            ...(baseline?.risk === undefined ? {} : { risk: baseline.risk }),
+        });
+        if (this.#accountEventSink !== undefined) {
+            this.#accountEventSink(nextEvent);
+            return;
+        }
+        this.#accountQueue.push(nextEvent);
+    }
+    async fetchOpenOrdersBaseline(accountId) {
+        return [...this.#orders.values()].filter((order) => {
+            return order.accountId === accountId && order.status === "open";
+        });
+    }
+    watchOrderEvents() {
+        return this.#orderQueue;
+    }
+    setOrderEventSink(sink) {
+        this.#orderEventSink = sink;
+    }
+    async placeOrder(input) {
+        const receivedAt = Date.now();
+        const snapshot = {
+            ...input,
+            status: "open",
+            filled: "0",
+            seq: 1,
+            receivedAt,
+            updatedAt: receivedAt,
+        };
+        this.#orders.set(this.#orderKey(input.accountId, input.clientOrderId), snapshot);
+        this.#emitOrderEvent({
+            type: "order.updated",
+            accountId: input.accountId,
+            exchange: input.exchange,
+            receivedAt,
+            snapshot,
+        });
+        return {
+            ...(snapshot.clientOrderId === undefined ? {} : { clientOrderId: snapshot.clientOrderId }),
+            ...(snapshot.orderId === undefined ? {} : { orderId: snapshot.orderId }),
+            receivedAt,
+        };
+    }
+    async amendOrder(input) {
+        const orderKey = this.#resolveOrderKey(input.accountId, input);
+        if (orderKey === undefined) {
+            return {
+                ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+                ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+                receivedAt: Date.now(),
+            };
+        }
+        const current = this.#orders.get(orderKey);
+        if (current === undefined) {
+            return {
+                ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+                ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+                receivedAt: Date.now(),
+            };
+        }
+        const amended = {
+            ...current,
+            updatedAt: Date.now(),
+            ...(input.newPrice === undefined ? {} : { price: input.newPrice }),
+        };
+        this.#orders.set(orderKey, amended);
+        this.#emitOrderEvent({
+            type: "order.updated",
+            accountId: input.accountId,
+            exchange: input.exchange,
+            receivedAt: amended.updatedAt,
+            snapshot: amended,
+        });
+        return {
+            ...(amended.clientOrderId === undefined ? {} : { clientOrderId: amended.clientOrderId }),
+            ...(amended.orderId === undefined ? {} : { orderId: amended.orderId }),
+            receivedAt: amended.updatedAt,
+        };
+    }
+    async cancelOrder(input) {
+        const orderKey = this.#resolveOrderKey(input.accountId, input);
+        if (orderKey === undefined) {
+            return {
+                ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+                ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+                receivedAt: Date.now(),
+            };
+        }
+        const current = this.#orders.get(orderKey);
+        if (current === undefined) {
+            return {
+                ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+                ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+                receivedAt: Date.now(),
+            };
+        }
+        const canceled = {
+            ...current,
+            status: "canceled",
+            updatedAt: Date.now(),
+        };
+        this.#orders.set(orderKey, canceled);
+        this.#emitOrderEvent({
+            type: "order.canceled",
+            accountId: input.accountId,
+            exchange: input.exchange,
+            receivedAt: canceled.updatedAt,
+            snapshot: canceled,
+        });
+        return {
+            ...(canceled.clientOrderId === undefined ? {} : { clientOrderId: canceled.clientOrderId }),
+            ...(canceled.orderId === undefined ? {} : { orderId: canceled.orderId }),
+            receivedAt: canceled.updatedAt,
+        };
+    }
+    async cancelAllOrders(input) {
+        let canceledCount = 0;
+        for (const [key, snapshot] of this.#orders.entries()) {
+            if (!key.startsWith(`${input.accountId}:`) || snapshot.status === "canceled") {
+                continue;
+            }
+            canceledCount += 1;
+            const canceled = {
+                ...snapshot,
+                status: "canceled",
+                updatedAt: Date.now(),
+            };
+            this.#orders.set(key, canceled);
+            this.#emitOrderEvent({
+                type: "order.canceled",
+                accountId: input.accountId,
+                exchange: input.exchange,
+                receivedAt: canceled.updatedAt,
+                snapshot: canceled,
+            });
+        }
+        return {
+            accountId: input.accountId,
+            exchange: input.exchange,
+            canceledCount,
+        };
+    }
+    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);
+    }
+    #emitOrderEvent(event) {
+        if (this.#orderEventSink !== undefined) {
+            this.#orderEventSink(event);
+            return;
+        }
+        this.#orderQueue.push(event);
+    }
+    #orderKey(accountId, clientOrderId) {
+        return `${accountId}:${clientOrderId}`;
+    }
+    #resolveOrderKey(accountId, locator) {
+        if (locator.clientOrderId !== undefined) {
+            return this.#orderKey(accountId, locator.clientOrderId);
+        }
+        if (locator.orderId === undefined) {
+            return undefined;
+        }
+        for (const [key, order] of this.#orders.entries()) {
+            if (key.startsWith(`${accountId}:`) && order.orderId === locator.orderId) {
+                return key;
+            }
+        }
+        return undefined;
+    }
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,210 @@
+export interface ExchangeCapabilities {
+    publicWs: boolean;
+    privateWs: boolean;
+    l1BookStream: boolean;
+    fundingRateStream: boolean;
+    accountStream: boolean;
+    orderStream: boolean;
+    fetchMarketInfo: boolean;
+    fetchBalances: boolean;
+    fetchPositions: boolean;
+    fetchRisk: boolean;
+    fetchOpenOrders: boolean;
+    fetchMyTrades: boolean;
+    fetchOrderById: boolean;
+}
+export type NormalizedMarketEvent = {
+    type: "l1_book.updated";
+    exchange: string;
+    symbol: string;
+    bidPrice: string;
+    bidSize: string;
+    askPrice: string;
+    askSize: string;
+    exchangeTs?: number;
+    receivedAt: number;
+} | {
+    type: "market.disconnected";
+    exchange: string;
+    symbol: string;
+    receivedAt: number;
+} | {
+    type: "market.reconnecting";
+    exchange: string;
+    symbol: string;
+    receivedAt: number;
+} | {
+    type: "funding_rate.updated";
+    exchange: string;
+    symbol: string;
+    fundingRate: string;
+    exchangeTs?: number;
+    receivedAt: number;
+};
+export type NormalizedOrderEvent = {
+    type: "order.updated";
+    accountId: string;
+    exchange: string;
+    receivedAt: number;
+    snapshot: {
+        accountId: string;
+        exchange: string;
+        symbol: string;
+        side: "buy" | "sell";
+        type: string;
+        status: string;
+        amount: string;
+        filled: string;
+        price?: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+        orderId?: string;
+        clientOrderId?: string;
+    };
+} | {
+    type: "order.canceled";
+    accountId: string;
+    exchange: string;
+    receivedAt: number;
+    snapshot: {
+        accountId: string;
+        exchange: string;
+        symbol: string;
+        side: "buy" | "sell";
+        type: string;
+        status: string;
+        amount: string;
+        filled: string;
+        price?: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+        orderId?: string;
+        clientOrderId?: string;
+    };
+};
+export interface AdapterAccountBaseline {
+    balances: Record<string, {
+        accountId: string;
+        exchange: string;
+        asset: string;
+        free: string;
+        used: string;
+        total: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+    }>;
+    positions: Array<{
+        accountId: string;
+        exchange: string;
+        symbol: string;
+        side: string;
+        size: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+    }>;
+    risk?: {
+        accountId: string;
+        exchange: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+        equity: string;
+    };
+}
+export type NormalizedAccountEvent = {
+    type: "balance.updated";
+    accountId: string;
+    exchange: string;
+    asset: string;
+    snapshot: {
+        accountId: string;
+        exchange: string;
+        asset: string;
+        free: string;
+        used: string;
+        total: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+    };
+};
+export interface ExchangeAdapter {
+    readonly exchange: string;
+    readonly capabilities: ExchangeCapabilities;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    subscribeL1Book(input: {
+        exchange: string;
+        symbol: string;
+    }): Promise<void>;
+    subscribeFundingRate(input: {
+        exchange: string;
+        symbol: string;
+    }): Promise<void>;
+    watchMarketEvents(): AsyncIterable<NormalizedMarketEvent>;
+    setMarketEventSink?(sink: ((event: NormalizedMarketEvent) => void) | undefined): void;
+    watchInternalErrors(): AsyncIterable<Error>;
+    subscribeOrders(input: {
+        accountId: string;
+    }): Promise<void>;
+    fetchOpenOrdersBaseline(accountId: string): Promise<NormalizedOrderEvent["snapshot"][]>;
+    watchOrderEvents(): AsyncIterable<NormalizedOrderEvent>;
+    setOrderEventSink?(sink: ((event: NormalizedOrderEvent) => void) | undefined): void;
+    fetchAccountBaseline(accountId: string): Promise<AdapterAccountBaseline>;
+    watchAccountEvents(): AsyncIterable<NormalizedAccountEvent>;
+    setAccountEventSink?(sink: ((event: NormalizedAccountEvent) => void) | undefined): void;
+    placeOrder(input: {
+        accountId: string;
+        exchange: string;
+        symbol: string;
+        side: "buy" | "sell";
+        amount: string;
+        clientOrderId: string;
+        type: string;
+        price?: string;
+        reduceOnly?: boolean;
+    }): Promise<{
+        clientOrderId?: string;
+        orderId?: string;
+        receivedAt: number;
+    }>;
+    amendOrder(input: {
+        accountId: string;
+        exchange: string;
+        clientOrderId?: string;
+        orderId?: string;
+        symbol?: string;
+        newPrice?: string;
+    }): Promise<{
+        clientOrderId?: string;
+        orderId?: string;
+        receivedAt: number;
+    }>;
+    cancelOrder(input: {
+        accountId: string;
+        exchange: string;
+        clientOrderId?: string;
+        orderId?: string;
+    }): Promise<{
+        clientOrderId?: string;
+        orderId?: string;
+        receivedAt: number;
+    }>;
+    cancelAllOrders(input: {
+        accountId: string;
+        exchange: string;
+    }): Promise<{
+        accountId: string;
+        exchange: string;
+        canceledCount: number;
+    }>;
+    getHealth(): {
+        exchange: string;
+        status: string;
+        wsConnected: boolean;
+    };
+}

package/dist/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/client.d.ts

@@ -0,0 +1,37 @@
+import type { ExchangeAdapter } from "../adapters/types.js";
+import { type AccountManager } from "../managers/account-manager.js";
+import { type MarketManager } from "../managers/market-manager.js";
+import { type OrderManager } from "../managers/order-manager.js";
+import { createHealthStore } from "../store/health-store.js";
+import type { ClientStatus, Exchange } from "../types/public.js";
+import { createRuntime } from "./runtime.js";
+export interface RegisterAccountInput {
+    accountId: string;
+    exchange: Exchange;
+    credentials: {
+        apiKey: string;
+        secret: string;
+        password?: string;
+    };
+}
+interface InternalCreateClientOptions {
+    adapter?: ExchangeAdapter;
+}
+export interface AcexClient {
+    readonly market: MarketManager;
+    readonly account: AccountManager;
+    readonly order: OrderManager;
+    getStatus(): ClientStatus;
+    getHealth(): ReturnType<ReturnType<typeof createHealthStore>["snapshot"]>;
+    registerAccount(input: RegisterAccountInput): Promise<{
+        accountId: string;
+        exchange: Exchange;
+    }>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    watchErrors(): ReturnType<ReturnType<typeof createRuntime>["watchErrors"]>;
+    watchHealth(): ReturnType<ReturnType<typeof createRuntime>["watchHealth"]>;
+}
+export declare function createInternalClient(options?: InternalCreateClientOptions): AcexClient;
+export declare function createClient(): AcexClient;
+export {};

package/dist/core/client.js

@@ -0,0 +1,45 @@
+import { createIdleAccountManager } from "../managers/account-manager.js";
+import { createIdleMarketManager } from "../managers/market-manager.js";
+import { createIdleOrderManager } from "../managers/order-manager.js";
+import { createHealthStore } from "../store/health-store.js";
+import { createRuntime } from "./runtime.js";
+async function* emptyAsyncIterable() { }
+export function createInternalClient(options = {}) {
+    let status = "idle";
+    const healthStore = createHealthStore();
+    const accounts = new Map();
+    const adapter = options.adapter;
+    const runtime = adapter === undefined ? undefined : createRuntime(adapter);
+    return {
+        market: runtime?.market ?? createIdleMarketManager(),
+        account: runtime?.account ?? createIdleAccountManager(),
+        order: runtime?.order ?? createIdleOrderManager(),
+        getStatus: () => status,
+        getHealth: () => healthStore.snapshot(),
+        watchErrors: () => runtime?.watchErrors() ?? emptyAsyncIterable(),
+        watchHealth: () => runtime?.watchHealth() ?? emptyAsyncIterable(),
+        async registerAccount(input) {
+            accounts.set(input.accountId, input);
+            return {
+                accountId: input.accountId,
+                exchange: input.exchange,
+            };
+        },
+        async start() {
+            status = "running";
+            healthStore.setClientStatus("running");
+            if (adapter !== undefined) {
+                await adapter.start();
+                healthStore.setExchangeHealth(adapter.exchange, adapter.getHealth());
+            }
+        },
+        async stop() {
+            status = "stopped";
+            healthStore.setClientStatus("stopped");
+            await adapter?.stop();
+        },
+    };
+}
+export function createClient() {
+    return createInternalClient();
+}

package/dist/core/recovery.d.ts

@@ -0,0 +1,22 @@
+export declare function markMarketStale(input: {
+    exchange: string;
+    symbol: string;
+    receivedAt: number;
+}): {
+    exchange: string;
+    symbol: string;
+    freshness: "stale";
+    staleSince: number;
+    reason: "ws_disconnected";
+};
+export declare function markMarketReconciling(input: {
+    exchange: string;
+    symbol: string;
+    receivedAt: number;
+}): {
+    exchange: string;
+    symbol: string;
+    freshness: "reconciling";
+    lastStreamReceivedAt: number;
+    reason: "reconciling";
+};

package/dist/core/recovery.js

@@ -0,0 +1,18 @@
+export function markMarketStale(input) {
+    return {
+        exchange: input.exchange,
+        symbol: input.symbol,
+        freshness: "stale",
+        staleSince: input.receivedAt,
+        reason: "ws_disconnected",
+    };
+}
+export function markMarketReconciling(input) {
+    return {
+        exchange: input.exchange,
+        symbol: input.symbol,
+        freshness: "reconciling",
+        lastStreamReceivedAt: input.receivedAt,
+        reason: "reconciling",
+    };
+}

package/dist/core/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { ExchangeAdapter } from "../adapters/types.js";
+import { type AccountManagerRuntime } from "../managers/account-manager.js";
+import { createMarketManager } from "../managers/market-manager.js";
+import { createOrderManager } from "../managers/order-manager.js";
+import { markMarketReconciling, markMarketStale } from "./recovery.js";
+export interface HealthEvent {
+    type: "market.status_changed";
+    exchange: string;
+    symbol: string;
+    status: ReturnType<typeof markMarketStale> | ReturnType<typeof markMarketReconciling>;
+    ts: number;
+}
+export interface RuntimeErrorEvent {
+    source: "adapter";
+    exchange: string;
+    error: Error;
+    ts: number;
+}
+export interface Runtime {
+    account: AccountManagerRuntime;
+    market: ReturnType<typeof createMarketManager>;
+    order: ReturnType<typeof createOrderManager>;
+    watchErrors(): AsyncIterable<RuntimeErrorEvent>;
+    watchHealth(): AsyncIterable<HealthEvent>;
+}
+export declare function createRuntime(adapter: ExchangeAdapter): Runtime;