@imbingox/acex 0.1.0-beta.0

package/dist/core/runtime.js

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

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

@@ -0,0 +1,54 @@
+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");
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createClient } from "./core/client.js";
+export { createAcexError, isAcexError } from "./errors/acex-error.js";
+export { IMPLEMENTED_EXCHANGES } from "./types/public.js";
+export type { AcexErrorCode, ClientStatus, Exchange, ImplementedExchange, Logger, } from "./types/public.js";
+export type { AcexError, CreateAcexErrorInput } from "./errors/acex-error.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createClient } from "./core/client.js";
+export { createAcexError, isAcexError } from "./errors/acex-error.js";
+export { IMPLEMENTED_EXCHANGES } from "./types/public.js";

package/dist/managers/account-manager.d.ts

@@ -0,0 +1,41 @@
+import type { AdapterAccountBaseline, NormalizedAccountEvent } from "../adapters/types.js";
+import type { AccountBalanceSnapshot, AccountPositionSnapshot, AccountRiskSnapshot, AccountSnapshot, AccountStatus, AccountStore } from "../store/account-store.js";
+export interface SubscribeAccountInput {
+    accountId: string;
+}
+export interface AccountPositionLookupInput {
+    accountId: string;
+    symbol: string;
+}
+export interface AccountManager {
+    subscribeAccount(input: SubscribeAccountInput): Promise<void>;
+    getBalance(accountId: string, asset: string): AccountBalanceSnapshot | undefined;
+    getBalances(accountId: string): AccountBalanceSnapshot[];
+    getPosition(input: AccountPositionLookupInput): AccountPositionSnapshot | undefined;
+    getPositions(accountId: string): AccountPositionSnapshot[];
+    getAccountSnapshot(accountId: string): AccountSnapshot | undefined;
+    getAccountStatus(accountId: string): AccountStatus | undefined;
+    getRiskSnapshot(accountId: string): AccountRiskSnapshot | undefined;
+    watchAccountEvents(): AsyncIterable<NormalizedAccountEvent>;
+}
+interface AccountAdapter {
+    exchange: string;
+    fetchAccountBaseline(accountId: string): Promise<AdapterAccountBaseline>;
+}
+export declare function createAccountManager(store: AccountStore, adapter: AccountAdapter): {
+    subscribeAccount(input: SubscribeAccountInput): Promise<void>;
+    getBalance(accountId: string, asset: string): AccountBalanceSnapshot | undefined;
+    getBalances(accountId: string): AccountBalanceSnapshot[];
+    getPosition(input: AccountPositionLookupInput): AccountPositionSnapshot | undefined;
+    getPositions(accountId: string): AccountPositionSnapshot[];
+    getAccountSnapshot: (accountId: string) => AccountSnapshot | undefined;
+    getAccountStatus: (accountId: string) => AccountStatus | undefined;
+    getRiskSnapshot(accountId: string): AccountRiskSnapshot | undefined;
+    watchAccountEvents(): import("../runtime/async-queue.js").AsyncQueue<NormalizedAccountEvent>;
+    pushEvent(event: NormalizedAccountEvent): void;
+};
+export declare function createIdleAccountManager(): AccountManager;
+export interface AccountManagerRuntime extends AccountManager {
+    pushEvent(event: NormalizedAccountEvent): void;
+}
+export {};

package/dist/managers/account-manager.js

@@ -0,0 +1,80 @@
+import { createAsyncQueue } from "../runtime/async-queue.js";
+export function createAccountManager(store, adapter) {
+    const publicEvents = createAsyncQueue({ maxBufferSize: 100 });
+    return {
+        async subscribeAccount(input) {
+            const baseline = await adapter.fetchAccountBaseline(input.accountId);
+            const now = Date.now();
+            store.replaceSnapshot({
+                accountId: input.accountId,
+                exchange: adapter.exchange,
+                balances: baseline.balances,
+                positions: baseline.positions,
+                ...(baseline.risk === undefined ? {} : { risk: baseline.risk }),
+                receivedAt: now,
+                updatedAt: now,
+            });
+            store.setStatus({
+                accountId: input.accountId,
+                exchange: adapter.exchange,
+                status: "healthy",
+                bootstrapCompleted: true,
+            });
+        },
+        getBalance(accountId, asset) {
+            return store.getSnapshot(accountId)?.balances?.[asset];
+        },
+        getBalances(accountId) {
+            return Object.values(store.getSnapshot(accountId)?.balances ?? {});
+        },
+        getPosition(input) {
+            return (store.getSnapshot(input.accountId)?.positions ?? []).find((position) => {
+                return position.symbol === input.symbol;
+            });
+        },
+        getPositions(accountId) {
+            return store.getSnapshot(accountId)?.positions ?? [];
+        },
+        getAccountSnapshot: store.getSnapshot,
+        getAccountStatus: store.getStatus,
+        getRiskSnapshot(accountId) {
+            return store.getSnapshot(accountId)?.risk;
+        },
+        watchAccountEvents() {
+            return publicEvents;
+        },
+        pushEvent(event) {
+            publicEvents.push(event);
+        },
+    };
+}
+export function createIdleAccountManager() {
+    const events = createAsyncQueue({ maxBufferSize: 100 });
+    return {
+        async subscribeAccount() { },
+        getBalance() {
+            return undefined;
+        },
+        getBalances() {
+            return [];
+        },
+        getPosition() {
+            return undefined;
+        },
+        getPositions() {
+            return [];
+        },
+        getAccountSnapshot() {
+            return undefined;
+        },
+        getAccountStatus() {
+            return undefined;
+        },
+        getRiskSnapshot() {
+            return undefined;
+        },
+        watchAccountEvents() {
+            return events;
+        },
+    };
+}

