@imbingox/acex 0.1.0-beta.0 → 0.1.0

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

@@ -0,0 +1,17 @@
+import type { BinanceCoinmExchangeInfo, BinanceSpotExchangeInfo, BinanceUsdmExchangeInfo } from "./market-types.js";
+export interface BinanceMarketRestClient {
+    fetchAllExchangeInfo(): Promise<{
+        spot: BinanceSpotExchangeInfo;
+        usdm: BinanceUsdmExchangeInfo;
+        coinm: BinanceCoinmExchangeInfo;
+    }>;
+}
+export interface CreateBinanceMarketRestClientInput {
+    fetchImpl?: typeof fetch;
+    baseUrls?: {
+        spot: string;
+        usdm: string;
+        coinm: string;
+    };
+}
+export declare function createBinanceMarketRestClient(input?: CreateBinanceMarketRestClientInput): BinanceMarketRestClient;

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

@@ -0,0 +1,66 @@
+import { createAcexError } from "../../errors/acex-error.js";
+const DEFAULT_BASE_URLS = {
+    spot: "https://api.binance.com",
+    usdm: "https://fapi.binance.com",
+    coinm: "https://dapi.binance.com",
+};
+function createTransportError(message, cause) {
+    return createAcexError({
+        code: "TRANSPORT_UNAVAILABLE",
+        message,
+        retryable: true,
+        exchange: "binance",
+        ...(cause === undefined ? {} : { cause }),
+    });
+}
+function createPayloadError(message, cause) {
+    return createAcexError({
+        code: "VALIDATION_ERROR",
+        message,
+        retryable: false,
+        exchange: "binance",
+        ...(cause === undefined ? {} : { cause }),
+    });
+}
+export function createBinanceMarketRestClient(input = {}) {
+    const fetchImpl = input.fetchImpl ?? fetch;
+    const baseUrls = input.baseUrls ?? DEFAULT_BASE_URLS;
+    async function getJson(url) {
+        let response;
+        try {
+            response = await fetchImpl(url);
+        }
+        catch (error) {
+            throw createTransportError(`binance market metadata request failed: ${url}`, error);
+        }
+        if (!response.ok) {
+            throw createTransportError(`binance market metadata request failed: ${url} (${response.status})`);
+        }
+        try {
+            return (await response.json());
+        }
+        catch (error) {
+            throw createPayloadError(`invalid binance market metadata payload: ${url}`, error);
+        }
+    }
+    function requireSymbolsArray(family, payload) {
+        if (!Array.isArray(payload.symbols)) {
+            throw createPayloadError(`invalid binance market metadata payload: ${family}`);
+        }
+        return payload;
+    }
+    return {
+        async fetchAllExchangeInfo() {
+            const [spot, usdm, coinm] = await Promise.all([
+                getJson(`${baseUrls.spot}/api/v3/exchangeInfo`),
+                getJson(`${baseUrls.usdm}/fapi/v1/exchangeInfo`),
+                getJson(`${baseUrls.coinm}/dapi/v1/exchangeInfo`),
+            ]);
+            return {
+                spot: requireSymbolsArray("spot", spot),
+                usdm: requireSymbolsArray("usdm", usdm),
+                coinm: requireSymbolsArray("coinm", coinm),
+            };
+        },
+    };
+}

package/dist/adapters/binance/symbol-router.d.ts

@@ -0,0 +1,9 @@
+import type { BinanceCoinmExchangeInfo, BinanceMarketIndex, BinanceMarketRecord, BinanceSpotExchangeInfo, BinanceUsdmExchangeInfo } from "./market-types.js";
+export declare function buildBinanceMarketIndex(input: {
+    spot: BinanceSpotExchangeInfo;
+    usdm: BinanceUsdmExchangeInfo;
+    coinm: BinanceCoinmExchangeInfo;
+}): BinanceMarketIndex;
+export declare function requireMarketRecord(index: BinanceMarketIndex, unifiedSymbol: string): BinanceMarketRecord;
+export declare function requireFundingMarketRecord(index: BinanceMarketIndex, unifiedSymbol: string): BinanceMarketRecord;
+export declare function getRecordByNativeSymbol(index: BinanceMarketIndex, family: BinanceMarketRecord["family"], nativeSymbol: string): BinanceMarketRecord | undefined;

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

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

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

