ccxt 4.0.100 → 4.0.101

package/dist/cjs/ccxt.js

@@ -180,7 +180,7 @@ var woo$1 = require('./src/pro/woo.js');
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.0.100';
+const version = '4.0.101';
 Exchange["default"].ccxtVersion = version;
 const exchanges = {
     'ace': ace,

package/dist/cjs/src/binance.js

@@ -3420,6 +3420,18 @@ class binance extends binance$1 {
         //         "M": true           // Was the trade the best price match?
         //     }
         //
+        // REST: aggregate trades for swap & future (both linear and inverse)
+        //
+        //     {
+        //         "a": "269772814",
+        //         "p": "25864.1",
+        //         "q": "3",
+        //         "f": "662149354",
+        //         "l": "662149355",
+        //         "T": "1694209776022",
+        //         "m": false,
+        //     }
+        //
         // recent public trades and old public trades
         // https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#recent-trades-list
         // https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#old-trade-lookup-market_data
@@ -3673,7 +3685,8 @@ class binance extends binance$1 {
             }
         }
         if (limit !== undefined) {
-            request['limit'] = limit; // default = 500, maximum = 1000
+            const isFutureOrSwap = (market['swap'] || market['future']);
+            request['limit'] = isFutureOrSwap ? Math.min(limit, 1000) : limit; // default = 500, maximum = 1000
         }
         params = this.omit(params, ['until', 'fetchTradesMethod']);
         //
@@ -3702,6 +3715,20 @@ class binance extends binance$1 {
         //         }
         //     ]
         //
+        // inverse (swap & future)
+        //
+        //     [
+        //      {
+        //         "a": "269772814",
+        //         "p": "25864.1",
+        //         "q": "3",
+        //         "f": "662149354",
+        //         "l": "662149355",
+        //         "T": "1694209776022",
+        //         "m": false,
+        //      },
+        //     ]
+        //
         // recent public trades and historical public trades
         //
         //     [

package/dist/cjs/src/bitbank.js

@@ -316,6 +316,17 @@ class bitbank extends bitbank$1 {
         return this.parseOrderBook(orderbook, market['symbol'], timestamp);
     }
     parseTrade(trade, market = undefined) {
+        //
+        // fetchTrades
+        //
+        //    {
+        //        "transaction_id": "1143247037",
+        //        "side": "buy",
+        //        "price": "3836025",
+        //        "amount": "0.0005",
+        //        "executed_at": "1694249441593"
+        //    }
+        //
         const timestamp = this.safeInteger(trade, 'executed_at');
         market = this.safeMarket(undefined, market);
         const priceString = this.safeString(trade, 'price');

package/dist/cjs/src/bitfinex.js

@@ -919,14 +919,6 @@ class bitfinex extends bitfinex$1 {
         //          "type":"sell"
         //     }
         //
-        //     {    "timestamp":1637258238,
-        //          "tid":894452800,
-        //          "price":"0.99958",
-        //          "amount":"261.90514",
-        //          "exchange":"bitfinex",
-        //          "type":"buy"
-        //     }
-        //
         // fetchMyTrades (private) v1
         //
         //     {
@@ -1005,6 +997,18 @@ class bitfinex extends bitfinex$1 {
             request['timestamp'] = this.parseToInt(since / 1000);
         }
         const response = await this.publicGetTradesSymbol(this.extend(request, params));
+        //
+        //    [
+        //        {
+        //            "timestamp": "1694284565",
+        //            "tid": "1415415034",
+        //            "price": "25862.0",
+        //            "amount": "0.00020685",
+        //            "exchange": "bitfinex",
+        //            "type": "buy"
+        //        },
+        //    ]
+        //
         return this.parseTrades(response, market, since, limit);
     }
     async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {

package/dist/cjs/src/bitflyer.js

@@ -406,7 +406,7 @@ class bitflyer extends bitflyer$1 {
         //
         // fetchTrades (public) v1
         //
-        //     {
+        //      {
         //          "id":2278466664,
         //          "side":"SELL",
         //          "price":56810.7,
@@ -416,16 +416,18 @@ class bitflyer extends bitflyer$1 {
         //          "sell_child_order_acceptance_id":"JRF20211119-114639-236919"
         //      }
         //
-        //      {
-        //          "id":2278463423,
-        //          "side":"BUY",
-        //          "price":56757.83,
-        //          "size":0.6003,"exec_date":"2021-11-19T11:28:00.523",
-        //          "buy_child_order_acceptance_id":"JRF20211119-112800-236526",
-        //          "sell_child_order_acceptance_id":"JRF20211119-112734-062017"
-        //      }
-        //
+        // fetchMyTrades
         //
+        //      {
+        //          "id": 37233,
+        //          "side": "BUY",
+        //          "price": 33470,
+        //          "size": 0.01,
+        //          "exec_date": "2015-07-07T09:57:40.397",
+        //          "child_order_id": "JOR20150707-060559-021935",
+        //          "child_order_acceptance_id": "JRF20150707-060559-396699"
+        //          "commission": 0,
+        //      },
         //
         let side = this.safeStringLower(trade, 'side');
         if (side !== undefined) {
@@ -484,6 +486,19 @@ class bitflyer extends bitflyer$1 {
             request['count'] = limit;
         }
         const response = await this.publicGetGetexecutions(this.extend(request, params));
+        //
+        //    [
+        //     {
+        //       "id": 39287,
+        //       "side": "BUY",
+        //       "price": 31690,
+        //       "size": 27.04,
+        //       "exec_date": "2015-07-08T02:43:34.823",
+        //       "buy_child_order_acceptance_id": "JRF20150707-200203-452209",
+        //       "sell_child_order_acceptance_id": "JRF20150708-024334-060234"
+        //     },
+        //    ]
+        //
         return this.parseTrades(response, market, since, limit);
     }
     async fetchTradingFee(symbol, params = {}) {
@@ -720,6 +735,20 @@ class bitflyer extends bitflyer$1 {
             request['count'] = limit;
         }
         const response = await this.privateGetGetexecutions(this.extend(request, params));
+        //
+        //    [
+        //     {
+        //       "id": 37233,
+        //       "side": "BUY",
+        //       "price": 33470,
+        //       "size": 0.01,
+        //       "exec_date": "2015-07-07T09:57:40.397",
+        //       "child_order_id": "JOR20150707-060559-021935",
+        //       "child_order_acceptance_id": "JRF20150707-060559-396699"
+        //       "commission": 0,
+        //     },
+        //    ]
+        //
         return this.parseTrades(response, market, since, limit);
     }
     async fetchPositions(symbols = undefined, params = {}) {

package/dist/cjs/src/bitforex.js

@@ -246,14 +246,6 @@ class bitforex extends bitforex$1 {
         //          "tid":"1131019666"
         //      }
         //
-        //      {
-        //          "price":57591.33,
-        //          "amount":0.002,
-        //          "time":1637329685322,
-        //          "direction":1,
-        //          "tid":"1131019639"
-        //      }
-        //
         // fetchMyTrades (private)
         //
         //     {

package/dist/cjs/src/bitget.js

@@ -2149,7 +2149,7 @@ class bitget extends bitget$1 {
         //         "fillTime": "1692073691000"
         //     }
         //
-        // swap
+        // swap (public trades)
         //
         //     {
         //         "tradeId": "1075199767891652609",
@@ -2281,6 +2281,16 @@ class bitget extends bitget$1 {
             params = this.omit(params, 'method');
             if (swapMethod === 'publicMixGetMarketFillsHistory') {
                 response = await this.publicMixGetMarketFillsHistory(this.extend(request, params));
+                //
+                //     {
+                //         "tradeId": "1084459062491590657",
+                //         "price": "25874",
+                //         "size": "1.624",
+                //         "side": "Buy",
+                //         "timestamp": "1694281109000",
+                //         "symbol": "BTCUSDT_UMCBL",
+                //     }
+                //
             }
             else if (swapMethod === 'publicMixGetMarketFills') {
                 response = await this.publicMixGetMarketFills(this.extend(request, params));
@@ -2981,12 +2991,12 @@ class bitget extends bitget$1 {
             }
             else if (isStopLossOrTakeProfit) {
                 if (isStopLoss) {
-                    const stopLossTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice');
-                    request['presetStopLossPrice'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
+                    const slTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice');
+                    request['presetStopLossPrice'] = this.priceToPrecision(symbol, slTriggerPrice);
                 }
                 if (isTakeProfit) {
-                    const takeProfitTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice');
-                    request['presetTakeProfitPrice'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
+                    const tpTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice');
+                    request['presetTakeProfitPrice'] = this.priceToPrecision(symbol, tpTriggerPrice);
                 }
             }
         }

package/dist/cjs/src/bitstamp1.js

@@ -215,6 +215,17 @@ class bitstamp1 extends bitstamp1$1 {
         return this.parseTicker(ticker, market);
     }
     parseTrade(trade, market = undefined) {
+        //
+        // public trade
+        //
+        //        {
+        //            "amount": "0.00114000",
+        //            "date": "1694287856",
+        //            "price": "25865",
+        //            "tid": 298730788,
+        //            "type": 0
+        //        }
+        //
         const timestamp = this.safeTimestamp2(trade, 'date', 'datetime');
         const side = (trade['type'] === 0) ? 'buy' : 'sell';
         const orderId = this.safeString(trade, 'order_id');
@@ -259,6 +270,17 @@ class bitstamp1 extends bitstamp1$1 {
             'time': 'minute',
         };
         const response = await this.publicGetTransactions(this.extend(request, params));
+        //
+        //    [
+        //        {
+        //            "amount": "0.00114000",
+        //            "date": "1694287856",
+        //            "price": "25865",
+        //            "tid": 298730788,
+        //            "type": 0
+        //        },
+        //    ]
+        //
         return this.parseTrades(response, market, since, limit);
     }
     parseBalance(response) {

package/dist/cjs/src/bl3p.js

@@ -241,6 +241,16 @@ class bl3p extends bl3p$1 {
         return this.parseTicker(ticker, market);
     }
     parseTrade(trade, market = undefined) {
+        //
+        // fetchTrades
+        //
+        //     {
+        //         "trade_id": "2518789",
+        //         "date": "1694348697745",
+        //         "amount_int": "2959153",
+        //         "price_int": "2416231440"
+        //     }
+        //
         const id = this.safeString(trade, 'trade_id');
         const timestamp = this.safeInteger(trade, 'date');
         const price = this.safeString(trade, 'price_int');
@@ -277,6 +287,20 @@ class bl3p extends bl3p$1 {
         const response = await this.publicGetMarketTrades(this.extend({
             'market': market['id'],
         }, params));
+        //
+        //    {
+        //        "result": "success",
+        //        "data": {
+        //            "trades": [
+        //                {
+        //                    "trade_id": "2518789",
+        //                    "date": "1694348697745",
+        //                    "amount_int": "2959153",
+        //                    "price_int": "2416231440"
+        //                },
+        //            ]
+        //        }
+        //     }
         const result = this.parseTrades(response['data']['trades'], market, since, limit);
         return result;
     }

package/dist/cjs/src/bybit.js

@@ -726,7 +726,7 @@ class bybit extends bybit$1 {
                     '110023': errors.InvalidOrder,
                     '110024': errors.InvalidOrder,
                     '110025': errors.InvalidOrder,
-                    '110026': errors.InvalidOrder,
+                    '110026': errors.BadRequest,
                     '110027': errors.InvalidOrder,
                     '110028': errors.InvalidOrder,
                     '110029': errors.InvalidOrder,
@@ -2401,20 +2401,14 @@ class bybit extends bybit$1 {
             request['limit'] = limit; // max 1000, default 1000
         }
         request['interval'] = this.safeString(this.timeframes, timeframe, timeframe);
-        let method = undefined;
+        let response = undefined;
         if (market['spot']) {
             request['category'] = 'spot';
-            method = 'publicGetV5MarketKline';
+            response = await this.publicGetV5MarketKline(this.extend(request, params));
         }
         else {
             const price = this.safeString(params, 'price');
             params = this.omit(params, 'price');
-            const methods = {
-                'mark': 'publicGetV5MarketMarkPriceKline',
-                'index': 'publicGetV5MarketIndexPriceKline',
-                'premiumIndex': 'publicGetV5MarketPremiumIndexPriceKline',
-            };
-            method = this.safeValue(methods, price, 'publicGetV5MarketKline');
             if (market['linear']) {
                 request['category'] = 'linear';
             }
@@ -2424,8 +2418,19 @@ class bybit extends bybit$1 {
             else {
                 throw new errors.NotSupported(this.id + ' fetchOHLCV() is not supported for option markets');
             }
+            if (price === 'mark') {
+                response = await this.publicGetV5MarketMarkPriceKline(this.extend(request, params));
+            }
+            else if (price === 'index') {
+                response = await this.publicGetV5MarketIndexPriceKline(this.extend(request, params));
+            }
+            else if (price === 'premiumIndex') {
+                response = await this.publicGetV5MarketPremiumIndexPriceKline(this.extend(request, params));
+            }
+            else {
+                response = await this.publicGetV5MarketKline(this.extend(request, params));
+            }
         }
-        const response = await this[method](this.extend(request, params));
         //
         //     {
         //         "retCode": 0,
@@ -3598,6 +3603,7 @@ class bybit extends bybit$1 {
          * @param {boolean} [params.isLeverage] *unified spot only* false then spot trading true then margin trading
          * @param {string} [params.tpslMode] *contract only* 'full' or 'partial'
          * @param {string} [params.mmp] *option only* market maker protection
+         * @param {int} [params.triggerDirection] *contract only* conditional orders, 1: triggered when market price rises to triggerPrice, 2: triggered when market price falls to triggerPrice
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
@@ -3705,7 +3711,6 @@ class bybit extends bybit$1 {
         const isBuy = side === 'buy';
         const ascending = stopLossTriggerPrice ? !isBuy : isBuy;
         if (triggerPrice !== undefined) {
-            request['triggerDirection'] = ascending ? 2 : 1;
             request['triggerPrice'] = this.priceToPrecision(symbol, triggerPrice);
         }
         else if (isStopLossTriggerOrder || isTakeProfitTriggerOrder) {
@@ -3851,8 +3856,13 @@ class bybit extends bybit$1 {
             request['orderLinkId'] = this.uuid16();
         }
         params = this.omit(params, ['stopPrice', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'postOnly', 'clientOrderId']);
-        const method = market['option'] ? 'privatePostOptionUsdcOpenapiPrivateV1PlaceOrder' : 'privatePostPerpetualUsdcOpenapiPrivateV1PlaceOrder';
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (market['option']) {
+            response = await this.privatePostOptionUsdcOpenapiPrivateV1PlaceOrder(this.extend(request, params));
+        }
+        else {
+            response = await this.privatePostPerpetualUsdcOpenapiPrivateV1PlaceOrder(this.extend(request, params));
+        }
         //
         //     {
         //         "retCode":0,
@@ -3894,12 +3904,11 @@ class bybit extends bybit$1 {
         if (price !== undefined) {
             request['orderPrice'] = this.priceToPrecision(symbol, price);
         }
-        let method = undefined;
+        let response = undefined;
         if (market['option']) {
-            method = 'privatePostOptionUsdcOpenapiPrivateV1ReplaceOrder';
+            response = await this.privatePostOptionUsdcOpenapiPrivateV1ReplaceOrder(this.extend(request, params));
         }
         else {
-            method = 'privatePostPerpetualUsdcOpenapiPrivateV1ReplaceOrder';
             const isStop = this.safeValue(params, 'stop', false);
             const triggerPrice = this.safeValue2(params, 'stopPrice', 'triggerPrice');
             const stopLossPrice = this.safeValue(params, 'stopLossPrice');
@@ -3920,8 +3929,8 @@ class bybit extends bybit$1 {
                 }
             }
             params = this.omit(params, ['stop', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice']);
+            response = await this.privatePostPerpetualUsdcOpenapiPrivateV1ReplaceOrder(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //    {
         //        "retCode": 0,
@@ -4055,18 +4064,17 @@ class bybit extends bybit$1 {
         };
         const isStop = this.safeValue(params, 'stop', false);
         params = this.omit(params, ['stop']);
-        let method = undefined;
         if (id !== undefined) { // The user can also use argument params["order_link_id"]
             request['orderId'] = id;
         }
+        let response = undefined;
         if (market['option']) {
-            method = 'privatePostOptionUsdcOpenapiPrivateV1CancelOrder';
+            response = await this.privatePostOptionUsdcOpenapiPrivateV1CancelOrder(this.extend(request, params));
         }
         else {
-            method = 'privatePostPerpetualUsdcOpenapiPrivateV1CancelOrder';
             request['orderFilter'] = isStop ? 'StopOrder' : 'Order';
+            response = await this.privatePostPerpetualUsdcOpenapiPrivateV1CancelOrder(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //     {
         //         "retCode": 0,
@@ -5239,7 +5247,6 @@ class bybit extends bybit$1 {
                 request['start_date'] = this.yyyymmdd(since);
             }
         }
-        const method = (enableUnified[1]) ? 'privateGetV5AccountTransactionLog' : 'privateGetV2PrivateWalletFundRecords';
         if (code !== undefined) {
             currency = this.currency(code);
             request[currencyKey] = currency['id'];
@@ -5247,7 +5254,13 @@ class bybit extends bybit$1 {
         if (limit !== undefined) {
             request['limit'] = limit;
         }
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (enableUnified[1]) {
+            response = await this.privateGetV5AccountTransactionLog(this.extend(request, params));
+        }
+        else {
+            response = await this.privateGetV2PrivateWalletFundRecords(this.extend(request, params));
+        }
         //
         //     {
         //         "ret_code": 0,
@@ -5968,21 +5981,83 @@ class bybit extends bybit$1 {
         });
     }
     async setMarginMode(marginMode, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#setMarginMode
+         * @description set margin mode (account) or trade mode (symbol)
+         * @see https://bybit-exchange.github.io/docs/v5/account/set-margin-mode
+         * @see https://bybit-exchange.github.io/docs/v5/position/cross-isolate
+         * @param {string} marginMode account mode must be either [isolated, cross, portfolio], trade mode must be either [isolated, cross]
+         * @param {string} symbol unified market symbol of the market the position is held in, default is undefined
+         * @param {object} [params] extra parameters specific to the bybit api endpoint
+         * @param {string} [params.leverage] the rate of leverage, is required if setting trade mode (symbol)
+         * @returns {object} response from the exchange
+         */
         await this.loadMarkets();
         const [enableUnifiedMargin, enableUnifiedAccount] = await this.isUnifiedEnabled();
         const isUnifiedAccount = (enableUnifiedMargin || enableUnifiedAccount);
-        if (marginMode === 'ISOLATED_MARGIN') {
-            if (!isUnifiedAccount) {
-                throw new errors.NotSupported(this.id + ' setMarginMode() Normal Account not support ISOLATED_MARGIN');
+        let response = undefined;
+        if (symbol === undefined) {
+            if (marginMode === 'isolated') {
+                if (!isUnifiedAccount) {
+                    throw new errors.NotSupported(this.id + ' setMarginMode() Normal Account not support ISOLATED_MARGIN');
+                }
+                marginMode = 'ISOLATED_MARGIN';
             }
+            else if (marginMode === 'cross') {
+                marginMode = 'REGULAR_MARGIN';
+            }
+            else if (marginMode === 'portfolio') {
+                marginMode = 'PORTFOLIO_MARGIN';
+            }
+            else {
+                throw new errors.NotSupported(this.id + ' setMarginMode() marginMode must be either [isolated, cross, portfolio]');
+            }
+            const request = {
+                'setMarginMode': marginMode,
+            };
+            response = await this.privatePostV5AccountSetMarginMode(this.extend(request, params));
         }
-        else if ((marginMode !== 'REGULAR_MARGIN') && (marginMode !== 'PORTFOLIO_MARGIN')) {
-            throw new errors.NotSupported(this.id + ' setMarginMode() marginMode must be either ISOLATED_MARGIN or REGULAR_MARGIN or PORTFOLIO_MARGIN');
+        else {
+            const market = this.market(symbol);
+            let type = undefined;
+            [type, params] = this.getBybitType('setMarginMode', market, params);
+            if (type === 'linear') {
+                if (isUnifiedAccount) {
+                    throw new errors.NotSupported(this.id + ' setMarginMode() with symbol Unified Account only support inverse contract');
+                }
+                const isUsdtSettled = market['settle'] === 'USDT';
+                if (!isUsdtSettled) {
+                    throw new errors.NotSupported(this.id + ' setMarginMode() with symbol only support USDT perpetual / inverse contract');
+                }
+            }
+            else if (type !== 'inverse') {
+                throw new errors.NotSupported(this.id + ' setMarginMode() does not support this market type');
+            }
+            let tradeMode = undefined;
+            if (marginMode === 'cross') {
+                tradeMode = 0;
+            }
+            else if (marginMode === 'isolated') {
+                tradeMode = 1;
+            }
+            else {
+                throw new errors.NotSupported(this.id + ' setMarginMode() with symbol marginMode must be either [isolated, cross]');
+            }
+            const leverage = this.safeString(params, 'leverage');
+            params = this.omit(params, ['leverage']);
+            if (leverage === undefined) {
+                throw new errors.ArgumentsRequired(this.id + ' setMarginMode() with symbol requires leverage');
+            }
+            const request = {
+                'category': type,
+                'symbol': market['id'],
+                'tradeMode': tradeMode,
+                'buyLeverage': leverage,
+                'sellLeverage': leverage,
+            };
+            response = await this.privatePostV5PositionSwitchIsolated(this.extend(request, params));
         }
-        const request = {
-            'setMarginMode': marginMode,
-        };
-        const response = await this.privatePostV5AccountSetMarginMode(this.extend(request, params));
         return response;
     }
     async setLeverage(leverage, symbol = undefined, params = {}) {
@@ -6014,15 +6089,14 @@ class bybit extends bybit$1 {
             'buyLeverage': leverage,
             'sellLeverage': leverage,
         };
-        let method = undefined;
+        let response = undefined;
         if (isUsdcSettled && !isUnifiedAccount) {
             request['leverage'] = leverage;
-            method = 'privatePostPerpetualUsdcOpenapiPrivateV1PositionLeverageSave';
+            response = await this.privatePostPerpetualUsdcOpenapiPrivateV1PositionLeverageSave(this.extend(request, params));
         }
         else {
             request['buyLeverage'] = leverage;
             request['sellLeverage'] = leverage;
-            method = 'privatePostV5PositionSetLeverage';
             if (market['linear']) {
                 request['category'] = 'linear';
             }
@@ -6032,8 +6106,9 @@ class bybit extends bybit$1 {
             else {
                 throw new errors.NotSupported(this.id + ' setLeverage() only support linear and inverse market');
             }
+            response = await this.privatePostV5PositionSetLeverage(this.extend(request, params));
         }
-        return await this[method](this.extend(request, params));
+        return response;
     }
     async setPositionMode(hedged, symbol = undefined, params = {}) {
         /**

package/dist/cjs/src/coinbasepro.js

@@ -815,6 +815,17 @@ class coinbasepro extends coinbasepro$1 {
             request['limit'] = limit; // default 100
         }
         const response = await this.publicGetProductsIdTrades(this.extend(request, params));
+        //
+        //    [
+        //        {
+        //            "trade_id": "15035219",
+        //            "side": "sell",
+        //            "size": "0.27426731",
+        //            "price": "25820.42000000",
+        //            "time": "2023-09-10T13:47:41.447577Z"
+        //        },
+        //    ]
+        //
         return this.parseTrades(response, market, since, limit);
     }
     async fetchTradingFees(params = {}) {

package/dist/cjs/src/currencycom.js

@@ -1081,7 +1081,7 @@ class currencycom extends currencycom$1 {
             // 'limit': 500, // default 500, max 1000
         };
         if (limit !== undefined) {
-            request['limit'] = limit; // default 500, max 1000
+            request['limit'] = Math.min(limit, 1000); // default 500, max 1000
         }
         if (since !== undefined) {
             request['startTime'] = since;

package/dist/cjs/src/huobi.js

@@ -2551,7 +2551,7 @@ class huobi extends huobi$1 {
         }
         request[fieldName] = market['id'];
         if (limit !== undefined) {
-            request['size'] = limit; // max 2000
+            request['size'] = Math.min(limit, 2000); // max 2000
         }
         const response = await this[method](this.extend(request, params));
         //

package/dist/cjs/src/huobijp.js

@@ -869,7 +869,7 @@ class huobijp extends huobijp$1 {
             'symbol': market['id'],
         };
         if (limit !== undefined) {
-            request['size'] = limit;
+            request['size'] = Math.min(limit, 2000);
         }
         const response = await this.marketGetHistoryTrade(this.extend(request, params));
         //

package/dist/cjs/src/idex.js

@@ -508,7 +508,7 @@ class idex extends idex$1 {
             request['start'] = since;
         }
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 1000);
         }
         // [
         //   {