package/dist/managers/market-manager.d.ts

@@ -0,0 +1,16 @@
+import type { MarketDataStatus, MarketStore, MarketStoreKey } from "../store/market-store.js";
+export interface MarketManager {
+    subscribeL1Book(input: MarketStoreKey): Promise<void>;
+    subscribeFundingRate(input: MarketStoreKey): Promise<void>;
+    getL1Book(key: MarketStoreKey): ReturnType<MarketStore["getL1Book"]>;
+    getFundingRate(key: MarketStoreKey): ReturnType<MarketStore["getFundingRate"]>;
+    getMarketSnapshot(key: MarketStoreKey): ReturnType<MarketStore["getSnapshot"]>;
+    getMarketStatus(key: MarketStoreKey): MarketDataStatus | undefined;
+}
+interface MarketSubscriptionAdapter {
+    subscribeL1Book(input: MarketStoreKey): Promise<void>;
+    subscribeFundingRate(input: MarketStoreKey): Promise<void>;
+}
+export declare function createMarketManager(store: MarketStore, adapter: MarketSubscriptionAdapter): MarketManager;
+export declare function createIdleMarketManager(): MarketManager;
+export {};

package/dist/managers/market-manager.js

@@ -0,0 +1,28 @@
+export function createMarketManager(store, adapter) {
+    return {
+        subscribeL1Book: adapter.subscribeL1Book.bind(adapter),
+        subscribeFundingRate: adapter.subscribeFundingRate.bind(adapter),
+        getL1Book: store.getL1Book,
+        getFundingRate: store.getFundingRate,
+        getMarketSnapshot: store.getSnapshot,
+        getMarketStatus: store.getStatus,
+    };
+}
+export function createIdleMarketManager() {
+    return {
+        async subscribeL1Book() { },
+        async subscribeFundingRate() { },
+        getL1Book() {
+            return undefined;
+        },
+        getFundingRate() {
+            return undefined;
+        },
+        getMarketSnapshot() {
+            return {};
+        },
+        getMarketStatus() {
+            return undefined;
+        },
+    };
+}

package/dist/managers/order-manager.d.ts

@@ -0,0 +1,87 @@
+import type { OrderSnapshot, OrderStatus, OrderStore } from "../store/order-store.js";
+export interface SubscribeOrdersInput {
+    accountId: string;
+}
+export interface PlaceOrderInput {
+    accountId: string;
+    exchange: string;
+    symbol: string;
+    side: "buy" | "sell";
+    amount: string;
+    clientOrderId: string;
+    type: string;
+    price?: string;
+    reduceOnly?: boolean;
+}
+export interface AmendOrderInput {
+    accountId: string;
+    exchange: string;
+    clientOrderId?: string;
+    orderId?: string;
+    symbol?: string;
+    newPrice?: string;
+}
+export interface CancelOrderInput {
+    accountId: string;
+    exchange: string;
+    clientOrderId?: string;
+    orderId?: string;
+}
+export interface CancelAllOrdersInput {
+    accountId: string;
+    exchange: string;
+}
+export interface OrderLookupInput {
+    accountId: string;
+    exchange: string;
+    clientOrderId?: string;
+    orderId?: string;
+}
+export interface OrderAck {
+    requestId: string;
+    accountId: string;
+    exchange: string;
+    clientOrderId?: string;
+    orderId?: string;
+    symbol?: string;
+    submittedAt: number;
+}
+export interface CancelAllOrdersResult {
+    accountId: string;
+    exchange: string;
+    canceledCount: number;
+}
+export interface OrderManager {
+    subscribeOrders(input: SubscribeOrdersInput): Promise<void>;
+    placeOrder(input: PlaceOrderInput): Promise<OrderAck>;
+    amendOrder(input: AmendOrderInput): Promise<OrderAck>;
+    cancelOrder(input: CancelOrderInput): Promise<OrderAck>;
+    cancelAllOrders(input: CancelAllOrdersInput): Promise<CancelAllOrdersResult>;
+    getOrder(input: OrderLookupInput): OrderSnapshot | undefined;
+    getOpenOrders(accountId: string): OrderSnapshot[];
+    getOrderStatus(accountId: string): OrderStatus | undefined;
+}
+interface OrderAdapter {
+    exchange: string;
+    subscribeOrders(input: SubscribeOrdersInput): Promise<void>;
+    fetchOpenOrdersBaseline(accountId: string): Promise<OrderSnapshot[]>;
+    placeOrder(input: PlaceOrderInput): Promise<{
+        clientOrderId?: string;
+        orderId?: string;
+        receivedAt: number;
+    }>;
+    amendOrder(input: AmendOrderInput): Promise<{
+        clientOrderId?: string;
+        orderId?: string;
+        receivedAt: number;
+    }>;
+    cancelOrder(input: CancelOrderInput): Promise<{
+        clientOrderId?: string;
+        orderId?: string;
+        receivedAt: number;
+    }>;
+    cancelAllOrders(input: CancelAllOrdersInput): Promise<CancelAllOrdersResult>;
+}
+export declare function createOrderManager(store: OrderStore, adapter: OrderAdapter): OrderManager;
+export declare function createIdleOrderManager(): OrderManager;
+export {};

