@imbingox/acex 0.1.0 → 0.2.0

package/dist/adapters/binance/symbol-router.js

@@ -1,174 +0,0 @@
-import { createAcexError } from "../../errors/acex-error.js";
-function keyFor(family, nativeSymbol) {
-    return `${family}:${nativeSymbol}`;
-}
-function createInvalidMetadataError(message) {
-    return createAcexError({
-        code: "VALIDATION_ERROR",
-        message: `invalid binance market metadata: ${message}`,
-        retryable: false,
-        exchange: "binance",
-    });
-}
-function createDuplicateSymbolError(message) {
-    return createAcexError({
-        code: "VALIDATION_ERROR",
-        message: `duplicate binance market symbol: ${message}`,
-        retryable: false,
-        exchange: "binance",
-    });
-}
-function getFilterValue(filters, filterType, key) {
-    return filters.find((filter) => filter.filterType === filterType)?.[key];
-}
-function parseTickOrStepSize(filters, nativeSymbol, filterType, key) {
-    const value = getFilterValue(filters, filterType, key);
-    if (value === undefined) {
-        throw createInvalidMetadataError(`missing ${filterType}.${key} for ${nativeSymbol}`);
-    }
-    const parsedSize = Number(value);
-    if (!Number.isFinite(parsedSize) || parsedSize <= 0) {
-        throw createInvalidMetadataError(`invalid ${filterType}.${key} for ${nativeSymbol}: ${value}`);
-    }
-    return parsedSize;
-}
-function parseDeliveryDateSuffix(nativeSymbol, deliveryDate) {
-    if (deliveryDate === undefined) {
-        throw createInvalidMetadataError(`missing delivery suffix for ${nativeSymbol}`);
-    }
-    if (!Number.isInteger(deliveryDate) ||
-        deliveryDate < 1_000_000_000_000 ||
-        deliveryDate > 10_000_000_000_000) {
-        throw createInvalidMetadataError(`invalid deliveryDate for ${nativeSymbol}: ${deliveryDate}`);
-    }
-    const delivery = new Date(deliveryDate);
-    if (Number.isNaN(delivery.getTime())) {
-        throw createInvalidMetadataError(`invalid deliveryDate for ${nativeSymbol}: ${deliveryDate}`);
-    }
-    const year = String(delivery.getUTCFullYear()).slice(-2);
-    const month = String(delivery.getUTCMonth() + 1).padStart(2, "0");
-    const day = String(delivery.getUTCDate()).padStart(2, "0");
-    return `${year}${month}${day}`;
-}
-function toDeliverySuffix(nativeSymbol, deliveryDate) {
-    const nativeSuffix = nativeSymbol.match(/_(\d{6})$/)?.[1];
-    const deliveryDateSuffix = deliveryDate === undefined ? undefined : parseDeliveryDateSuffix(nativeSymbol, deliveryDate);
-    if (nativeSuffix !== undefined) {
-        if (deliveryDateSuffix !== undefined && deliveryDateSuffix !== nativeSuffix) {
-            throw createInvalidMetadataError(`deliveryDate does not match native suffix for ${nativeSymbol}: ${deliveryDateSuffix} !== ${nativeSuffix}`);
-        }
-        return `-${nativeSuffix}`;
-    }
-    if (deliveryDateSuffix !== undefined) {
-        return `-${deliveryDateSuffix}`;
-    }
-    throw createInvalidMetadataError(`missing delivery suffix for ${nativeSymbol}`);
-}
-function createMarketMaps(markets) {
-    const byUnifiedSymbol = new Map();
-    const byNativeSymbol = new Map();
-    for (const record of markets) {
-        if (byUnifiedSymbol.has(record.unifiedSymbol)) {
-            throw createDuplicateSymbolError(record.unifiedSymbol);
-        }
-        const nativeKey = keyFor(record.family, record.nativeSymbol);
-        if (byNativeSymbol.has(nativeKey)) {
-            throw createDuplicateSymbolError(nativeKey);
-        }
-        byUnifiedSymbol.set(record.unifiedSymbol, record);
-        byNativeSymbol.set(nativeKey, record);
-    }
-    return {
-        byUnifiedSymbol,
-        byNativeSymbol,
-    };
-}
-function buildSpotRecord(symbol) {
-    return {
-        exchange: "binance",
-        family: "spot",
-        nativeSymbol: symbol.symbol,
-        unifiedSymbol: `${symbol.baseAsset}/${symbol.quoteAsset}`,
-        baseAsset: symbol.baseAsset,
-        quoteAsset: symbol.quoteAsset,
-        fundingEligible: false,
-        active: symbol.status === "TRADING",
-        pricePrecision: parseTickOrStepSize(symbol.filters, symbol.symbol, "PRICE_FILTER", "tickSize"),
-        amountPrecision: parseTickOrStepSize(symbol.filters, symbol.symbol, "LOT_SIZE", "stepSize"),
-    };
-}
-function buildUsdmRecord(symbol) {
-    return {
-        exchange: "binance",
-        family: "usdm",
-        nativeSymbol: symbol.symbol,
-        unifiedSymbol: `${symbol.baseAsset}/${symbol.quoteAsset}:${symbol.marginAsset}`,
-        baseAsset: symbol.baseAsset,
-        quoteAsset: symbol.quoteAsset,
-        settleAsset: symbol.marginAsset,
-        contractType: symbol.contractType,
-        fundingEligible: symbol.contractType === "PERPETUAL",
-        active: symbol.status === "TRADING",
-        pricePrecision: parseTickOrStepSize(symbol.filters, symbol.symbol, "PRICE_FILTER", "tickSize"),
-        amountPrecision: parseTickOrStepSize(symbol.filters, symbol.symbol, "LOT_SIZE", "stepSize"),
-    };
-}
-function buildCoinmRecord(symbol) {
-    const isPerpetual = symbol.contractType === "PERPETUAL";
-    const deliverySuffix = isPerpetual ? "" : toDeliverySuffix(symbol.symbol, symbol.deliveryDate);
-    const settleSegment = `${symbol.marginAsset}${deliverySuffix}`;
-    return {
-        exchange: "binance",
-        family: "coinm",
-        nativeSymbol: symbol.symbol,
-        unifiedSymbol: `${symbol.baseAsset}/${symbol.quoteAsset}:${settleSegment}`,
-        baseAsset: symbol.baseAsset,
-        quoteAsset: symbol.quoteAsset,
-        settleAsset: symbol.marginAsset,
-        contractType: symbol.contractType,
-        fundingEligible: symbol.contractType === "PERPETUAL",
-        active: symbol.contractStatus === "TRADING",
-        pricePrecision: parseTickOrStepSize(symbol.filters, symbol.symbol, "PRICE_FILTER", "tickSize"),
-        amountPrecision: parseTickOrStepSize(symbol.filters, symbol.symbol, "LOT_SIZE", "stepSize"),
-    };
-}
-export function buildBinanceMarketIndex(input) {
-    const markets = [
-        ...input.spot.symbols.map(buildSpotRecord),
-        ...input.usdm.symbols.map(buildUsdmRecord),
-        ...input.coinm.symbols.map(buildCoinmRecord),
-    ];
-    const maps = createMarketMaps(markets);
-    return {
-        markets,
-        byUnifiedSymbol: maps.byUnifiedSymbol,
-        byNativeSymbol: maps.byNativeSymbol,
-    };
-}
-export function requireMarketRecord(index, unifiedSymbol) {
-    const record = index.byUnifiedSymbol.get(unifiedSymbol);
-    if (record === undefined) {
-        throw createAcexError({
-            code: "VALIDATION_ERROR",
-            message: `unsupported binance market symbol: ${unifiedSymbol}`,
-            retryable: false,
-            exchange: "binance",
-        });
-    }
-    return record;
-}
-export function requireFundingMarketRecord(index, unifiedSymbol) {
-    const record = requireMarketRecord(index, unifiedSymbol);
-    if (!record.fundingEligible) {
-        throw createAcexError({
-            code: "CAPABILITY_NOT_SUPPORTED",
-            message: "funding rate is not supported for spot or delivery markets",
-            retryable: false,
-            exchange: "binance",
-        });
-    }
-    return record;
-}
-export function getRecordByNativeSymbol(index, family, nativeSymbol) {
-    return index.byNativeSymbol.get(keyFor(family, nativeSymbol));
-}

