@imbingox/acex 0.1.0 → 0.2.0

package/dist/runtime/ws-connection-supervisor.js

@@ -1,522 +0,0 @@
-import { createAcexError } from "../errors/acex-error.js";
-const SOCKET_CONNECTING = 0;
-const SOCKET_OPEN = 1;
-const SOCKET_CLOSING = 2;
-function createDeferred() {
-    let resolve;
-    const promise = new Promise((innerResolve) => {
-        resolve = innerResolve;
-    });
-    return {
-        promise,
-        resolve() {
-            resolve?.();
-        },
-    };
-}
-function createTransportError(message, cause) {
-    return createAcexError({
-        code: "TRANSPORT_UNAVAILABLE",
-        message,
-        retryable: true,
-        ...(cause === undefined ? {} : { cause }),
-    });
-}
-function toError(value) {
-    if (value instanceof Error) {
-        return value;
-    }
-    if (typeof value === "string") {
-        return new Error(value);
-    }
-    return new Error("websocket error");
-}
-export function createWsConnectionSupervisor(input) {
-    const now = input.now ?? (() => Date.now());
-    const sleep = input.sleep ??
-        ((ms) => {
-            return new Promise((resolve) => setTimeout(resolve, ms));
-        });
-    let state = "idle";
-    let socket;
-    let connectPromise;
-    let resolveConnect;
-    let rejectConnect;
-    let reconnectTask;
-    let manualClose = false;
-    let lastActivityAt;
-    let openedAt;
-    let loopGeneration = 0;
-    let reconnectAttempts = 0;
-    let reconnectGeneration = 0;
-    let customHeartbeatCleanup;
-    let customHeartbeatStartTask;
-    let connectionLoopsStopping = false;
-    let connectionLoopStopTask = Promise.resolve();
-    let pendingClose;
-    const resetPendingConnect = () => {
-        connectPromise = undefined;
-        resolveConnect = undefined;
-        rejectConnect = undefined;
-    };
-    const markActivity = () => {
-        lastActivityAt = now();
-    };
-    const resetActivityWindow = () => {
-        lastActivityAt = undefined;
-        openedAt = now();
-    };
-    const toInactiveState = () => {
-        if (manualClose) {
-            state = "closed";
-            return;
-        }
-        state = "idle";
-    };
-    const reportError = (error) => {
-        try {
-            input.onError?.(toError(error));
-        }
-        catch { }
-    };
-    const runSyncCallback = (callback) => {
-        try {
-            callback?.();
-        }
-        catch (error) {
-            reportError(error);
-        }
-    };
-    const runMessageCallback = (callback, event) => {
-        try {
-            callback?.(event);
-        }
-        catch (error) {
-            reportError(error);
-        }
-    };
-    const runOnReconnect = () => {
-        void Promise.resolve()
-            .then(async () => {
-            await input.onReconnect?.();
-        })
-            .catch((error) => {
-            reportError(error);
-        });
-    };
-    const stopConnectionLoops = () => {
-        const cleanup = customHeartbeatCleanup;
-        const startTask = customHeartbeatStartTask;
-        customHeartbeatCleanup = undefined;
-        customHeartbeatStartTask = undefined;
-        loopGeneration += 1;
-        openedAt = undefined;
-        connectionLoopsStopping = true;
-        connectionLoopStopTask = Promise.resolve(startTask)
-            .then(async () => {
-            if (typeof cleanup === "function") {
-                await cleanup();
-            }
-        })
-            .catch((error) => {
-            reportError(error);
-        })
-            .finally(() => {
-            connectionLoopsStopping = false;
-        });
-        return connectionLoopStopTask;
-    };
-    const resolvePendingClose = (currentSocket) => {
-        if (pendingClose?.socket !== currentSocket) {
-            return;
-        }
-        const { resolve } = pendingClose;
-        pendingClose = undefined;
-        void connectionLoopStopTask.finally(() => {
-            resolve();
-        });
-    };
-    const watchdogIntervalMs = () => {
-        if (input.heartbeat.kind === "passive_read_timeout") {
-            return input.heartbeat.idleTimeoutMs;
-        }
-        if (input.heartbeat.kind === "custom") {
-            return Math.min(input.heartbeat.heartbeatIntervalMs ?? input.heartbeat.idleTimeoutMs, input.heartbeat.idleTimeoutMs);
-        }
-        return Math.min(input.heartbeat.heartbeatIntervalMs, input.heartbeat.idleTimeoutMs);
-    };
-    const backoffDelayMs = () => {
-        const uncappedDelay = input.backoff.baseDelayMs * 2 ** reconnectAttempts;
-        const cappedDelay = Math.min(uncappedDelay, input.backoff.maxDelayMs);
-        if (input.backoff.jitter === false) {
-            return cappedDelay;
-        }
-        const spread = Math.floor(cappedDelay * 0.2);
-        const jitterDelta = Math.floor(Math.random() * (spread * 2 + 1)) - spread;
-        return Math.max(0, cappedDelay + jitterDelta);
-    };
-    const isCurrentOpenSocket = (generation, currentSocket) => {
-        return (generation === loopGeneration &&
-            socket === currentSocket &&
-            currentSocket.readyState === SOCKET_OPEN &&
-            state === "open");
-    };
-    const disconnectSocketForTimeout = (currentSocket) => {
-        if (socket !== currentSocket) {
-            return;
-        }
-        socket = undefined;
-        stopConnectionLoops();
-        try {
-            if (typeof currentSocket.terminate === "function") {
-                currentSocket.terminate();
-            }
-            else if (currentSocket.readyState < SOCKET_CLOSING) {
-                currentSocket.close();
-            }
-        }
-        catch (error) {
-            reportError(error);
-        }
-        if (manualClose) {
-            state = "closed";
-            return;
-        }
-        runSyncCallback(input.onClose);
-        void reconnect();
-    };
-    const startHeartbeatLoop = (generation, currentSocket) => {
-        const heartbeat = input.heartbeat;
-        if (heartbeat.kind === "passive_read_timeout" || heartbeat.kind === "custom") {
-            return;
-        }
-        void (async () => {
-            while (isCurrentOpenSocket(generation, currentSocket) && !manualClose) {
-                await sleep(heartbeat.heartbeatIntervalMs);
-                if (!isCurrentOpenSocket(generation, currentSocket) || manualClose) {
-                    return;
-                }
-                try {
-                    if (heartbeat.kind === "native_ping_pong") {
-                        currentSocket.ping?.();
-                    }
-                    else {
-                        currentSocket.send(heartbeat.buildPingMessage());
-                    }
-                }
-                catch (error) {
-                    reportError(error);
-                }
-            }
-        })().catch((error) => {
-            reportError(error);
-        });
-    };
-    const startCustomHeartbeatDriver = (generation, currentSocket) => {
-        const heartbeat = input.heartbeat;
-        if (heartbeat.kind !== "custom") {
-            return;
-        }
-        customHeartbeatStartTask = Promise.resolve()
-            .then(async () => {
-            return await heartbeat.start({
-                socket: currentSocket,
-                markActivity: () => {
-                    if (socket === currentSocket) {
-                        markActivity();
-                    }
-                },
-                send: (data) => {
-                    if (socket !== currentSocket || currentSocket.readyState !== SOCKET_OPEN) {
-                        throw createTransportError("websocket is not open");
-                    }
-                    currentSocket.send(data);
-                },
-                sleep,
-                now,
-                reportError,
-            });
-        })
-            .then(async (cleanup) => {
-            if (typeof cleanup !== "function") {
-                return;
-            }
-            if (generation !== loopGeneration ||
-                socket !== currentSocket ||
-                currentSocket.readyState !== SOCKET_OPEN ||
-                state !== "open") {
-                await cleanup();
-                return;
-            }
-            customHeartbeatCleanup = cleanup;
-        })
-            .catch((error) => {
-            reportError(error);
-        });
-    };
-    const startWatchdogLoop = (generation, currentSocket) => {
-        const watchdogInterval = watchdogIntervalMs();
-        void (async () => {
-            while (generation === loopGeneration && socket === currentSocket && !manualClose) {
-                const activityReferenceAt = lastActivityAt ?? openedAt;
-                const remainingTimeoutMs = activityReferenceAt === undefined
-                    ? input.heartbeat.idleTimeoutMs
-                    : Math.max(0, input.heartbeat.idleTimeoutMs - (now() - activityReferenceAt));
-                if (remainingTimeoutMs === 0) {
-                    disconnectSocketForTimeout(currentSocket);
-                    return;
-                }
-                await sleep(Math.min(watchdogInterval, remainingTimeoutMs));
-                if (generation !== loopGeneration || socket !== currentSocket || manualClose) {
-                    return;
-                }
-            }
-        })().catch((error) => {
-            reportError(error);
-        });
-    };
-    const beginConnect = (mode, manualConnectGeneration) => {
-        const reconnecting = mode === "reconnect";
-        const connectGeneration = mode === "connect" ? (manualConnectGeneration ?? reconnectGeneration + 1) : undefined;
-        if (mode === "connect") {
-            reconnectGeneration = connectGeneration ?? reconnectGeneration;
-            reconnectTask = undefined;
-        }
-        if (socket !== undefined) {
-            if (socket.readyState === SOCKET_OPEN) {
-                state = "open";
-                return Promise.resolve();
-            }
-            if (socket.readyState === SOCKET_CONNECTING && connectPromise !== undefined) {
-                return connectPromise;
-            }
-        }
-        if (mode === "connect" && (pendingClose !== undefined || connectionLoopsStopping)) {
-            return Promise.all([
-                pendingClose?.promise,
-                connectionLoopsStopping ? connectionLoopStopTask : undefined,
-            ]).then(() => beginConnect(mode, connectGeneration));
-        }
-        if (mode === "connect") {
-            manualClose = false;
-        }
-        state = reconnecting ? "reconnecting" : "connecting";
-        let currentSocket;
-        try {
-            currentSocket = input.createSocket();
-        }
-        catch (error) {
-            toInactiveState();
-            return Promise.reject(error);
-        }
-        socket = currentSocket;
-        connectPromise = new Promise((resolve, reject) => {
-            resolveConnect = resolve;
-            rejectConnect = reject;
-        });
-        currentSocket.onopen = () => {
-            if (socket !== currentSocket) {
-                return;
-            }
-            state = "open";
-            resetActivityWindow();
-            loopGeneration += 1;
-            reconnectAttempts = 0;
-            resolveConnect?.();
-            resetPendingConnect();
-            startHeartbeatLoop(loopGeneration, currentSocket);
-            startCustomHeartbeatDriver(loopGeneration, currentSocket);
-            startWatchdogLoop(loopGeneration, currentSocket);
-            if (!reconnecting) {
-                runSyncCallback(input.onOpen);
-            }
-        };
-        currentSocket.onmessage = (event) => {
-            if (socket !== currentSocket) {
-                return;
-            }
-            markActivity();
-            runMessageCallback(input.onMessage, event);
-        };
-        currentSocket.onping = () => {
-            if (socket !== currentSocket) {
-                return;
-            }
-            markActivity();
-        };
-        currentSocket.onpong = () => {
-            if (socket !== currentSocket) {
-                return;
-            }
-            markActivity();
-        };
-        currentSocket.onclose = () => {
-            if (socket !== currentSocket) {
-                resolvePendingClose(currentSocket);
-                return;
-            }
-            socket = undefined;
-            stopConnectionLoops();
-            if (rejectConnect !== undefined) {
-                rejectConnect(createTransportError("websocket connection closed before opening"));
-                toInactiveState();
-                resetPendingConnect();
-                resolvePendingClose(currentSocket);
-                return;
-            }
-            if (manualClose) {
-                state = "closed";
-                resolvePendingClose(currentSocket);
-                return;
-            }
-            runSyncCallback(input.onClose);
-            void reconnect();
-        };
-        currentSocket.onerror = (event) => {
-            if (socket !== currentSocket) {
-                return;
-            }
-            reportError(event);
-            socket = undefined;
-            stopConnectionLoops();
-            if (rejectConnect !== undefined) {
-                rejectConnect(createTransportError("failed to connect websocket", event));
-                toInactiveState();
-                resetPendingConnect();
-                return;
-            }
-            if (currentSocket.readyState < SOCKET_CLOSING) {
-                try {
-                    currentSocket.close();
-                }
-                catch { }
-            }
-            if (manualClose) {
-                state = "closed";
-                return;
-            }
-            void reconnect();
-        };
-        return connectPromise;
-    };
-    const reconnect = async () => {
-        if (reconnectTask !== undefined) {
-            return reconnectTask;
-        }
-        const generation = reconnectGeneration + 1;
-        reconnectGeneration = generation;
-        state = "reconnecting";
-        try {
-            input.onDisconnect?.();
-        }
-        catch (error) {
-            reportError(error);
-        }
-        const taskRef = { current: undefined };
-        const currentTask = (async () => {
-            try {
-                try {
-                    await connectionLoopStopTask;
-                    await sleep(backoffDelayMs());
-                    if (manualClose || generation !== reconnectGeneration) {
-                        return;
-                    }
-                    reconnectAttempts += 1;
-                    await beginConnect("reconnect");
-                    if (manualClose || generation !== reconnectGeneration) {
-                        return;
-                    }
-                }
-                catch (error) {
-                    if (!manualClose) {
-                        toInactiveState();
-                        reportError(error);
-                    }
-                    return;
-                }
-                runOnReconnect();
-            }
-            finally {
-                if (reconnectTask === taskRef.current) {
-                    reconnectTask = undefined;
-                }
-            }
-        })();
-        taskRef.current = currentTask;
-        reconnectTask = currentTask;
-        return reconnectTask;
-    };
-    return {
-        async connect() {
-            await beginConnect("connect");
-        },
-        async close() {
-            const currentSocket = socket;
-            const previousManualClose = manualClose;
-            const previousState = state;
-            manualClose = true;
-            if (currentSocket === undefined) {
-                stopConnectionLoops();
-                state = "closed";
-                if (rejectConnect !== undefined) {
-                    rejectConnect(createTransportError("websocket connection closed by supervisor"));
-                    resetPendingConnect();
-                }
-            }
-            else if (currentSocket.readyState < SOCKET_CLOSING) {
-                if (pendingClose?.socket !== currentSocket) {
-                    const deferred = createDeferred();
-                    pendingClose = {
-                        socket: currentSocket,
-                        promise: deferred.promise,
-                        resolve: deferred.resolve,
-                    };
-                }
-                const closePromise = pendingClose.promise;
-                try {
-                    currentSocket.close();
-                }
-                catch (error) {
-                    manualClose = previousManualClose;
-                    state = previousState;
-                    pendingClose = undefined;
-                    throw createTransportError("failed to close websocket", error);
-                }
-                await closePromise;
-            }
-            else if (pendingClose?.socket === currentSocket) {
-                await pendingClose.promise;
-            }
-            else {
-                const deferred = createDeferred();
-                pendingClose = {
-                    socket: currentSocket,
-                    promise: deferred.promise,
-                    resolve: deferred.resolve,
-                };
-                await pendingClose.promise;
-            }
-            try {
-                await reconnectTask;
-            }
-            catch {
-                if (!manualClose) {
-                    throw createTransportError("failed to close websocket supervisor");
-                }
-            }
-            await connectionLoopStopTask;
-        },
-        send(data) {
-            if (socket === undefined || socket.readyState !== SOCKET_OPEN) {
-                throw createTransportError("websocket is not open");
-            }
-            socket.send(data);
-        },
-        getState() {
-            return state;
-        },
-        getLastActivityAt() {
-            return lastActivityAt;
-        },
-    };
-}

