@imbingox/acex 0.1.0 → 0.3.0-beta.0

package/dist/core/client.js

@@ -1,403 +0,0 @@
-import { BinanceCompositeAdapter } from "../adapters/binance/composite-adapter.js";
-import { BinanceNativeMarketAdapter } from "../adapters/binance/native-market-adapter.js";
-import { CcxtBinanceUsdMAdapter } from "../adapters/ccxt/binance-usdm-ccxt-adapter.js";
-import { createBinanceUsdmExchange, } from "../adapters/ccxt/binance-usdm-exchange.js";
-import { createAcexError, isAcexError } from "../errors/acex-error.js";
-import { createIdleAccountManager } from "../managers/account-manager.js";
-import { createIdleMarketManager } from "../managers/market-manager.js";
-import { createIdleOrderManager } from "../managers/order-manager.js";
-import { createAsyncQueue } from "../runtime/async-queue.js";
-import { createHealthStore } from "../store/health-store.js";
-import { IMPLEMENTED_EXCHANGES } from "../types/public.js";
-import { createRuntime } from "./runtime.js";
-const PUBLIC_EXCHANGE = IMPLEMENTED_EXCHANGES[0];
-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 createPublicClient(options = {}, dependencies = {}) {
-    const idleMarket = createIdleMarketManager();
-    const idleAccount = createIdleAccountManager();
-    const idleOrder = createIdleOrderManager();
-    const accountEvents = createAsyncQueue({ maxBufferSize: 100 });
-    const errors = createAsyncQueue({ maxBufferSize: 100 });
-    const healthStore = createHealthStore();
-    const healthEvents = createAsyncQueue({ maxBufferSize: 100 });
-    const accounts = new Map();
-    let status = "idle";
-    let activeClient;
-    let activeAdapter;
-    const market = {
-        async subscribeL1Book(input) {
-            assertSupportedExchange(input.exchange);
-            const client = await requireStartedClient();
-            await client.market.subscribeL1Book(input);
-            syncHealth();
-        },
-        async subscribeFundingRate(input) {
-            assertSupportedExchange(input.exchange);
-            const client = await requireStartedClient();
-            await client.market.subscribeFundingRate(input);
-            syncHealth();
-        },
-        getL1Book(key) {
-            return getCurrentClient().market.getL1Book(key);
-        },
-        getFundingRate(key) {
-            return getCurrentClient().market.getFundingRate(key);
-        },
-        getMarketSnapshot(key) {
-            return getCurrentClient().market.getMarketSnapshot(key);
-        },
-        getMarketStatus(key) {
-            return getCurrentClient().market.getMarketStatus(key);
-        },
-    };
-    const account = {
-        async subscribeAccount(input) {
-            getRegisteredAccount(input.accountId);
-            const client = await requireStartedClient();
-            await client.account.subscribeAccount(input);
-            syncHealth();
-        },
-        getBalance(accountId, asset) {
-            return getCurrentClient().account.getBalance(accountId, asset);
-        },
-        getBalances(accountId) {
-            return getCurrentClient().account.getBalances(accountId);
-        },
-        getPosition(input) {
-            return getCurrentClient().account.getPosition(input);
-        },
-        getPositions(accountId) {
-            return getCurrentClient().account.getPositions(accountId);
-        },
-        getAccountSnapshot(accountId) {
-            return getCurrentClient().account.getAccountSnapshot(accountId);
-        },
-        getAccountStatus(accountId) {
-            return getCurrentClient().account.getAccountStatus(accountId);
-        },
-        getRiskSnapshot(accountId) {
-            return getCurrentClient().account.getRiskSnapshot(accountId);
-        },
-        watchAccountEvents() {
-            return accountEvents;
-        },
-    };
-    const order = {
-        async subscribeOrders(input) {
-            getRegisteredAccount(input.accountId);
-            const client = await requireStartedClient();
-            await client.order.subscribeOrders(input);
-            syncHealth();
-        },
-        async placeOrder(input) {
-            getRegisteredAccount(input.accountId);
-            assertSupportedExchange(input.exchange);
-            const client = await requireStartedClient();
-            const ack = await client.order.placeOrder(input);
-            syncHealth();
-            return ack;
-        },
-        async amendOrder(input) {
-            getRegisteredAccount(input.accountId);
-            assertSupportedExchange(input.exchange);
-            const client = await requireStartedClient();
-            const ack = await client.order.amendOrder(input);
-            syncHealth();
-            return ack;
-        },
-        async cancelOrder(input) {
-            getRegisteredAccount(input.accountId);
-            assertSupportedExchange(input.exchange);
-            const client = await requireStartedClient();
-            const ack = await client.order.cancelOrder(input);
-            syncHealth();
-            return ack;
-        },
-        async cancelAllOrders(input) {
-            getRegisteredAccount(input.accountId);
-            assertSupportedExchange(input.exchange);
-            const result = await requireStartedClient().then((client) => client.order.cancelAllOrders(input));
-            syncHealth();
-            return result;
-        },
-        getOrder(input) {
-            return getCurrentClient().order.getOrder(input);
-        },
-        getOpenOrders(accountId) {
-            return getCurrentClient().order.getOpenOrders(accountId);
-        },
-        getOrderStatus(accountId) {
-            return getCurrentClient().order.getOrderStatus(accountId);
-        },
-    };
-    function getCurrentClient() {
-        return (activeClient ?? {
-            market: idleMarket,
-            account: idleAccount,
-            order: idleOrder,
-        });
-    }
-    function bridgeEvents(source, push) {
-        void (async () => {
-            try {
-                for await (const value of source) {
-                    push(value);
-                }
-            }
-            catch { }
-        })();
-    }
-    function attachClientBridges(client) {
-        bridgeEvents(client.account.watchAccountEvents(), (event) => {
-            accountEvents.push(event);
-        });
-        bridgeEvents(client.watchErrors(), (event) => {
-            errors.push(event);
-        });
-        bridgeEvents(client.watchHealth(), (event) => {
-            healthEvents.push(event);
-        });
-    }
-    function getRegisteredAccount(accountId) {
-        const account = accounts.get(accountId);
-        if (account === undefined) {
-            throw createAcexError({
-                code: "ACCOUNT_NOT_FOUND",
-                message: `account not found: ${accountId}`,
-                retryable: false,
-                accountId,
-            });
-        }
-        return account;
-    }
-    function getOnlyRegisteredAccount() {
-        const registered = [...accounts.values()][0];
-        if (registered === undefined) {
-            throw createAcexError({
-                code: "VALIDATION_ERROR",
-                message: "registerAccount() must be called before start()",
-                retryable: false,
-            });
-        }
-        return registered;
-    }
-    function assertNonEmpty(value, field) {
-        if (value.trim().length === 0) {
-            throw createAcexError({
-                code: "VALIDATION_ERROR",
-                message: `missing required field: ${field}`,
-                retryable: false,
-            });
-        }
-    }
-    function assertSupportedExchange(exchange) {
-        if (exchange !== PUBLIC_EXCHANGE) {
-            throw createAcexError({
-                code: "EXCHANGE_NOT_SUPPORTED",
-                message: `unsupported exchange: ${exchange}`,
-                retryable: false,
-                exchange,
-            });
-        }
-    }
-    function syncHealth() {
-        healthStore.setClientStatus(status);
-        if (activeAdapter !== undefined) {
-            healthStore.setExchangeHealth(activeAdapter.exchange, activeAdapter.getHealth());
-        }
-        if (activeClient === undefined) {
-            return;
-        }
-        for (const accountId of accounts.keys()) {
-            const accountStatus = activeClient.account.getAccountStatus(accountId);
-            if (accountStatus !== undefined) {
-                healthStore.setAccountStatus(accountId, accountStatus);
-            }
-            const orderStatus = activeClient.order.getOrderStatus(accountId);
-            if (orderStatus !== undefined) {
-                healthStore.setOrderStatus(accountId, orderStatus);
-            }
-        }
-    }
-    async function ensureActiveClient() {
-        if (activeClient !== undefined) {
-            return activeClient;
-        }
-        const registered = getOnlyRegisteredAccount();
-        try {
-            const exchangeInput = {
-                apiKey: registered.credentials.apiKey,
-                secret: registered.credentials.secret,
-                ...(options.sandbox === undefined ? {} : { sandbox: options.sandbox }),
-            };
-            const exchange = dependencies.createExchange?.(exchangeInput) ?? createBinanceUsdmExchange(exchangeInput);
-            activeAdapter =
-                dependencies.createAdapter?.({
-                    accountId: registered.accountId,
-                    exchange,
-                }) ??
-                    new BinanceCompositeAdapter({
-                        marketAdapter: new BinanceNativeMarketAdapter(),
-                        privateAdapter: new CcxtBinanceUsdMAdapter({
-                            accountId: registered.accountId,
-                            exchange: exchange,
-                        }),
-                    });
-            activeClient = createInternalClient({ adapter: activeAdapter });
-            attachClientBridges(activeClient);
-            return activeClient;
-        }
-        catch (error) {
-            throw toClientError(error, {
-                exchange: registered.exchange,
-                accountId: registered.accountId,
-            });
-        }
-    }
-    async function requireStartedClient() {
-        if (status !== "running") {
-            throw createAcexError({
-                code: "VALIDATION_ERROR",
-                message: "client.start() must be called before using runtime APIs",
-                retryable: false,
-            });
-        }
-        return ensureActiveClient();
-    }
-    return {
-        market,
-        account,
-        order,
-        getStatus: () => status,
-        getHealth() {
-            syncHealth();
-            return healthStore.snapshot();
-        },
-        watchErrors() {
-            return errors;
-        },
-        watchHealth() {
-            return healthEvents;
-        },
-        async registerAccount(input) {
-            assertNonEmpty(input.accountId, "accountId");
-            assertNonEmpty(input.credentials.apiKey, "credentials.apiKey");
-            assertNonEmpty(input.credentials.secret, "credentials.secret");
-            assertSupportedExchange(input.exchange);
-            if (accounts.has(input.accountId)) {
-                throw createAcexError({
-                    code: "VALIDATION_ERROR",
-                    message: `duplicate accountId: ${input.accountId}`,
-                    retryable: false,
-                    accountId: input.accountId,
-                    exchange: input.exchange,
-                });
-            }
-            if (accounts.size > 0) {
-                throw createAcexError({
-                    code: "CAPABILITY_NOT_SUPPORTED",
-                    message: "public createClient() currently supports one registered account",
-                    retryable: false,
-                    exchange: input.exchange,
-                });
-            }
-            accounts.set(input.accountId, input);
-            if (status === "running" && activeClient === undefined) {
-                const client = await ensureActiveClient();
-                await client.start();
-            }
-            syncHealth();
-            return {
-                accountId: input.accountId,
-                exchange: input.exchange,
-            };
-        },
-        async start() {
-            if (status === "running") {
-                return;
-            }
-            const registered = getOnlyRegisteredAccount();
-            status = "starting";
-            syncHealth();
-            try {
-                const client = await ensureActiveClient();
-                await client.start();
-                status = "running";
-                syncHealth();
-            }
-            catch (error) {
-                status = "idle";
-                syncHealth();
-                throw toClientError(error, {
-                    exchange: registered.exchange,
-                    accountId: registered.accountId,
-                });
-            }
-        },
-        async stop() {
-            if (status === "stopped") {
-                return;
-            }
-            status = "stopping";
-            syncHealth();
-            await activeClient?.stop();
-            status = "stopped";
-            syncHealth();
-        },
-    };
-}
-export function createClient(options = {}) {
-    return createPublicClient(options);
-}
-function toClientError(error, context) {
-    if (isAcexError(error)) {
-        return error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return createAcexError({
-        code: message.includes("ccxt.pro.binanceusdm is not available")
-            ? "CAPABILITY_NOT_SUPPORTED"
-            : "INTERNAL_ERROR",
-        message,
-        retryable: false,
-        ...(context.exchange === undefined ? {} : { exchange: context.exchange }),
-        ...(context.accountId === undefined ? {} : { accountId: context.accountId }),
-        cause: error,
-    });
-}

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;

package/dist/core/runtime.js

@@ -1,150 +0,0 @@
-import { createAccountManager } from "../managers/account-manager.js";
-import { createMarketManager } from "../managers/market-manager.js";
-import { createOrderManager } from "../managers/order-manager.js";
-import { createAsyncQueue } from "../runtime/async-queue.js";
-import { createAccountStore } from "../store/account-store.js";
-import { createMarketStore } from "../store/market-store.js";
-import { createOrderStore } from "../store/order-store.js";
-import { markMarketReconciling, markMarketStale } from "./recovery.js";
-export function createRuntime(adapter) {
-    const accountStore = createAccountStore();
-    const marketStore = createMarketStore();
-    const orderStore = createOrderStore();
-    const account = createAccountManager(accountStore, adapter);
-    const healthQueue = createAsyncQueue({ maxBufferSize: 100 });
-    const errorQueue = createAsyncQueue({ maxBufferSize: 100 });
-    if (adapter.setMarketEventSink !== undefined) {
-        adapter.setMarketEventSink((event) => {
-            applyMarketEvent(marketStore, event, healthQueue);
-        });
-    }
-    else {
-        void (async () => {
-            for await (const event of adapter.watchMarketEvents()) {
-                applyMarketEvent(marketStore, event, healthQueue);
-            }
-        })();
-    }
-    if (adapter.setOrderEventSink !== undefined) {
-        adapter.setOrderEventSink((event) => {
-            applyOrderEvent(orderStore, event);
-        });
-    }
-    else {
-        void (async () => {
-            for await (const event of adapter.watchOrderEvents()) {
-                applyOrderEvent(orderStore, event);
-            }
-        })();
-    }
-    if (adapter.setAccountEventSink !== undefined) {
-        adapter.setAccountEventSink((event) => {
-            applyAccountEvent(accountStore, event);
-            account.pushEvent(event);
-        });
-    }
-    else {
-        void (async () => {
-            for await (const event of adapter.watchAccountEvents()) {
-                applyAccountEvent(accountStore, event);
-                account.pushEvent(event);
-            }
-        })();
-    }
-    void (async () => {
-        for await (const error of adapter.watchInternalErrors()) {
-            errorQueue.push({
-                source: "adapter",
-                exchange: adapter.exchange,
-                error,
-                ts: Date.now(),
-            });
-        }
-    })();
-    return {
-        account,
-        market: createMarketManager(marketStore, adapter),
-        order: createOrderManager(orderStore, adapter),
-        watchErrors() {
-            return errorQueue;
-        },
-        watchHealth() {
-            return healthQueue;
-        },
-    };
-}
-function applyMarketEvent(marketStore, event, healthQueue) {
-    if (event.type === "market.disconnected") {
-        const status = markMarketStale(event);
-        marketStore.setStatus(status);
-        healthQueue.push({
-            type: "market.status_changed",
-            exchange: event.exchange,
-            symbol: event.symbol,
-            status,
-            ts: event.receivedAt,
-        });
-        return;
-    }
-    if (event.type === "market.reconnecting") {
-        const status = markMarketReconciling(event);
-        marketStore.setStatus(status);
-        healthQueue.push({
-            type: "market.status_changed",
-            exchange: event.exchange,
-            symbol: event.symbol,
-            status,
-            ts: event.receivedAt,
-        });
-        return;
-    }
-    if (event.type === "l1_book.updated") {
-        marketStore.upsertL1Book(event);
-        marketStore.setStatus({
-            exchange: event.exchange,
-            symbol: event.symbol,
-            freshness: "fresh",
-            lastStreamReceivedAt: event.receivedAt,
-        });
-    }
-    if (event.type === "funding_rate.updated") {
-        marketStore.upsertFundingRate(event);
-        marketStore.setStatus({
-            exchange: event.exchange,
-            symbol: event.symbol,
-            freshness: "fresh",
-            lastStreamReceivedAt: event.receivedAt,
-        });
-    }
-}
-function applyOrderEvent(orderStore, event) {
-    orderStore.upsertOrder(event.snapshot);
-    orderStore.setStatus({
-        accountId: event.accountId,
-        exchange: event.exchange,
-        status: "healthy",
-        bootstrapCompleted: true,
-    });
-}
-function applyAccountEvent(accountStore, event) {
-    const current = accountStore.getSnapshot(event.accountId);
-    const balances = {
-        ...(current?.balances ?? {}),
-        [event.asset]: event.snapshot,
-    };
-    accountStore.replaceSnapshot({
-        accountId: event.accountId,
-        exchange: event.exchange,
-        balances,
-        positions: current?.positions ?? [],
-        ...(current?.risk === undefined ? {} : { risk: current.risk }),
-        receivedAt: event.snapshot.receivedAt,
-        updatedAt: event.snapshot.updatedAt,
-    });
-    accountStore.setStatus({
-        accountId: event.accountId,
-        exchange: event.exchange,
-        status: "healthy",
-        bootstrapCompleted: true,
-    });
-}

package/dist/errors/acex-error.d.ts

@@ -1,25 +0,0 @@
-import type { AcexErrorCode, Exchange } from "../types/public.js";
-export interface AcexError extends Error {
-    name: "AcexError";
-    readonly code: AcexErrorCode;
-    readonly retryable: boolean;
-    readonly exchange?: Exchange;
-    readonly accountId?: string;
-    readonly requestId?: string;
-    readonly clientOrderId?: string;
-    readonly orderId?: string;
-    readonly cause?: unknown;
-}
-export interface CreateAcexErrorInput {
-    code: AcexErrorCode;
-    message: string;
-    retryable: boolean;
-    exchange?: Exchange;
-    accountId?: string;
-    requestId?: string;
-    clientOrderId?: string;
-    orderId?: string;
-    cause?: unknown;
-}
-export declare function createAcexError(input: CreateAcexErrorInput): AcexError;
-export declare function isAcexError(value: unknown): value is AcexError;

package/dist/errors/acex-error.js

@@ -1,54 +0,0 @@
-const ACEX_ERROR_CODES = [
-    "VALIDATION_ERROR",
-    "EXCHANGE_NOT_SUPPORTED",
-    "ACCOUNT_NOT_FOUND",
-    "AUTH_FAILED",
-    "RATE_LIMITED",
-    "TRANSPORT_UNAVAILABLE",
-    "ORDER_REJECTED",
-    "INSUFFICIENT_BALANCE",
-    "REQUEST_OUTCOME_UNKNOWN",
-    "ORDER_STATE_UNKNOWN",
-    "EVENT_CONSUMER_OVERFLOW",
-    "CAPABILITY_NOT_SUPPORTED",
-    "INTERNAL_ERROR",
-];
-const ACEX_ERROR_CODE_SET = new Set(ACEX_ERROR_CODES);
-export function createAcexError(input) {
-    const error = new Error(input.message, {
-        cause: input.cause,
-    });
-    error.name = "AcexError";
-    error.code = input.code;
-    error.retryable = input.retryable;
-    if (input.exchange !== undefined) {
-        error.exchange = input.exchange;
-    }
-    if (input.accountId !== undefined) {
-        error.accountId = input.accountId;
-    }
-    if (input.requestId !== undefined) {
-        error.requestId = input.requestId;
-    }
-    if (input.clientOrderId !== undefined) {
-        error.clientOrderId = input.clientOrderId;
-    }
-    if (input.orderId !== undefined) {
-        error.orderId = input.orderId;
-    }
-    if (input.cause !== undefined) {
-        error.cause = input.cause;
-    }
-    return error;
-}
-export function isAcexError(value) {
-    if (!(value instanceof Error)) {
-        return false;
-    }
-    if (!("code" in value) || !("retryable" in value)) {
-        return false;
-    }
-    const code = value.code;
-    const retryable = value.retryable;
-    return (typeof code === "string" && ACEX_ERROR_CODE_SET.has(code) && typeof retryable === "boolean");
-}