@imbingox/acex 0.1.0-beta.0

package/dist/adapters/ccxt/binance-usdm-ccxt-adapter.js

@@ -0,0 +1,537 @@
+import { createAsyncQueue } from "../../runtime/async-queue.js";
+export class CcxtBinanceUsdMAdapter {
+    exchange = "binance";
+    capabilities = {
+        publicWs: true,
+        privateWs: true,
+        l1BookStream: true,
+        fundingRateStream: true,
+        accountStream: true,
+        orderStream: true,
+        fetchMarketInfo: true,
+        fetchBalances: true,
+        fetchPositions: true,
+        fetchRisk: true,
+        fetchOpenOrders: true,
+        fetchMyTrades: true,
+        fetchOrderById: true,
+    };
+    #exchange;
+    #started = false;
+    #privateWatchTasks = new Set();
+    #orderSymbolsByClientOrderId = new Map();
+    #orderSymbolsByOrderId = new Map();
+    #marketQueue = createAsyncQueue({ maxBufferSize: 100 });
+    #marketEventSink;
+    #internalErrorQueue = createAsyncQueue({ maxBufferSize: 20 });
+    #orderQueue = createAsyncQueue({ maxBufferSize: 100 });
+    #orderEventSink;
+    #accountQueue = createAsyncQueue({ maxBufferSize: 100 });
+    #accountEventSink;
+    constructor(input) {
+        this.#exchange = input.exchange;
+    }
+    async start() {
+        this.#started = true;
+        const privateStreams = this.#exchange;
+        if (privateStreams.watchOrders !== undefined) {
+            this.#trackPrivateWatchTask(this.#runWatchOrders(privateStreams));
+        }
+        if (privateStreams.watchBalance !== undefined) {
+            this.#trackPrivateWatchTask(this.#runWatchBalance(privateStreams));
+        }
+    }
+    async stop() {
+        this.#started = false;
+        await this.#exchange.close?.();
+        await Promise.allSettled([...this.#privateWatchTasks]);
+        this.#marketQueue.close();
+        this.#internalErrorQueue.close();
+        this.#orderQueue.close();
+        this.#accountQueue.close();
+    }
+    async subscribeL1Book(input) {
+        try {
+            const snapshot = await this.mapTickerToL1(input.symbol);
+            this.#emitMarketEvent({
+                type: "l1_book.updated",
+                exchange: snapshot.exchange,
+                symbol: snapshot.symbol,
+                bidPrice: snapshot.bidPrice,
+                bidSize: snapshot.bidSize,
+                askPrice: snapshot.askPrice,
+                askSize: snapshot.askSize,
+                ...(snapshot.exchangeTs === undefined ? {} : { exchangeTs: snapshot.exchangeTs }),
+                receivedAt: snapshot.receivedAt,
+            });
+        }
+        catch (error) {
+            this.#emitInternalError(asError(error));
+            throw error;
+        }
+    }
+    async subscribeFundingRate(_input) {
+        return;
+    }
+    watchMarketEvents() {
+        return this.#marketQueue;
+    }
+    setMarketEventSink(sink) {
+        this.#marketEventSink = sink;
+    }
+    watchInternalErrors() {
+        return this.#internalErrorQueue;
+    }
+    async subscribeOrders(_input) {
+        return;
+    }
+    watchOrderEvents() {
+        return this.#orderQueue;
+    }
+    setOrderEventSink(sink) {
+        this.#orderEventSink = sink;
+    }
+    watchAccountEvents() {
+        return this.#accountQueue;
+    }
+    setAccountEventSink(sink) {
+        this.#accountEventSink = sink;
+    }
+    async mapTickerToL1(symbol) {
+        const bidsAsks = await this.#exchange.watchBidsAsks([symbol]);
+        const ticker = bidsAsks[symbol];
+        if (ticker === undefined) {
+            throw new Error("missing required ticker fields");
+        }
+        if (ticker.bid === undefined ||
+            ticker.bidVolume === undefined ||
+            ticker.ask === undefined ||
+            ticker.askVolume === undefined) {
+            throw new Error("missing required ticker fields");
+        }
+        return {
+            exchange: this.exchange,
+            symbol: ticker.symbol,
+            bidPrice: String(ticker.bid),
+            bidSize: String(ticker.bidVolume),
+            askPrice: String(ticker.ask),
+            askSize: String(ticker.askVolume),
+            ...(ticker.timestamp === undefined ? {} : { exchangeTs: ticker.timestamp }),
+            receivedAt: Date.now(),
+        };
+    }
+    async fetchMarketInfo() {
+        const markets = await this.#exchange.fetchMarkets();
+        return markets.map((market) => {
+            return {
+                exchange: this.exchange,
+                symbol: market.symbol,
+                baseAsset: market.base,
+                quoteAsset: market.quote,
+                marketType: market.type,
+                pricePrecision: market.precision.price,
+                amountPrecision: market.precision.amount,
+                active: market.active,
+            };
+        });
+    }
+    async fetchOpenOrdersBaseline(accountId) {
+        const now = Date.now();
+        const orders = await this.#exchange.fetchOpenOrders(undefined, undefined, undefined, {
+            type: "future",
+        });
+        return orders.map((order) => {
+            const symbol = requiredString(order.symbol, "symbol");
+            const side = requiredOrderSide(order.side);
+            const type = requiredString(order.type, "type");
+            const status = requiredString(order.status, "status");
+            const amount = valueToRequiredString(order.amount, "amount");
+            const filled = valueToRequiredString(order.filled, "filled");
+            const updatedAt = order.timestamp ?? now;
+            this.#rememberOrderSymbol(withOptionalOrderLocators({
+                symbol,
+                orderId: order.id,
+                clientOrderId: order.clientOrderId,
+            }));
+            return {
+                accountId,
+                exchange: this.exchange,
+                symbol,
+                side,
+                type,
+                status,
+                amount,
+                filled,
+                ...(order.price === undefined ? {} : { price: String(order.price) }),
+                seq: 0,
+                receivedAt: now,
+                updatedAt,
+                ...(order.id === undefined ? {} : { orderId: order.id }),
+                ...(order.clientOrderId === undefined ? {} : { clientOrderId: order.clientOrderId }),
+            };
+        });
+    }
+    async fetchAccountBaseline(accountId) {
+        const now = Date.now();
+        const [balance, positions] = await Promise.all([
+            this.#exchange.fetchBalance({ type: "future" }),
+            this.#exchange.fetchPositions([], { type: "future" }),
+        ]);
+        const assets = new Set([
+            ...Object.keys(balance.free ?? {}),
+            ...Object.keys(balance.used ?? {}),
+            ...Object.keys(balance.total ?? {}),
+        ]);
+        const balances = Object.fromEntries([...assets].map((asset) => [
+            asset,
+            {
+                accountId,
+                exchange: this.exchange,
+                asset,
+                free: valueToString(balance.free?.[asset]),
+                used: valueToString(balance.used?.[asset]),
+                total: valueToString(balance.total?.[asset]),
+                seq: 0,
+                receivedAt: now,
+                updatedAt: now,
+            },
+        ]));
+        const positionsSnapshots = positions.map((position) => {
+            const symbol = requiredString(position.symbol, "symbol", "position fields");
+            const side = requiredString(position.side, "side", "position fields");
+            const size = valueToRequiredString(position.contracts ?? position.amount ?? position.positionAmt, "size", "position fields");
+            const updatedAt = position.timestamp ?? now;
+            return {
+                accountId,
+                exchange: this.exchange,
+                symbol,
+                side,
+                size,
+                seq: 0,
+                receivedAt: now,
+                updatedAt,
+            };
+        });
+        const totalWalletBalance = balance.info?.totalWalletBalance;
+        const risk = totalWalletBalance === undefined
+            ? undefined
+            : {
+                accountId,
+                exchange: this.exchange,
+                seq: 0,
+                receivedAt: now,
+                updatedAt: now,
+                equity: valueToString(totalWalletBalance),
+            };
+        return {
+            balances,
+            positions: positionsSnapshots,
+            ...(risk === undefined ? {} : { risk }),
+        };
+    }
+    async placeOrder(input) {
+        const amount = parseFiniteNumber(input.amount, "amount");
+        if (amount <= 0) {
+            throw new Error("invalid order amount");
+        }
+        const price = input.price === undefined ? undefined : parseFiniteNumber(input.price, "price");
+        if (price !== undefined && price <= 0) {
+            throw new Error("invalid order price");
+        }
+        const orderParams = {
+            type: "future",
+            clientOrderId: input.clientOrderId,
+        };
+        if (input.reduceOnly === true) {
+            orderParams.reduceOnly = true;
+        }
+        const order = await this.#exchange.createOrder(input.symbol, input.type, input.side, amount, price, orderParams);
+        this.#rememberOrderSymbol(withOptionalOrderLocators({
+            symbol: input.symbol,
+            orderId: order.id,
+            clientOrderId: order.clientOrderId ?? input.clientOrderId,
+        }));
+        return {
+            ...(order.clientOrderId === undefined
+                ? { clientOrderId: input.clientOrderId }
+                : { clientOrderId: String(order.clientOrderId) }),
+            ...(order.id === undefined ? {} : { orderId: String(order.id) }),
+            receivedAt: Date.now(),
+        };
+    }
+    async amendOrder(input) {
+        return {
+            ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+            ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+            receivedAt: Date.now(),
+        };
+    }
+    async cancelOrder(input) {
+        if (input.orderId === undefined && input.clientOrderId === undefined) {
+            return {
+                receivedAt: Date.now(),
+            };
+        }
+        const privateStreams = this.#exchange;
+        if (privateStreams.cancelOrder !== undefined) {
+            const symbol = this.#resolveOrderSymbol(withOptionalOrderLocators({
+                symbol: undefined,
+                orderId: input.orderId,
+                clientOrderId: input.clientOrderId,
+            }));
+            const params = { type: "future" };
+            if (input.clientOrderId !== undefined) {
+                params.clientOrderId = input.clientOrderId;
+            }
+            const result = await privateStreams.cancelOrder(input.orderId, symbol, params);
+            this.#rememberOrderSymbol(withOptionalOrderLocators({
+                symbol: result.symbol ?? symbol,
+                orderId: result.id ?? input.orderId,
+                clientOrderId: result.clientOrderId ?? input.clientOrderId,
+            }));
+            return {
+                ...(result.clientOrderId === undefined
+                    ? input.clientOrderId === undefined
+                        ? {}
+                        : { clientOrderId: input.clientOrderId }
+                    : { clientOrderId: String(result.clientOrderId) }),
+                ...(result.id === undefined
+                    ? input.orderId === undefined
+                        ? {}
+                        : { orderId: input.orderId }
+                    : { orderId: String(result.id) }),
+                receivedAt: Date.now(),
+            };
+        }
+        return {
+            ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+            ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+            receivedAt: Date.now(),
+        };
+    }
+    async cancelAllOrders(_input) {
+        return {
+            accountId: _input.accountId,
+            exchange: this.exchange,
+            canceledCount: 0,
+        };
+    }
+    #emitMarketEvent(event) {
+        if (this.#marketEventSink !== undefined) {
+            this.#marketEventSink(event);
+            return;
+        }
+        this.#marketQueue.push(event);
+    }
+    #emitOrderEvent(event) {
+        if (this.#orderEventSink !== undefined) {
+            this.#orderEventSink(event);
+            return;
+        }
+        this.#orderQueue.push(event);
+    }
+    #emitAccountEvent(event) {
+        if (this.#accountEventSink !== undefined) {
+            this.#accountEventSink(event);
+            return;
+        }
+        this.#accountQueue.push(event);
+    }
+    #emitInternalError(error) {
+        this.#internalErrorQueue.push(error);
+    }
+    #trackPrivateWatchTask(task) {
+        this.#privateWatchTasks.add(task);
+        void task.finally(() => {
+            this.#privateWatchTasks.delete(task);
+        });
+    }
+    #rememberOrderSymbol(input) {
+        if (input.symbol === undefined) {
+            return;
+        }
+        if (input.orderId !== undefined) {
+            this.#orderSymbolsByOrderId.set(String(input.orderId), input.symbol);
+        }
+        if (input.clientOrderId !== undefined) {
+            this.#orderSymbolsByClientOrderId.set(String(input.clientOrderId), input.symbol);
+        }
+    }
+    #resolveOrderSymbol(input) {
+        if (input.orderId !== undefined) {
+            const symbol = this.#orderSymbolsByOrderId.get(input.orderId);
+            if (symbol !== undefined) {
+                return symbol;
+            }
+        }
+        if (input.clientOrderId !== undefined) {
+            return this.#orderSymbolsByClientOrderId.get(input.clientOrderId);
+        }
+        return undefined;
+    }
+    async #runWatchOrders(privateStreams) {
+        while (this.#started) {
+            try {
+                const orders = await privateStreams.watchOrders?.();
+                if (!this.#started) {
+                    return;
+                }
+                this.#emitOrdersFromWatch(orders ?? []);
+            }
+            catch (error) {
+                if (!this.#started) {
+                    return;
+                }
+                this.#started = false;
+                this.#emitInternalError(asError(error));
+                return;
+            }
+        }
+    }
+    async #runWatchBalance(privateStreams) {
+        while (this.#started) {
+            try {
+                const balance = await privateStreams.watchBalance?.();
+                if (!this.#started) {
+                    return;
+                }
+                this.#emitBalanceFromWatch(balance);
+            }
+            catch (error) {
+                if (!this.#started) {
+                    return;
+                }
+                this.#started = false;
+                this.#emitInternalError(asError(error));
+                return;
+            }
+        }
+    }
+    #emitOrdersFromWatch(orders) {
+        for (const order of orders) {
+            try {
+                const now = Date.now();
+                const symbol = requiredString(order.symbol, "symbol", "watchOrders");
+                const side = requiredOrderSide(order.side, "watchOrders");
+                const type = requiredString(order.type, "type", "watchOrders");
+                const status = requiredString(order.status, "status", "watchOrders");
+                const amount = valueToRequiredString(order.amount, "amount", "watchOrders");
+                const filled = valueToString(order.filled);
+                const normalizedStatus = status.toLowerCase();
+                this.#rememberOrderSymbol(withOptionalOrderLocators({
+                    symbol,
+                    orderId: order.id,
+                    clientOrderId: order.clientOrderId,
+                }));
+                const eventType = normalizedStatus === "canceled" || normalizedStatus === "cancelled"
+                    ? "order.canceled"
+                    : "order.updated";
+                this.#emitOrderEvent({
+                    type: eventType,
+                    accountId: "main",
+                    exchange: this.exchange,
+                    receivedAt: now,
+                    snapshot: {
+                        accountId: "main",
+                        exchange: this.exchange,
+                        symbol,
+                        side,
+                        type,
+                        status,
+                        amount,
+                        filled,
+                        ...(order.price === undefined ? {} : { price: String(order.price) }),
+                        seq: 0,
+                        receivedAt: now,
+                        updatedAt: Number(order.timestamp ?? now),
+                        ...(order.id === undefined ? {} : { orderId: String(order.id) }),
+                        ...(order.clientOrderId === undefined
+                            ? {}
+                            : { clientOrderId: String(order.clientOrderId) }),
+                    },
+                });
+            }
+            catch (error) {
+                this.#emitInternalError(asError(error));
+            }
+        }
+    }
+    #emitBalanceFromWatch(balance) {
+        if (balance === undefined) {
+            return;
+        }
+        const now = Date.now();
+        const assets = new Set([
+            ...Object.keys(balance.free ?? {}),
+            ...Object.keys(balance.used ?? {}),
+            ...Object.keys(balance.total ?? {}),
+        ]);
+        for (const asset of assets) {
+            this.#emitAccountEvent({
+                type: "balance.updated",
+                accountId: "main",
+                exchange: this.exchange,
+                asset,
+                snapshot: {
+                    accountId: "main",
+                    exchange: this.exchange,
+                    asset,
+                    free: valueToString(balance.free?.[asset]),
+                    used: valueToString(balance.used?.[asset]),
+                    total: valueToString(balance.total?.[asset]),
+                    seq: 0,
+                    receivedAt: now,
+                    updatedAt: now,
+                },
+            });
+        }
+    }
+    getHealth() {
+        return {
+            exchange: this.exchange,
+            status: this.#started ? "healthy" : "idle",
+            wsConnected: this.#started,
+        };
+    }
+}
+function withOptionalOrderLocators(input) {
+    return {
+        ...(input.symbol === undefined ? {} : { symbol: input.symbol }),
+        ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+        ...(input.clientOrderId === undefined ? {} : { clientOrderId: input.clientOrderId }),
+    };
+}
+function requiredString(value, field, context = "order fields") {
+    if (value === undefined || value.trim().length === 0) {
+        throw new Error(`missing required ${context}: ${field}`);
+    }
+    return value;
+}
+function requiredOrderSide(value, context = "order fields") {
+    if (value !== "buy" && value !== "sell") {
+        throw new Error(`missing required ${context}: side`);
+    }
+    return value;
+}
+function valueToRequiredString(value, field, context = "order fields") {
+    if (value === undefined) {
+        throw new Error(`missing required ${context}: ${field}`);
+    }
+    return String(value);
+}
+function valueToString(value) {
+    return value === undefined ? "0" : String(value);
+}
+function parseFiniteNumber(value, field) {
+    if (value.trim().length === 0) {
+        throw new Error(`invalid order ${field}`);
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`invalid order ${field}`);
+    }
+    return parsed;
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}

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

