@imbingox/acex 0.1.0 → 0.2.0

package/dist/index.d.ts

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

package/dist/index.js

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

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

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

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

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

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

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

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

package/dist/runtime/async-queue.js

@@ -1,88 +0,0 @@
-import { createAcexError } from "../errors/acex-error.js";
-export function createAsyncQueue(input) {
-    const buffer = [];
-    const pendingNext = [];
-    let isClosed = false;
-    let overflowError;
-    const drainPending = () => {
-        while (pendingNext.length > 0) {
-            const next = pendingNext.shift();
-            if (next === undefined) {
-                return;
-            }
-            if (overflowError !== undefined) {
-                next.reject(overflowError);
-                continue;
-            }
-            if (buffer.length > 0) {
-                const slot = buffer.shift();
-                if (slot === undefined) {
-                    next.resolve({ done: true, value: undefined });
-                    continue;
-                }
-                next.resolve({ done: false, value: slot.value });
-                continue;
-            }
-            if (isClosed) {
-                next.resolve({ done: true, value: undefined });
-                continue;
-            }
-            pendingNext.unshift(next);
-            return;
-        }
-    };
-    const next = () => {
-        if (overflowError !== undefined) {
-            return Promise.reject(overflowError);
-        }
-        if (buffer.length > 0) {
-            const slot = buffer.shift();
-            if (slot !== undefined) {
-                return Promise.resolve({ done: false, value: slot.value });
-            }
-        }
-        if (isClosed) {
-            return Promise.resolve({ done: true, value: undefined });
-        }
-        return new Promise((resolve, reject) => {
-            pendingNext.push({ resolve, reject });
-        });
-    };
-    const queue = {
-        push(value) {
-            if (isClosed || overflowError !== undefined) {
-                return;
-            }
-            if (pendingNext.length > 0) {
-                const waiter = pendingNext.shift();
-                if (waiter !== undefined) {
-                    waiter.resolve({ done: false, value });
-                    return;
-                }
-            }
-            if (buffer.length >= input.maxBufferSize) {
-                overflowError = createAcexError({
-                    code: "EVENT_CONSUMER_OVERFLOW",
-                    message: "EVENT_CONSUMER_OVERFLOW",
-                    retryable: false,
-                });
-                drainPending();
-                return;
-            }
-            buffer.push({ value });
-        },
-        close() {
-            if (isClosed) {
-                return;
-            }
-            isClosed = true;
-            drainPending();
-        },
-        [Symbol.asyncIterator]() {
-            return {
-                next,
-            };
-        },
-    };
-    return queue;
-}

package/dist/runtime/request-id.d.ts

@@ -1 +0,0 @@
-export declare function nextRequestId(): string;

package/dist/runtime/request-id.js

@@ -1,5 +0,0 @@
-let counter = 0;
-export function nextRequestId() {
-    counter += 1;
-    return `req-${counter}`;
-}

package/dist/runtime/ws-connection-supervisor.d.ts

@@ -1,76 +0,0 @@
-export type WsConnectionState = "idle" | "connecting" | "open" | "reconnecting" | "closed";
-export interface WsSocketLike {
-    readyState: number;
-    send(data: string | ArrayBufferLike | Uint8Array): void;
-    close(code?: number, reason?: string): void;
-    ping?(data?: string | ArrayBufferLike | Uint8Array): void;
-    pong?(data?: string | ArrayBufferLike | Uint8Array): void;
-    terminate?(): void;
-    onopen: ((event: unknown) => void) | null;
-    onmessage: ((event: {
-        data: string | Buffer | ArrayBuffer | ArrayBufferView;
-    }) => void) | null;
-    onping?: ((event: {
-        data?: string | Buffer | ArrayBuffer | ArrayBufferView;
-    }) => void) | null;
-    onpong?: ((event: {
-        data?: string | Buffer | ArrayBuffer | ArrayBufferView;
-    }) => void) | null;
-    onclose: ((event: unknown) => void) | null;
-    onerror: ((event: unknown) => void) | null;
-}
-type CustomHeartbeatCleanup = (() => void | Promise<void>) | undefined;
-type CustomHeartbeatContext = {
-    socket: WsSocketLike;
-    markActivity: () => void;
-    send: (data: string | ArrayBufferLike | Uint8Array) => void;
-    sleep: (ms: number) => Promise<void>;
-    now: () => number;
-    reportError: (error: unknown) => void;
-};
-type HeartbeatConfig = {
-    kind: "passive_read_timeout";
-    idleTimeoutMs: number;
-} | {
-    kind: "native_ping_pong";
-    heartbeatIntervalMs: number;
-    idleTimeoutMs: number;
-} | {
-    kind: "app_ping_message";
-    heartbeatIntervalMs: number;
-    idleTimeoutMs: number;
-    buildPingMessage: () => string | ArrayBufferLike | Uint8Array;
-} | {
-    kind: "custom";
-    idleTimeoutMs: number;
-    heartbeatIntervalMs?: number;
-    start: (context: CustomHeartbeatContext) => CustomHeartbeatCleanup | Promise<CustomHeartbeatCleanup>;
-};
-interface CreateWsConnectionSupervisorInput {
-    createSocket: () => WsSocketLike;
-    heartbeat: HeartbeatConfig;
-    backoff: {
-        baseDelayMs: number;
-        maxDelayMs: number;
-        jitter: boolean;
-    };
-    now?: () => number;
-    sleep?: (ms: number) => Promise<void>;
-    onOpen?: () => void;
-    onMessage?: (event: {
-        data: string | Buffer | ArrayBuffer | ArrayBufferView;
-    }) => void;
-    onClose?: () => void;
-    onDisconnect?: () => void;
-    onReconnect?: () => void | Promise<void>;
-    onError?: (error: Error) => void;
-}
-export interface WsConnectionSupervisor {
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    send(data: string | ArrayBufferLike | Uint8Array): void;
-    getState(): WsConnectionState;
-    getLastActivityAt(): number | undefined;
-}
-export declare function createWsConnectionSupervisor(input: CreateWsConnectionSupervisorInput): WsConnectionSupervisor;
-export {};