package/dist/store/account-store.d.ts

@@ -1,52 +0,0 @@
-export interface AccountBalanceSnapshot {
-    accountId: string;
-    exchange: string;
-    asset: string;
-    free: string;
-    used: string;
-    total: string;
-    seq: number;
-    receivedAt: number;
-    updatedAt: number;
-}
-export interface AccountRiskSnapshot {
-    accountId: string;
-    exchange: string;
-    seq: number;
-    receivedAt: number;
-    updatedAt: number;
-    equity: string;
-}
-export interface AccountPositionSnapshot {
-    accountId: string;
-    exchange: string;
-    symbol: string;
-    side: string;
-    size: string;
-    seq: number;
-    receivedAt: number;
-    updatedAt: number;
-}
-export interface AccountSnapshot {
-    accountId: string;
-    exchange: string;
-    balances: Record<string, AccountBalanceSnapshot>;
-    positions: AccountPositionSnapshot[];
-    risk?: AccountRiskSnapshot;
-    receivedAt: number;
-    updatedAt: number;
-}
-export interface AccountStatus {
-    accountId: string;
-    exchange: string;
-    status: "healthy" | "degraded" | "reconciling";
-    bootstrapCompleted: boolean;
-    unresolvedOrdersCount?: number;
-}
-export interface AccountStore {
-    replaceSnapshot(snapshot: AccountSnapshot): void;
-    getSnapshot(accountId: string): AccountSnapshot | undefined;
-    setStatus(status: AccountStatus): void;
-    getStatus(accountId: string): AccountStatus | undefined;
-}
-export declare function createAccountStore(): AccountStore;