@@ -0,0 +1,130 @@
+import type { AdapterAccountBaseline, ExchangeAdapter, NormalizedAccountEvent, NormalizedMarketEvent, NormalizedOrderEvent } from "../types.js";
+export declare class FakeAsterAdapter implements ExchangeAdapter {
+    #private;
+    readonly exchange = "aster";
+    readonly capabilities: {
+        publicWs: boolean;
+        privateWs: boolean;
+        l1BookStream: boolean;
+        fundingRateStream: boolean;
+        accountStream: boolean;
+        orderStream: boolean;
+        fetchMarketInfo: boolean;
+        fetchBalances: boolean;
+        fetchPositions: boolean;
+        fetchRisk: boolean;
+        fetchOpenOrders: boolean;
+        fetchMyTrades: boolean;
+        fetchOrderById: boolean;
+    };
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    subscribeL1Book(): Promise<void>;
+    subscribeFundingRate(): Promise<void>;
+    watchMarketEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedMarketEvent>;
+    setMarketEventSink(sink: ((event: NormalizedMarketEvent) => void) | undefined): void;
+    emitL1Book(event: Extract<NormalizedMarketEvent, {
+        type: "l1_book.updated";
+    }>): void;
+    emitFundingRate(event: Extract<NormalizedMarketEvent, {
+        type: "funding_rate.updated";
+    }>): void;
+    emitMarketDisconnect(input: {
+        exchange: string;
+        symbol: string;
+    }): void;
+    emitMarketReconnect(input: {
+        exchange: string;
+        symbol: string;
+    }): void;
+    watchInternalErrors(): import("../../runtime/async-queue.js").AsyncQueue<Error>;
+    emitInternalError(error: Error): void;
+    subscribeOrders(): Promise<void>;
+    setAccountBaseline(accountId: string, baseline: AdapterAccountBaseline): void;
+    fetchAccountBaseline(accountId: string): Promise<AdapterAccountBaseline>;
+    watchAccountEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedAccountEvent>;
+    setAccountEventSink(sink: ((event: NormalizedAccountEvent) => void) | undefined): void;
+    emitBalanceUpdate(event: Omit<NormalizedAccountEvent, "type">): void;
+    fetchOpenOrdersBaseline(accountId: string): Promise<({
+        accountId: string;
+        exchange: string;
+        symbol: string;
+        side: "buy" | "sell";
+        type: string;
+        status: string;
+        amount: string;
+        filled: string;
+        price?: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+        orderId?: string;
+        clientOrderId?: string;
+    } | {
+        accountId: string;
+        exchange: string;
+        symbol: string;
+        side: "buy" | "sell";
+        type: string;
+        status: string;
+        amount: string;
+        filled: string;
+        price?: string;
+        seq: number;
+        receivedAt: number;
+        updatedAt: number;
+        orderId?: string;
+        clientOrderId?: string;
+    })[]>;
+    watchOrderEvents(): import("../../runtime/async-queue.js").AsyncQueue<NormalizedOrderEvent>;
+    setOrderEventSink(sink: ((event: NormalizedOrderEvent) => void) | undefined): void;
+    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;
+        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;
+    };
+}