package/dist/managers/order-manager.js

@@ -0,0 +1,122 @@
+import { nextRequestId } from "../runtime/request-id.js";
+export function createOrderManager(store, adapter) {
+    return {
+        async subscribeOrders(input) {
+            await adapter.subscribeOrders(input);
+            const baseline = await adapter.fetchOpenOrdersBaseline(input.accountId);
+            for (const snapshot of baseline) {
+                store.upsertOrder(snapshot);
+            }
+            store.setStatus({
+                accountId: input.accountId,
+                exchange: adapter.exchange,
+                status: "healthy",
+                bootstrapCompleted: true,
+            });
+        },
+        async placeOrder(input) {
+            const result = await adapter.placeOrder(input);
+            return createOrderAck({
+                requestId: nextRequestId(),
+                accountId: input.accountId,
+                exchange: input.exchange,
+                symbol: input.symbol,
+                clientOrderId: result.clientOrderId ?? input.clientOrderId,
+                orderId: result.orderId,
+                submittedAt: result.receivedAt,
+            });
+        },
+        async amendOrder(input) {
+            const result = await adapter.amendOrder(input);
+            return createOrderAck({
+                requestId: nextRequestId(),
+                accountId: input.accountId,
+                exchange: input.exchange,
+                symbol: input.symbol,
+                clientOrderId: result.clientOrderId ?? input.clientOrderId,
+                orderId: result.orderId,
+                submittedAt: result.receivedAt,
+            });
+        },
+        async cancelOrder(input) {
+            const result = await adapter.cancelOrder(input);
+            return createOrderAck({
+                requestId: nextRequestId(),
+                accountId: input.accountId,
+                exchange: input.exchange,
+                clientOrderId: result.clientOrderId ?? input.clientOrderId,
+                orderId: result.orderId,
+                submittedAt: result.receivedAt,
+            });
+        },
+        cancelAllOrders: adapter.cancelAllOrders.bind(adapter),
+        getOrder(input) {
+            return store.getOrder(input.accountId, input);
+        },
+        getOpenOrders: store.getOpenOrders,
+        getOrderStatus: store.getStatus,
+    };
+}
+export function createIdleOrderManager() {
+    return {
+        async subscribeOrders() { },
+        async placeOrder(input) {
+            return createOrderAck({
+                requestId: nextRequestId(),
+                accountId: input.accountId,
+                exchange: input.exchange,
+                symbol: input.symbol,
+                clientOrderId: input.clientOrderId,
+                submittedAt: Date.now(),
+            });
+        },
+        async amendOrder(input) {
+            return createOrderAck({
+                requestId: nextRequestId(),
+                accountId: input.accountId,
+                exchange: input.exchange,
+                symbol: input.symbol,
+                clientOrderId: input.clientOrderId,
+                orderId: input.orderId,
+                submittedAt: Date.now(),
+            });
+        },
+        async cancelOrder(input) {
+            return createOrderAck({
+                requestId: nextRequestId(),
+                accountId: input.accountId,
+                exchange: input.exchange,
+                clientOrderId: input.clientOrderId,
+                orderId: input.orderId,
+                submittedAt: Date.now(),
+            });
+        },
+        async cancelAllOrders(input) {
+            return {
+                accountId: input.accountId,
+                exchange: input.exchange,
+                canceledCount: 0,
+            };
+        },
+        getOrder() {
+            return undefined;
+        },
+        getOpenOrders() {
+            return [];
+        },
+        getOrderStatus() {
+            return undefined;
+        },
+    };
+}
+function createOrderAck(input) {
+    return {
+        requestId: input.requestId,
+        accountId: input.accountId,
+        exchange: input.exchange,
+        submittedAt: input.submittedAt,
+        ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+        ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+        ...(input.symbol === undefined ? {} : { symbol: input.symbol }),
+    };
+}

package/dist/runtime/async-queue.d.ts

@@ -0,0 +1,8 @@
+export interface CreateAsyncQueueInput {
+    maxBufferSize: number;
+}
+export interface AsyncQueue<T> extends AsyncIterable<T> {
+    push(value: T): void;
+    close(): void;
+}
+export declare function createAsyncQueue<T>(input: CreateAsyncQueueInput): AsyncQueue<T>;