package/dist/store/account-store.js

@@ -1,18 +0,0 @@
-export function createAccountStore() {
-    const snapshots = new Map();
-    const statuses = new Map();
-    return {
-        replaceSnapshot(snapshot) {
-            snapshots.set(snapshot.accountId, snapshot);
-        },
-        getSnapshot(accountId) {
-            return snapshots.get(accountId);
-        },
-        setStatus(status) {
-            statuses.set(status.accountId, status);
-        },
-        getStatus(accountId) {
-            return statuses.get(accountId);
-        },
-    };
-}

package/dist/store/health-store.d.ts

@@ -1,16 +0,0 @@
-import type { ClientStatus } from "../types/public.js";
-export interface HealthSnapshot {
-    clientStatus: ClientStatus;
-    exchanges: Record<string, unknown>;
-    accounts: Record<string, unknown>;
-    orders: Record<string, unknown>;
-    updatedAt: number;
-}
-export interface HealthStore {
-    setClientStatus(status: ClientStatus): void;
-    setExchangeHealth(exchange: string, health: unknown): void;
-    setAccountStatus(accountId: string, status: unknown): void;
-    setOrderStatus(accountId: string, status: unknown): void;
-    snapshot(): HealthSnapshot;
-}
-export declare function createHealthStore(): HealthStore;