package/dist/adapters/binance/ws-client.d.ts

@@ -1,24 +0,0 @@
-import { type WsSocketLike } from "../../runtime/ws-connection-supervisor.js";
-import type { BinanceMarketFamily } from "./market-types.js";
-export interface BinanceWsSocketLike extends WsSocketLike {
-    send(data: string): void;
-}
-export interface BinanceMarketWsTransport {
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    ensureSubscribed(stream: string): Promise<void>;
-}
-export interface CreateBinanceMarketWsTransportInput {
-    family: BinanceMarketFamily;
-    createSocket: (url: string) => BinanceWsSocketLike;
-    url?: string;
-    onMessage?: (payload: unknown) => void;
-    onClose?: () => void;
-    onReconnect?: () => void | Promise<void>;
-    reconnectDelayMs?: number;
-    heartbeatIntervalMs?: number;
-    idleTimeoutMs?: number;
-    now?: () => number;
-    sleepImpl?: (ms: number) => Promise<void>;
-}
-export declare function createBinanceMarketWsTransport(input: CreateBinanceMarketWsTransportInput): BinanceMarketWsTransport;

package/dist/adapters/binance/ws-client.js

@@ -1,261 +0,0 @@
-import { createAcexError, isAcexError } from "../../errors/acex-error.js";
-import { createWsConnectionSupervisor, } from "../../runtime/ws-connection-supervisor.js";
-const DEFAULT_WS_URLS = {
-    spot: "wss://stream.binance.com:9443/ws",
-    usdm: "wss://fstream.binance.com/ws",
-    coinm: "wss://dstream.binance.com/ws",
-};
-function toMessageString(data) {
-    if (typeof data === "string") {
-        return data;
-    }
-    if (data instanceof ArrayBuffer) {
-        return Buffer.from(data).toString("utf8");
-    }
-    return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
-}
-function createTransportError(message, cause) {
-    return createAcexError({
-        code: "TRANSPORT_UNAVAILABLE",
-        message,
-        retryable: true,
-        exchange: "binance",
-        ...(cause === undefined ? {} : { cause }),
-    });
-}
-function toTransportError(message, cause) {
-    if (isAcexError(cause) && cause.exchange === "binance") {
-        return cause;
-    }
-    return createTransportError(message, cause);
-}
-function isSocketNotOpenError(error) {
-    return (isAcexError(error) &&
-        error.code === "TRANSPORT_UNAVAILABLE" &&
-        error.exchange === undefined &&
-        error.message === "websocket is not open");
-}
-export function createBinanceMarketWsTransport(input) {
-    const url = input.url ?? DEFAULT_WS_URLS[input.family];
-    const reconnectDelayMs = input.reconnectDelayMs ?? 250;
-    const sleep = input.sleepImpl ??
-        ((ms) => {
-            return new Promise((resolve) => setTimeout(resolve, ms));
-        });
-    const subscribed = new Set();
-    const pendingSubscriptions = new Set();
-    const inFlightSubscriptions = new Map();
-    const subscriptionErrors = new Map();
-    let requestId = 1;
-    let manualClose = false;
-    let awaitingReconnect = false;
-    let recoveryAttempts = 0;
-    let reconnectRecoveryTask;
-    const sendSubscribe = (stream) => {
-        try {
-            supervisor.send(JSON.stringify({
-                method: "SUBSCRIBE",
-                params: [stream],
-                id: requestId++,
-            }));
-            subscribed.add(stream);
-            pendingSubscriptions.delete(stream);
-            subscriptionErrors.delete(stream);
-        }
-        catch (error) {
-            if (isSocketNotOpenError(error)) {
-                pendingSubscriptions.add(stream);
-                return;
-            }
-            const transportError = createTransportError(`failed to subscribe binance ${input.family} stream: ${stream}`, error);
-            subscribed.delete(stream);
-            pendingSubscriptions.delete(stream);
-            subscriptionErrors.set(stream, transportError);
-            throw transportError;
-        }
-    };
-    const restoreDesiredSubscriptions = () => {
-        const desiredSubscriptions = new Set([...pendingSubscriptions, ...subscribed]);
-        pendingSubscriptions.clear();
-        for (const stream of desiredSubscriptions) {
-            pendingSubscriptions.add(stream);
-        }
-    };
-    const flushPendingSubscriptions = () => {
-        for (const stream of [...pendingSubscriptions]) {
-            try {
-                sendSubscribe(stream);
-            }
-            catch { }
-        }
-    };
-    const completeReconnect = async () => {
-        restoreDesiredSubscriptions();
-        flushPendingSubscriptions();
-        if (!awaitingReconnect) {
-            return;
-        }
-        if (supervisor.getState() !== "open" || pendingSubscriptions.size > 0) {
-            scheduleReconnectRecovery();
-            return;
-        }
-        awaitingReconnect = false;
-        recoveryAttempts = 0;
-        await input.onReconnect?.();
-    };
-    const hasDesiredStreams = () => {
-        return subscribed.size > 0 || pendingSubscriptions.size > 0 || inFlightSubscriptions.size > 0;
-    };
-    const connectViaSupervisor = async () => {
-        manualClose = false;
-        try {
-            await supervisor.connect();
-        }
-        catch (error) {
-            throw toTransportError(`failed to connect binance ${input.family} websocket`, error);
-        }
-    };
-    const recoveryDelayMs = () => {
-        const uncappedDelay = reconnectDelayMs * 2 ** recoveryAttempts;
-        const cappedDelay = Math.min(uncappedDelay, Math.max(reconnectDelayMs, 5_000));
-        const spread = Math.floor(cappedDelay * 0.2);
-        const jitterDelta = Math.floor(Math.random() * (spread * 2 + 1)) - spread;
-        return Math.max(0, cappedDelay + jitterDelta);
-    };
-    const scheduleReconnectRecovery = () => {
-        if (reconnectRecoveryTask !== undefined ||
-            manualClose ||
-            !awaitingReconnect ||
-            !hasDesiredStreams()) {
-            return;
-        }
-        reconnectRecoveryTask = (async () => {
-            try {
-                while (!manualClose && awaitingReconnect && hasDesiredStreams()) {
-                    await sleep(recoveryDelayMs());
-                    if (manualClose || !awaitingReconnect || !hasDesiredStreams()) {
-                        return;
-                    }
-                    recoveryAttempts += 1;
-                    restoreDesiredSubscriptions();
-                    try {
-                        await supervisor.connect();
-                    }
-                    catch {
-                        continue;
-                    }
-                    if (manualClose || !awaitingReconnect) {
-                        return;
-                    }
-                    await completeReconnect();
-                    if (!awaitingReconnect) {
-                        return;
-                    }
-                }
-            }
-            finally {
-                reconnectRecoveryTask = undefined;
-            }
-        })();
-    };
-    const supervisor = createWsConnectionSupervisor({
-        createSocket: () => input.createSocket(url),
-        heartbeat: {
-            kind: "native_ping_pong",
-            heartbeatIntervalMs: input.heartbeatIntervalMs ?? 10_000,
-            idleTimeoutMs: input.idleTimeoutMs ?? 30_000,
-        },
-        backoff: {
-            baseDelayMs: input.reconnectDelayMs ?? 250,
-            maxDelayMs: Math.max(input.reconnectDelayMs ?? 250, 5_000),
-            jitter: true,
-        },
-        ...(input.now === undefined ? {} : { now: input.now }),
-        ...(input.sleepImpl === undefined ? {} : { sleep: input.sleepImpl }),
-        onMessage(event) {
-            const raw = toMessageString(event.data);
-            try {
-                const parsed = JSON.parse(raw);
-                const payload = typeof parsed === "object" && parsed !== null && "data" in parsed
-                    ? parsed.data
-                    : parsed;
-                input.onMessage?.(payload);
-            }
-            catch {
-                return;
-            }
-        },
-        onDisconnect() {
-            awaitingReconnect = true;
-            input.onClose?.();
-        },
-        async onReconnect() {
-            await completeReconnect();
-        },
-        onError() {
-            queueMicrotask(() => {
-                if (supervisor.getState() === "idle") {
-                    scheduleReconnectRecovery();
-                }
-            });
-        },
-    });
-    return {
-        async connect() {
-            if (supervisor.getState() === "open") {
-                return;
-            }
-            restoreDesiredSubscriptions();
-            await connectViaSupervisor();
-            await completeReconnect();
-        },
-        async close() {
-            manualClose = true;
-            awaitingReconnect = false;
-            try {
-                await supervisor.close();
-            }
-            catch (error) {
-                throw toTransportError(`failed to close binance ${input.family} websocket`, error);
-            }
-        },
-        async ensureSubscribed(stream) {
-            if (subscribed.has(stream)) {
-                return;
-            }
-            const existing = inFlightSubscriptions.get(stream);
-            if (existing !== undefined) {
-                await existing;
-                return;
-            }
-            const task = (async () => {
-                pendingSubscriptions.add(stream);
-                if (awaitingReconnect) {
-                    restoreDesiredSubscriptions();
-                }
-                await connectViaSupervisor();
-                if (!subscribed.has(stream)) {
-                    if (awaitingReconnect) {
-                        await completeReconnect();
-                        return;
-                    }
-                    if (pendingSubscriptions.has(stream)) {
-                        sendSubscribe(stream);
-                        return;
-                    }
-                    const error = subscriptionErrors.get(stream);
-                    if (error !== undefined) {
-                        throw error;
-                    }
-                }
-            })();
-            inFlightSubscriptions.set(stream, task);
-            try {
-                await task;
-            }
-            finally {
-                inFlightSubscriptions.delete(stream);
-            }
-        },
-    };
-}

