binance/lib/util/usdm/exchangeInfo.js

Professional Node.js & JavaScript SDK for Binance REST APIs & WebSockets, with TypeScript & end-to-end tests.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.normaliseUSDMFuturesSymbolFilters = normaliseUSDMFuturesSymbolFilters;
exports.getUSDMFuturesSymbolFilters = getUSDMFuturesSymbolFilters;
exports.getUSDMFuturesSymbolFilterMap = getUSDMFuturesSymbolFilterMap;
exports.getUSDMFuturesSymbolMinNotional = getUSDMFuturesSymbolMinNotional;
exports.getUSDMFuturesMinNotionalSymbolMap = getUSDMFuturesMinNotionalSymbolMap;
function numberValue(value) {
    return Number(value);
}
function findUSDMFuturesSymbolFilter(filters, filterType) {
    return filters.find((filter) => filter.filterType === filterType);
}
/** Normalise a USDM Futures symbol's raw exchange-info filters into numeric fields. */
function normaliseUSDMFuturesSymbolFilters(symbolInfo) {
    const priceFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'PRICE_FILTER');
    const lotSizeFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'LOT_SIZE');
    const marketLotSizeFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'MARKET_LOT_SIZE');
    const minNotionalFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'MIN_NOTIONAL');
    const percentPriceFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'PERCENT_PRICE');
    const maxOrdersFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'MAX_NUM_ORDERS');
    const maxAlgoOrdersFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'MAX_NUM_ALGO_ORDERS');
    const maxPositionFilter = findUSDMFuturesSymbolFilter(symbolInfo.filters, 'MAX_POSITION');
    return {
        symbol: symbolInfo.symbol,
        pricePrecision: symbolInfo.pricePrecision,
        quantityPrecision: symbolInfo.quantityPrecision,
        triggerProtect: numberValue(symbolInfo.triggerProtect),
        price: priceFilter
            ? {
                minPrice: numberValue(priceFilter.minPrice),
                maxPrice: numberValue(priceFilter.maxPrice),
                tickSize: numberValue(priceFilter.tickSize),
            }
            : undefined,
        lotSize: lotSizeFilter
            ? {
                minQty: numberValue(lotSizeFilter.minQty),
                maxQty: numberValue(lotSizeFilter.maxQty),
                stepSize: numberValue(lotSizeFilter.stepSize),
            }
            : undefined,
        marketLotSize: marketLotSizeFilter
            ? {
                minQty: numberValue(marketLotSizeFilter.minQty),
                maxQty: numberValue(marketLotSizeFilter.maxQty),
                stepSize: numberValue(marketLotSizeFilter.stepSize),
            }
            : undefined,
        minNotional: minNotionalFilter
            ? {
                notional: numberValue(minNotionalFilter.notional),
            }
            : undefined,
        percentPrice: percentPriceFilter
            ? {
                multiplierUp: numberValue(percentPriceFilter.multiplierUp),
                multiplierDown: numberValue(percentPriceFilter.multiplierDown),
                multiplierDecimal: numberValue(percentPriceFilter.multiplierDecimal),
            }
            : undefined,
        maxOrders: maxOrdersFilter ? { limit: maxOrdersFilter.limit } : undefined,
        maxAlgoOrders: maxAlgoOrdersFilter
            ? { limit: maxAlgoOrdersFilter.limit }
            : undefined,
        maxPosition: maxPositionFilter
            ? { maxPosition: numberValue(maxPositionFilter.maxPosition) }
            : undefined,
    };
}
/** Get normalised USDM Futures filters for one symbol. */
function getUSDMFuturesSymbolFilters(exchangeInfo, symbol) {
    const specs = exchangeInfo.symbols.find((sym) => sym.symbol === symbol);
    if (!specs) {
        return null;
    }
    return normaliseUSDMFuturesSymbolFilters(specs);
}
/** Returns an object where keys are USDM Futures symbols and values are normalised filters for that symbol. */
function getUSDMFuturesSymbolFilterMap(exchangeInfo) {
    return exchangeInfo.symbols.reduce((res, spec) => {
        res[spec.symbol] = normaliseUSDMFuturesSymbolFilters(spec);
        return res;
    }, {});
}
/** Get min notional filter for a USDM futures symbol */
function getUSDMFuturesSymbolMinNotional(exchangeInfo, symbol) {
    const specs = exchangeInfo.symbols.find((sym) => sym.symbol === symbol);
    if (!specs) {
        return null;
    }
    const filterType = 'MIN_NOTIONAL';
    const filter = specs.filters.find((filter) => filter.filterType === filterType);
    if (!filter) {
        return null;
    }
    return Number(filter.notional);
}
/** Returns an object where keys are USDM Futures symbols and values are min notionals for that symbol */
function getUSDMFuturesMinNotionalSymbolMap(exchangeInfo) {
    const minNotionals = exchangeInfo.symbols.reduce((res, spec) => {
        const filter = spec.filters.find((filter) => filter.filterType === 'MIN_NOTIONAL');
        if (filter) {
            res[spec.symbol] = filter.notional;
        }
        return res;
    }, {});
    return minNotionals;
}
//# sourceMappingURL=exchangeInfo.js.map