package/dist/store/health-store.js

@@ -1,29 +0,0 @@
-export function createHealthStore() {
-    let clientStatus = "idle";
-    const exchanges = new Map();
-    const accounts = new Map();
-    const orders = new Map();
-    return {
-        setClientStatus(status) {
-            clientStatus = status;
-        },
-        setExchangeHealth(exchange, health) {
-            exchanges.set(exchange, health);
-        },
-        setAccountStatus(accountId, status) {
-            accounts.set(accountId, status);
-        },
-        setOrderStatus(accountId, status) {
-            orders.set(accountId, status);
-        },
-        snapshot() {
-            return {
-                clientStatus,
-                exchanges: Object.fromEntries(exchanges),
-                accounts: Object.fromEntries(accounts),
-                orders: Object.fromEntries(orders),
-                updatedAt: Date.now(),
-            };
-        },
-    };
-}

package/dist/store/market-store.d.ts

@@ -1,42 +0,0 @@
-export interface MarketStoreKey {
-    exchange: string;
-    symbol: string;
-}
-export interface MarketDataStatus extends MarketStoreKey {
-    freshness: "fresh" | "stale" | "reconciling";
-    lastStreamReceivedAt?: number;
-    lastBaselineSyncAt?: number;
-    staleSince?: number;
-    reason?: "bootstrap_pending" | "ws_disconnected" | "heartbeat_timeout" | "sequence_gap" | "reconciling";
-}
-export interface L1BookSnapshot extends MarketStoreKey {
-    bidPrice: string;
-    bidSize: string;
-    askPrice: string;
-    askSize: string;
-    exchangeTs?: number;
-    receivedAt: number;
-    updatedAt: number;
-    version: number;
-}
-export interface FundingRateSnapshot extends MarketStoreKey {
-    fundingRate: string;
-    exchangeTs?: number;
-    receivedAt: number;
-    updatedAt: number;
-    version: number;
-}
-export interface MarketSnapshot {
-    l1Book?: L1BookSnapshot;
-    fundingRate?: FundingRateSnapshot;
-}
-export interface MarketStore {
-    upsertL1Book(input: Omit<L1BookSnapshot, "updatedAt" | "version">): L1BookSnapshot;
-    getL1Book(key: MarketStoreKey): L1BookSnapshot | undefined;
-    upsertFundingRate(input: Omit<FundingRateSnapshot, "updatedAt" | "version">): FundingRateSnapshot;
-    getFundingRate(key: MarketStoreKey): FundingRateSnapshot | undefined;
-    getSnapshot(key: MarketStoreKey): MarketSnapshot;
-    setStatus(status: MarketDataStatus): void;
-    getStatus(key: MarketStoreKey): MarketDataStatus | undefined;
-}
-export declare function createMarketStore(): MarketStore;