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

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

@@ -1,283 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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

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

package/dist/core/client.d.ts

@@ -1,37 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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;