@imbingox/acex 0.1.0-beta.0 → 0.1.0-beta.2

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

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

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