@@ -0,0 +1,261 @@
+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/binance-usdm-ccxt-adapter.d.ts

@@ -62,6 +62,7 @@ interface CcxtExchangeLike {
 }
 export interface CreateCcxtBinanceUsdMAdapterInput {
     exchange: CcxtExchangeLike;
+    accountId?: string;
 }
 export declare class CcxtBinanceUsdMAdapter implements ExchangeAdapter {
     #private;

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

@@ -17,6 +17,7 @@ export class CcxtBinanceUsdMAdapter {
         fetchOrderById: true,
     };
     #exchange;
+    #accountId;
     #started = false;
     #privateWatchTasks = new Set();
     #orderSymbolsByClientOrderId = new Map();
@@ -30,6 +31,7 @@ export class CcxtBinanceUsdMAdapter {
     #accountEventSink;
     constructor(input) {
         this.#exchange = input.exchange;
+        this.#accountId = input.accountId ?? "main";
     }
     async start() {
         this.#started = true;
@@ -428,11 +430,11 @@ export class CcxtBinanceUsdMAdapter {
                     : "order.updated";
                 this.#emitOrderEvent({
                     type: eventType,
-                    accountId: "main",
+                    accountId: this.#accountId,
                     exchange: this.exchange,
                     receivedAt: now,
                     snapshot: {
-                        accountId: "main",
+                        accountId: this.#accountId,
                         exchange: this.exchange,
                         symbol,
                         side,
@@ -469,11 +471,11 @@ export class CcxtBinanceUsdMAdapter {
         for (const asset of assets) {
             this.#emitAccountEvent({
                 type: "balance.updated",
-                accountId: "main",
+                accountId: this.#accountId,
                 exchange: this.exchange,
                 asset,
                 snapshot: {
-                    accountId: "main",
+                    accountId: this.#accountId,
                     exchange: this.exchange,
                     asset,
                     free: valueToString(balance.free?.[asset]),

package/dist/adapters/ccxt/binance-usdm-exchange.d.ts

@@ -0,0 +1,22 @@
+export interface BinanceUsdmExchangeConfig {
+    apiKey: string;
+    secret: string;
+    enableRateLimit: boolean;
+}
+export interface BinanceUsdmExchangeLike {
+    options: {
+        defaultType?: string;
+        warnOnFetchOpenOrdersWithoutSymbol?: boolean;
+    };
+    enableDemoTrading?(value: boolean): void;
+}
+export type BinanceUsdmExchangeCtor = new (config: BinanceUsdmExchangeConfig) => BinanceUsdmExchangeLike;
+export interface CreateBinanceUsdmExchangeInput {
+    apiKey: string;
+    secret: string;
+    sandbox?: boolean;
+    enableRateLimit?: boolean;
+    exchangeCtor?: BinanceUsdmExchangeCtor;
+}
+export declare function getCcxtProBinanceUsdmCtor(): BinanceUsdmExchangeCtor;
+export declare function createBinanceUsdmExchange(input: CreateBinanceUsdmExchangeInput): BinanceUsdmExchangeLike;

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

@@ -0,0 +1,23 @@
+import ccxt from "ccxt";
+export function getCcxtProBinanceUsdmCtor() {
+    const proNamespace = ccxt
+        .pro;
+    if (proNamespace === undefined || proNamespace.binanceusdm === undefined) {
+        throw new Error("ccxt.pro.binanceusdm is not available");
+    }
+    return proNamespace.binanceusdm;
+}
+export function createBinanceUsdmExchange(input) {
+    const ExchangeCtor = input.exchangeCtor ?? getCcxtProBinanceUsdmCtor();
+    const exchange = new ExchangeCtor({
+        apiKey: input.apiKey,
+        secret: input.secret,
+        enableRateLimit: input.enableRateLimit ?? true,
+    });
+    exchange.options.defaultType = "future";
+    exchange.options.warnOnFetchOpenOrdersWithoutSymbol = false;
+    if (input.sandbox ?? true) {
+        exchange.enableDemoTrading?.(true);
+    }
+    return exchange;
+}