ccxt 4.1.11 → 4.1.12

package/js/src/binance.js

@@ -1810,14 +1810,16 @@ export default class binance extends Exchange {
         const query = this.omit(params, 'type');
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchTime', undefined, params);
-        let method = 'publicGetTime';
+        let response = undefined;
         if (this.isLinear(type, subType)) {
-            method = 'fapiPublicGetTime';
+            response = await this.fapiPublicGetTime(query);
         }
         else if (this.isInverse(type, subType)) {
-            method = 'dapiPublicGetTime';
+            response = await this.dapiPublicGetTime(query);
+        }
+        else {
+            response = await this.publicGetTime(query);
         }
-        const response = await this[method](query);
         return this.safeInteger(response, 'serverTime');
     }
     async fetchCurrencies(params = {}) {
@@ -2803,17 +2805,19 @@ export default class binance extends Exchange {
         if (limit !== undefined) {
             request['limit'] = limit; // default 100, max 5000, see https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#order-book
         }
-        let method = 'publicGetDepth';
+        let response = undefined;
         if (market['option']) {
-            method = 'eapiPublicGetDepth';
+            response = await this.eapiPublicGetDepth(this.extend(request, params));
         }
         else if (market['linear']) {
-            method = 'fapiPublicGetDepth';
+            response = await this.fapiPublicGetDepth(this.extend(request, params));
         }
         else if (market['inverse']) {
-            method = 'dapiPublicGetDepth';
+            response = await this.dapiPublicGetDepth(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetDepth(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         // future
         //
@@ -3047,17 +3051,19 @@ export default class binance extends Exchange {
         const request = {
             'symbol': market['id'],
         };
-        let method = 'publicGetTicker24hr';
+        let response = undefined;
         if (market['option']) {
-            method = 'eapiPublicGetTicker';
+            response = await this.eapiPublicGetTicker(this.extend(request, params));
         }
         else if (market['linear']) {
-            method = 'fapiPublicGetTicker24hr';
+            response = await this.fapiPublicGetTicker24hr(this.extend(request, params));
         }
         else if (market['inverse']) {
-            method = 'dapiPublicGetTicker24hr';
+            response = await this.dapiPublicGetTicker24hr(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetTicker24hr(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         if (Array.isArray(response)) {
             const firstTicker = this.safeValue(response, 0, {});
             return this.parseTicker(firstTicker, market);
@@ -3087,17 +3093,16 @@ export default class binance extends Exchange {
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchBidsAsks', market, params);
         [type, params] = this.handleMarketTypeAndParams('fetchBidsAsks', market, params);
-        let method = undefined;
+        let response = undefined;
         if (this.isLinear(type, subType)) {
-            method = 'fapiPublicGetTickerBookTicker';
+            response = await this.fapiPublicGetTickerBookTicker(params);
         }
         else if (this.isInverse(type, subType)) {
-            method = 'dapiPublicGetTickerBookTicker';
+            response = await this.dapiPublicGetTickerBookTicker(params);
         }
         else {
-            method = 'publicGetTickerBookTicker';
+            response = await this.publicGetTickerBookTicker(params);
         }
-        const response = await this[method](params);
         return this.parseTickers(response, symbols);
     }
     async fetchLastPrices(symbols = undefined, params = {}) {
@@ -3119,9 +3124,9 @@ export default class binance extends Exchange {
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchLastPrices', market, params);
         [type, params] = this.handleMarketTypeAndParams('fetchLastPrices', market, params);
-        let method = undefined;
+        let response = undefined;
         if (this.isLinear(type, subType)) {
-            method = 'fapiPublicGetTickerPrice';
+            response = await this.fapiPublicGetTickerPrice(params);
             //
             //     [
             //         {
@@ -3134,7 +3139,7 @@ export default class binance extends Exchange {
             //
         }
         else if (this.isInverse(type, subType)) {
-            method = 'dapiPublicGetTickerPrice';
+            response = await this.dapiPublicGetTickerPrice(params);
             //
             //     [
             //         {
@@ -3147,7 +3152,7 @@ export default class binance extends Exchange {
             //
         }
         else if (type === 'spot') {
-            method = 'publicGetTickerPrice';
+            response = await this.publicGetTickerPrice(params);
             //
             //     [
             //         {
@@ -3161,7 +3166,6 @@ export default class binance extends Exchange {
         else {
             throw new NotSupported(this.id + ' fetchLastPrices() does not support ' + type + ' markets yet');
         }
-        const response = await this[method](params);
         return this.parseLastPrices(response, symbols);
     }
     parseLastPrice(info, market = undefined) {
@@ -6481,10 +6485,20 @@ export default class binance extends Exchange {
     }
     parseTradingFee(fee, market = undefined) {
         //
+        // spot
+        //     [
+        //       {
+        //         "symbol": "BTCUSDT",
+        //         "makerCommission": "0.001",
+        //         "takerCommission": "0.001"
+        //       }
+        //     ]
+        //
+        // swap
         //     {
-        //         "symbol": "ADABNB",
-        //         "makerCommission": 0.001,
-        //         "takerCommission": 0.001
+        //         "symbol": "BTCUSD_PERP",
+        //         "makerCommissionRate": "0.00015",  // 0.015%
+        //         "takerCommissionRate": "0.00040"   // 0.040%
         //     }
         //
         const marketId = this.safeString(fee, 'symbol');
@@ -6492,8 +6506,8 @@ export default class binance extends Exchange {
         return {
             'info': fee,
             'symbol': symbol,
-            'maker': this.safeNumber(fee, 'makerCommission'),
-            'taker': this.safeNumber(fee, 'takerCommission'),
+            'maker': this.safeNumber2(fee, 'makerCommission', 'makerCommissionRate'),
+            'taker': this.safeNumber2(fee, 'takerCommission', 'takerCommissionRate'),
         };
     }
     async fetchTradingFee(symbol, params = {}) {
@@ -6502,17 +6516,37 @@ export default class binance extends Exchange {
          * @name binance#fetchTradingFee
          * @description fetch the trading fees for a market
          * @see https://binance-docs.github.io/apidocs/spot/en/#trade-fee-user_data
+         * @see https://binance-docs.github.io/apidocs/futures/en/#user-commission-rate-user_data
+         * @see https://binance-docs.github.io/apidocs/delivery/en/#user-commission-rate-user_data
          * @param {string} symbol unified market symbol
          * @param {object} [params] extra parameters specific to the binance api endpoint
          * @returns {object} a [fee structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
+        const defaultType = this.safeString2(this.options, 'fetchTradingFee', 'defaultType', 'linear');
+        const type = this.safeString(params, 'type', defaultType);
+        params = this.omit(params, 'type');
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchTradingFee', market, params);
+        const isSpotOrMargin = (type === 'spot') || (type === 'margin');
+        const isLinear = this.isLinear(type, subType);
+        const isInverse = this.isInverse(type, subType);
         const request = {
             'symbol': market['id'],
         };
-        const response = await this.sapiGetAssetTradeFee(this.extend(request, params));
+        let response = undefined;
+        if (isSpotOrMargin) {
+            response = await this.sapiGetAssetTradeFee(this.extend(request, params));
+        }
+        else if (isLinear) {
+            response = await this.fapiPrivateGetCommissionRate(this.extend(request, params));
+        }
+        else if (isInverse) {
+            response = await this.dapiPrivateGetCommissionRate(this.extend(request, params));
+        }
         //
+        // spot
         //     [
         //       {
         //         "symbol": "BTCUSDT",
@@ -6521,8 +6555,18 @@ export default class binance extends Exchange {
         //       }
         //     ]
         //
-        const first = this.safeValue(response, 0, {});
-        return this.parseTradingFee(first);
+        // swap
+        //     {
+        //         "symbol": "BTCUSD_PERP",
+        //         "makerCommissionRate": "0.00015",  // 0.015%
+        //         "takerCommissionRate": "0.00040"   // 0.040%
+        //     }
+        //
+        let data = response;
+        if (Array.isArray(data)) {
+            data = this.safeValue(data, 0, {});
+        }
+        return this.parseTradingFee(data);
     }
     async fetchTradingFees(params = {}) {
         /**
@@ -6537,11 +6581,10 @@ export default class binance extends Exchange {
          */
         await this.loadMarkets();
         let method = undefined;
-        const defaultType = this.safeString2(this.options, 'fetchTradingFees', 'defaultType', 'linear');
-        const type = this.safeString(params, 'type', defaultType);
-        params = this.omit(params, 'type');
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchTradingFees', undefined, params);
         let subType = undefined;
-        [subType, params] = this.handleSubTypeAndParams('fetchTradingFees', undefined, params);
+        [subType, params] = this.handleSubTypeAndParams('fetchTradingFees', undefined, params, 'linear');
         const isSpotOrMargin = (type === 'spot') || (type === 'margin');
         const isLinear = this.isLinear(type, subType);
         const isInverse = this.isInverse(type, subType);

package/js/src/bitget.js

@@ -1576,7 +1576,7 @@ export default class bitget extends Exchange {
         }
         const currency = this.currency(code);
         if (since === undefined) {
-            since = this.milliseconds() - 31556952000; // 1yr
+            since = this.milliseconds() - 7776000000; // 90 days
         }
         let request = {
             'coin': currency['code'],
@@ -1732,7 +1732,7 @@ export default class bitget extends Exchange {
         }
         const currency = this.currency(code);
         if (since === undefined) {
-            since = this.milliseconds() - 31556952000; // 1yr
+            since = this.milliseconds() - 7776000000; // 90 days
         }
         let request = {
             'coin': currency['code'],
@@ -4045,10 +4045,17 @@ export default class bitget extends Exchange {
             response = await this.privateSpotPostTradeFills(this.extend(request, params));
         }
         else {
+            const orderId = this.safeString(params, 'orderId'); // when order id is not defined, startTime and endTime are required
             if (since !== undefined) {
                 request['startTime'] = since;
             }
+            else if (orderId === undefined) {
+                request['startTime'] = 0;
+            }
             [request, params] = this.handleUntilOption('endTime', params, request);
+            if (!('endTime' in request) && (orderId === undefined)) {
+                request['endTime'] = this.milliseconds();
+            }
             response = await this.privateMixGetOrderFills(this.extend(request, params));
         }
         //

package/js/src/bybit.d.ts

@@ -197,9 +197,9 @@ export default class bybit extends Exchange {
         updated: number;
         fee: any;
     }>;
-    fetchPosition(symbol: string, params?: {}): Promise<any>;
-    fetchUsdcPositions(symbols?: string[], params?: {}): Promise<any>;
-    fetchPositions(symbols?: string[], params?: {}): Promise<any>;
+    fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
+    fetchUsdcPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
+    fetchPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
     parsePosition(position: any, market?: any): import("./base/types.js").Position;
     setMarginMode(marginMode: any, symbol?: string, params?: {}): Promise<any>;
     setLeverage(leverage: any, symbol?: string, params?: {}): Promise<any>;

package/js/src/bybit.js

@@ -1753,6 +1753,7 @@ export default class bybit extends Exchange {
                         'max': this.safeNumber(lotSizeFilter, 'maxOrderAmt'),
                     },
                 },
+                'created': undefined,
                 'info': market,
             });
         }
@@ -1927,6 +1928,7 @@ export default class bybit extends Exchange {
                         'max': undefined,
                     },
                 },
+                'created': this.safeInteger(market, 'launchTime'),
                 'info': market,
             });
         }
@@ -2059,6 +2061,7 @@ export default class bybit extends Exchange {
                             'max': undefined,
                         },
                     },
+                    'created': this.safeInteger(market, 'launchTime'),
                     'info': market,
                 });
             }
@@ -3513,10 +3516,14 @@ export default class bybit extends Exchange {
         //     }
         //
         const marketId = this.safeString(order, 'symbol');
-        let marketType = 'contract';
+        const isContract = ('tpslMode' in order);
+        let marketType = undefined;
         if (market !== undefined) {
             marketType = market['type'];
         }
+        else {
+            marketType = isContract ? 'contract' : 'spot';
+        }
         market = this.safeMarket(marketId, market, undefined, marketType);
         const symbol = market['symbol'];
         const timestamp = this.safeInteger2(order, 'createdTime', 'createdAt');
@@ -5693,10 +5700,9 @@ export default class bybit extends Exchange {
         const timestamp = this.safeInteger(response, 'time');
         const first = this.safeValue(positions, 0, {});
         const position = this.parsePosition(first, market);
-        return this.extend(position, {
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-        });
+        position['timestamp'] = timestamp;
+        position['datetime'] = this.iso8601(timestamp);
+        return position;
     }
     async fetchUsdcPositions(symbols = undefined, params = {}) {
         await this.loadMarkets();
@@ -5771,7 +5777,7 @@ export default class bybit extends Exchange {
             }
             results.push(this.parsePosition(rawPosition, market));
         }
-        return this.filterByArray(results, 'symbol', symbols, false);
+        return this.filterByArrayPositions(results, 'symbol', symbols, false);
     }
     async fetchPositions(symbols = undefined, params = {}) {
         /**

package/js/src/cryptocom.d.ts

@@ -181,7 +181,7 @@ export default class cryptocom extends Exchange {
     parseSettlements(settlements: any, market: any): any[];
     fetchFundingRateHistory(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
     fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
-    fetchPositions(symbols?: string[], params?: {}): Promise<any>;
+    fetchPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
     parsePosition(position: any, market?: any): import("./base/types.js").Position;
     nonce(): number;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {

package/js/src/cryptocom.js

@@ -2956,7 +2956,7 @@ export default class cryptocom extends Exchange {
             const marketInner = this.safeMarket(marketId, undefined, undefined, 'contract');
             result.push(this.parsePosition(entry, marketInner));
         }
-        return this.filterByArray(result, 'symbol', undefined, false);
+        return this.filterByArrayPositions(result, 'symbol', undefined, false);
     }
     parsePosition(position, market = undefined) {
         //

package/js/src/delta.d.ts

@@ -74,61 +74,9 @@ export default class delta extends Exchange {
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").OHLCV[]>;
     parseBalance(response: any): import("./base/types.js").Balances;
     fetchBalance(params?: {}): Promise<import("./base/types.js").Balances>;
-    fetchPosition(symbol: string, params?: {}): Promise<{
-        info: any;
-        id: any;
-        symbol: any;
-        notional: any;
-        marginMode: any;
-        liquidationPrice: number;
-        entryPrice: number;
-        unrealizedPnl: any;
-        percentage: any;
-        contracts: number;
-        contractSize: number;
-        markPrice: any;
-        side: any;
-        hedged: any;
-        timestamp: number;
-        datetime: string;
-        maintenanceMargin: any;
-        maintenanceMarginPercentage: any;
-        collateral: any;
-        initialMargin: any;
-        initialMarginPercentage: any;
-        leverage: any;
-        marginRatio: any;
-        stopLossPrice: any;
-        takeProfitPrice: any;
-    }>;
+    fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
     fetchPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
-    parsePosition(position: any, market?: any): {
-        info: any;
-        id: any;
-        symbol: any;
-        notional: any;
-        marginMode: any;
-        liquidationPrice: number;
-        entryPrice: number;
-        unrealizedPnl: any;
-        percentage: any;
-        contracts: number;
-        contractSize: number;
-        markPrice: any;
-        side: any;
-        hedged: any;
-        timestamp: number;
-        datetime: string;
-        maintenanceMargin: any;
-        maintenanceMarginPercentage: any;
-        collateral: any;
-        initialMargin: any;
-        initialMarginPercentage: any;
-        leverage: any;
-        marginRatio: any;
-        stopLossPrice: any;
-        takeProfitPrice: any;
-    };
+    parsePosition(position: any, market?: any): import("./base/types.js").Position;
     parseOrderStatus(status: any): string;
     parseOrder(order: any, market?: any): import("./base/types.js").Order;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<import("./base/types.js").Order>;

package/js/src/delta.js

@@ -1675,7 +1675,7 @@ export default class delta extends Exchange {
                 side = 'sell';
             }
         }
-        return {
+        return this.safePosition({
             'info': position,
             'id': undefined,
             'symbol': symbol,
@@ -1701,7 +1701,7 @@ export default class delta extends Exchange {
             'marginRatio': undefined,
             'stopLossPrice': undefined,
             'takeProfitPrice': undefined,
-        };
+        });
     }
     parseOrderStatus(status) {
         const statuses = {

package/js/src/huobi.d.ts

@@ -269,7 +269,7 @@ export default class huobi extends Exchange {
     };
     parsePosition(position: any, market?: any): import("./base/types.js").Position;
     fetchPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
-    fetchPosition(symbol: string, params?: {}): Promise<any>;
+    fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
     parseLedgerEntryType(type: any): string;
     parseLedgerEntry(item: any, currency?: any): {
         id: string;

package/js/src/huobi.js

@@ -7218,10 +7218,9 @@ export default class huobi extends Exchange {
         }
         const timestamp = this.safeInteger(response, 'ts');
         const parsed = this.parsePosition(this.extend(position, omitted));
-        return this.extend(parsed, {
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-        });
+        parsed['timestamp'] = timestamp;
+        parsed['datetime'] = this.iso8601(timestamp);
+        return parsed;
     }
     parseLedgerEntryType(type) {
         const types = {

package/js/src/mexc.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/mexc.js';
-import { IndexType, Int, OrderSide, Balances, OrderType, OHLCV, FundingRateHistory } from './base/types.js';
+import { IndexType, Int, OrderSide, Balances, OrderType, OHLCV, FundingRateHistory, Position } from './base/types.js';
 /**
  * @class mexc
  * @extends Exchange
@@ -141,9 +141,9 @@ export default class mexc extends Exchange {
         fee: any;
     };
     parseTransactionStatusByType(status: any, type?: any): string;
-    fetchPosition(symbol: string, params?: {}): Promise<any>;
-    fetchPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
-    parsePosition(position: any, market?: any): import("./base/types.js").Position;
+    fetchPosition(symbol: string, params?: {}): Promise<Position>;
+    fetchPositions(symbols?: string[], params?: {}): Promise<Position[]>;
+    parsePosition(position: any, market?: any): Position;
     fetchTransfer(id: string, since?: Int, limit?: Int, params?: {}): Promise<{
         info: any;
         id: string;

package/js/src/okx.js

@@ -2115,6 +2115,7 @@ export default class okx extends Exchange {
             }
         }
         else if (price === 'index') {
+            request['instId'] = market['info']['instFamily']; // okx index candles require instFamily instead of instId
             if (isHistoryCandles) {
                 response = await this.publicGetMarketHistoryIndexCandles(this.extend(request, params));
             }

package/js/src/poloniex.js

@@ -291,6 +291,7 @@ export default class poloniex extends Exchange {
                     '21352': BadSymbol,
                     '21353': PermissionDenied,
                     '21354': PermissionDenied,
+                    '21359': OrderNotFound,
                     '21360': InvalidOrder,
                     '24106': BadRequest,
                     '24201': ExchangeNotAvailable,

package/js/src/whitebit.js

@@ -60,6 +60,7 @@ export default class whitebit extends Exchange {
                 'fetchMarginMode': false,
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': false,
+                'fetchMyTrades': true,
                 'fetchOHLCV': true,
                 'fetchOpenInterestHistory': false,
                 'fetchOpenOrders': true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.1.11",
+  "version": "4.1.12",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 130+ exchanges",
   "unpkg": "dist/ccxt.browser.js",
   "type": "module",