package/dist/adapters/ccxt/aster-ccxt-adapter.d.ts

@@ -1,157 +0,0 @@
-import type { AdapterAccountBaseline, ExchangeCapabilities, NormalizedAccountEvent, NormalizedMarketEvent, NormalizedOrderEvent } from "../types.js";
-interface CcxtTickerLike {
-    symbol: string;
-    bid: number | string | undefined;
-    bidVolume: number | string | undefined;
-    ask: number | string | undefined;
-    askVolume: number | string | undefined;
-    timestamp?: number;
-}
-interface CcxtMarketLike {
-    symbol: string;
-    base: string;
-    quote: string;
-    type: string;
-    precision: {
-        price: number;
-        amount: number;
-    };
-    active: boolean;
-}
-interface CcxtOrderLike {
-    id?: string;
-    clientOrderId?: string;
-    symbol?: string;
-    side?: string;
-    type?: string;
-    status?: string;
-    amount?: number | string;
-    filled?: number | string;
-    price?: number | string;
-    timestamp?: number;
-}
-interface CcxtBalanceLike {
-    free?: Record<string, number | string | undefined>;
-    used?: Record<string, number | string | undefined>;
-    total?: Record<string, number | string | undefined>;
-}
-interface CcxtExchangeLike {
-    watchTicker(symbol: string): Promise<CcxtTickerLike>;
-    fetchMarkets(): Promise<CcxtMarketLike[]>;
-    fetchBalance(params?: Record<string, unknown>): Promise<CcxtBalanceLike>;
-    fetchOpenOrders(symbol?: string, since?: number, limit?: number, params?: Record<string, unknown>): Promise<CcxtOrderLike[]>;
-    createOrder(symbol: string, type: string, side: "buy" | "sell", amount: number, price?: number, params?: Record<string, unknown>): Promise<CcxtOrderLike>;
-    cancelOrder(id?: string, symbol?: string, params?: Record<string, unknown>): Promise<CcxtOrderLike>;
-}
-export interface CreateCcxtAsterAdapterInput {
-    exchange: CcxtExchangeLike;
-}
-export declare class CcxtAsterAdapter {
-    #private;
-    readonly exchange = "aster";
-    readonly capabilities: ExchangeCapabilities;
-    constructor(input: CreateCcxtAsterAdapterInput);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    subscribeL1Book(input: {
-        exchange: string;
-        symbol: string;
-    }): Promise<void>;
-    subscribeFundingRate(): Promise<void>;
-    watchMarketEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedMarketEvent>;
-    setMarketEventSink(sink: ((event: NormalizedMarketEvent) => void) | undefined): void;
-    watchInternalErrors(): import("../../runtime/async-queue.js").AsyncQueue<Error>;
-    subscribeOrders(): Promise<void>;
-    watchOrderEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedOrderEvent>;
-    setOrderEventSink(sink: ((event: NormalizedOrderEvent) => void) | undefined): void;
-    watchAccountEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedAccountEvent>;
-    setAccountEventSink(sink: ((event: NormalizedAccountEvent) => void) | undefined): void;
-    mapTickerToL1(symbol: string): Promise<{
-        receivedAt: number;
-        exchangeTs?: number;
-        exchange: string;
-        symbol: string;
-        bidPrice: string;
-        bidSize: string;
-        askPrice: string;
-        askSize: string;
-    }>;
-    fetchMarketInfo(): Promise<{
-        exchange: string;
-        symbol: string;
-        baseAsset: string;
-        quoteAsset: string;
-        marketType: string;
-        pricePrecision: number;
-        amountPrecision: number;
-        active: boolean;
-    }[]>;
-    fetchAccountBaseline(accountId: string): Promise<AdapterAccountBaseline>;
-    fetchOpenOrdersBaseline(accountId: string): Promise<{
-        clientOrderId?: string;
-        orderId?: string;
-        seq: number;
-        receivedAt: number;
-        updatedAt: number;
-        price?: string;
-        accountId: string;
-        exchange: string;
-        symbol: string;
-        side: "buy" | "sell";
-        type: string;
-        status: string;
-        amount: string;
-        filled: string;
-    }[]>;
-    placeOrder(input: {
-        accountId: string;
-        exchange: string;
-        symbol: string;
-        side: "buy" | "sell";
-        amount: string;
-        clientOrderId: string;
-        type: string;
-        price?: string;
-        reduceOnly?: boolean;
-    }): Promise<{
-        receivedAt: number;
-        orderId?: string;
-        clientOrderId: string;
-    }>;
-    amendOrder(input: {
-        accountId: string;
-        exchange: string;
-        clientOrderId?: string;
-        orderId?: string;
-        symbol?: string;
-        newPrice?: string;
-    }): Promise<{
-        receivedAt: number;
-        orderId?: string;
-        clientOrderId?: string;
-    }>;
-    cancelOrder(input: {
-        accountId: string;
-        exchange: string;
-        clientOrderId?: string;
-        orderId?: string;
-    }): Promise<{
-        receivedAt: number;
-        orderId?: string;
-        clientOrderId?: string;
-    }>;
-    cancelAllOrders(input: {
-        accountId: string;
-        exchange: string;
-    }): Promise<{
-        accountId: string;
-        exchange: string;
-        canceledCount: number;
-    }>;
-    getHealth(): {
-        exchange: string;
-        status: string;
-        wsConnected: boolean;
-    };
-}
-export {};