ccxt 4.3.19 → 4.3.21

package/dist/cjs/src/phemex.js

@@ -2432,12 +2432,14 @@ class phemex extends phemex$1 {
          * @name phemex#createOrder
          * @description create a trade order
          * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#place-order
+         * @see https://phemex-docs.github.io/#place-order-http-put-prefered-3
          * @param {string} symbol unified symbol of the market to create an order in
          * @param {string} type 'market' or 'limit'
          * @param {string} side 'buy' or 'sell'
          * @param {float} amount how much of currency you want to trade in units of base currency
          * @param {float} [price] the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {float} [params.trigger] trigger price for conditional orders
          * @param {object} [params.takeProfit] *swap only* *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered (perpetual swap markets only)
          * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
          * @param {object} [params.stopLoss] *swap only* *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered (perpetual swap markets only)
@@ -2448,7 +2450,7 @@ class phemex extends phemex$1 {
         const market = this.market(symbol);
         const requestSide = this.capitalize(side);
         type = this.capitalize(type);
-        const reduceOnly = this.safeValue(params, 'reduceOnly');
+        const reduceOnly = this.safeBool(params, 'reduceOnly');
         const request = {
             // common
             'symbol': market['id'],
@@ -2492,13 +2494,13 @@ class phemex extends phemex$1 {
             request['clOrdID'] = clientOrderId;
             params = this.omit(params, ['clOrdID', 'clientOrderId']);
         }
-        const stopPrice = this.safeStringN(params, ['stopPx', 'stopPrice', 'triggerPrice']);
-        if (stopPrice !== undefined) {
+        const triggerPrice = this.safeStringN(params, ['stopPx', 'stopPrice', 'triggerPrice']);
+        if (triggerPrice !== undefined) {
             if (market['settle'] === 'USDT') {
-                request['stopPxRp'] = this.priceToPrecision(symbol, stopPrice);
+                request['stopPxRp'] = this.priceToPrecision(symbol, triggerPrice);
             }
             else {
-                request['stopPxEp'] = this.toEp(stopPrice, market);
+                request['stopPxEp'] = this.toEp(triggerPrice, market);
             }
         }
         params = this.omit(params, ['stopPx', 'stopPrice', 'stopLoss', 'takeProfit', 'triggerPrice']);
@@ -2509,6 +2511,15 @@ class phemex extends phemex$1 {
                     qtyType = 'ByQuote';
                 }
             }
+            if (triggerPrice !== undefined) {
+                if (type === 'Limit') {
+                    request['ordType'] = 'StopLimit';
+                }
+                else if (type === 'Market') {
+                    request['ordType'] = 'Stop';
+                }
+                request['trigger'] = 'ByLastPrice';
+            }
             request['qtyType'] = qtyType;
             if (qtyType === 'ByQuote') {
                 let cost = this.safeNumber(params, 'cost');
@@ -2549,7 +2560,7 @@ class phemex extends phemex$1 {
             else {
                 request['orderQty'] = this.parseToInt(amount);
             }
-            if (stopPrice !== undefined) {
+            if (triggerPrice !== undefined) {
                 const triggerType = this.safeString(params, 'triggerType', 'ByMarkPrice');
                 request['triggerType'] = triggerType;
             }

package/dist/cjs/src/pro/htx.js

@@ -1897,7 +1897,7 @@ class htx extends htx$1 {
         //        "data": { "user-id": "35930539" }
         //    }
         //
-        const promise = client.futures['authenticated'];
+        const promise = client.futures['auth'];
         promise.resolve(message);
     }
     handleErrorMessage(client, message) {
@@ -1925,6 +1925,12 @@ class htx extends htx$1 {
         //         'err-msg': "Non - single account user is not available, please check through the cross and isolated account asset interface",
         //         "ts": 1698419490189
         //     }
+        //     {
+        //         "action":"req",
+        //         "code":2002,
+        //         "ch":"auth",
+        //         "message":"auth.fail"
+        //     }
         //
         const status = this.safeString(message, 'status');
         if (status === 'error') {
@@ -1935,6 +1941,7 @@ class htx extends htx$1 {
                 const errorCode = this.safeString(message, 'err-code');
                 try {
                     this.throwExactlyMatchedException(this.exceptions['ws']['exact'], errorCode, this.json(message));
+                    throw new errors.ExchangeError(this.json(message));
                 }
                 catch (e) {
                     const messageHash = this.safeString(subscription, 'messageHash');
@@ -1947,11 +1954,12 @@ class htx extends htx$1 {
             }
             return false;
         }
-        const code = this.safeInteger2(message, 'code', 'err-code');
-        if (code !== undefined && ((code !== 200) && (code !== 0))) {
+        const code = this.safeString2(message, 'code', 'err-code');
+        if (code !== undefined && ((code !== '200') && (code !== '0'))) {
             const feedback = this.id + ' ' + this.json(message);
             try {
                 this.throwExactlyMatchedException(this.exceptions['ws']['exact'], code, feedback);
+                throw new errors.ExchangeError(feedback);
             }
             catch (e) {
                 if (e instanceof errors.AuthenticationError) {
@@ -2305,9 +2313,6 @@ class htx extends htx$1 {
             'url': url,
             'hostname': hostname,
         };
-        if (type === 'spot') {
-            this.options['ws']['gunzip'] = false;
-        }
         await this.authenticate(authParams);
         return await this.watch(url, messageHash, this.extend(request, params), channel, extendedSubsription);
     }
@@ -2319,7 +2324,7 @@ class htx extends htx$1 {
             throw new errors.ArgumentsRequired(this.id + ' authenticate requires a url, hostname and type argument');
         }
         this.checkRequiredCredentials();
-        const messageHash = 'authenticated';
+        const messageHash = 'auth';
         const relativePath = url.replace('wss://' + hostname, '');
         const client = this.client(url);
         const future = client.future(messageHash);

package/dist/cjs/src/pro/kucoinfutures.js

@@ -15,6 +15,7 @@ class kucoinfutures extends kucoinfutures$1 {
                 'watchTickers': true,
                 'watchBidsAsks': true,
                 'watchTrades': true,
+                'watchOHLCV': true,
                 'watchOrderBook': true,
                 'watchOrders': true,
                 'watchBalance': true,
@@ -25,6 +26,21 @@ class kucoinfutures extends kucoinfutures$1 {
                 'watchOrderBookForSymbols': true,
             },
             'options': {
+                'timeframes': {
+                    '1m': '1min',
+                    '3m': '1min',
+                    '5m': '5min',
+                    '15m': '15min',
+                    '30m': '30min',
+                    '1h': '1hour',
+                    '2h': '2hour',
+                    '4h': '4hour',
+                    '8h': '8hour',
+                    '12h': '12hour',
+                    '1d': '1day',
+                    '1w': '1week',
+                    '1M': '1month',
+                },
                 'accountsByType': {
                     'swap': 'future',
                     'cross': 'margin',
@@ -567,6 +583,81 @@ class kucoinfutures extends kucoinfutures$1 {
         client.resolve(trades, messageHash);
         return message;
     }
+    async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#watchOHLCV
+         * @see https://www.kucoin.com/docs/websocket/futures-trading/public-channels/klines
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @param {int} [since] timestamp in ms of the earliest candle to fetch
+         * @param {int} [limit] the maximum amount of candles to fetch
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        await this.loadMarkets();
+        symbol = this.symbol(symbol);
+        const url = await this.negotiate(false);
+        const marketId = this.marketId(symbol);
+        const timeframes = this.safeDict(this.options, 'timeframes');
+        const timeframeId = this.safeString(timeframes, timeframe, timeframe);
+        const topic = '/contractMarket/limitCandle:' + marketId + '_' + timeframeId;
+        const messageHash = 'ohlcv::' + symbol + '_' + timeframe;
+        const ohlcv = await this.subscribe(url, messageHash, topic, undefined, params);
+        if (this.newUpdates) {
+            limit = ohlcv.getLimit(symbol, limit);
+        }
+        return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
+    }
+    handleOHLCV(client, message) {
+        //
+        //    {
+        //        "topic":"/contractMarket/limitCandle:LTCUSDTM_1min",
+        //        "type":"message",
+        //        "data":{
+        //            "symbol":"LTCUSDTM",
+        //            "candles":[
+        //                "1715470980",
+        //                "81.38",
+        //                "81.38",
+        //                "81.38",
+        //                "81.38",
+        //                "61.0",
+        //                "61"
+        //            ],
+        //            "time":1715470994801
+        //        },
+        //        "subject":"candle.stick"
+        //    }
+        //
+        const topic = this.safeString(message, 'topic');
+        const parts = topic.split('_');
+        const timeframeId = this.safeString(parts, 1);
+        const data = this.safeDict(message, 'data');
+        const timeframes = this.safeDict(this.options, 'timeframes');
+        const timeframe = this.findTimeframe(timeframeId, timeframes);
+        const marketId = this.safeString(data, 'symbol');
+        const symbol = this.safeSymbol(marketId);
+        const messageHash = 'ohlcv::' + symbol + '_' + timeframe;
+        const ohlcv = this.safeList(data, 'candles');
+        const parsed = [
+            this.safeInteger(ohlcv, 0),
+            this.safeNumber(ohlcv, 1),
+            this.safeNumber(ohlcv, 2),
+            this.safeNumber(ohlcv, 3),
+            this.safeNumber(ohlcv, 4),
+            this.safeNumber(ohlcv, 6), // Note value 5 is incorrect and will be fixed in subsequent versions of kucoin
+        ];
+        this.ohlcvs[symbol] = this.safeDict(this.ohlcvs, symbol, {});
+        if (!(timeframe in this.ohlcvs[symbol])) {
+            const limit = this.safeInteger(this.options, 'OHLCVLimit', 1000);
+            this.ohlcvs[symbol][timeframe] = new Cache.ArrayCacheByTimestamp(limit);
+        }
+        const stored = this.ohlcvs[symbol][timeframe];
+        stored.append(parsed);
+        client.resolve(stored, messageHash);
+    }
     async watchOrderBook(symbol, limit = undefined, params = {}) {
         /**
          * @method
@@ -983,6 +1074,7 @@ class kucoinfutures extends kucoinfutures$1 {
         const methods = {
             'level2': this.handleOrderBook,
             'ticker': this.handleTicker,
+            'candle.stick': this.handleOHLCV,
             'tickerV2': this.handleBidAsk,
             'availableBalance.change': this.handleBalance,
             'match': this.handleTrade,

package/dist/cjs/src/pro/woo.js

@@ -547,6 +547,16 @@ class woo extends woo$1 {
         const request = this.extend(subscribe, message);
         return await this.watch(url, messageHash, request, messageHash, subscribe);
     }
+    async watchPrivateMultiple(messageHashes, message, params = {}) {
+        await this.authenticate(params);
+        const url = this.urls['api']['ws']['private'] + '/' + this.uid;
+        const requestId = this.requestId(url);
+        const subscribe = {
+            'id': requestId,
+        };
+        const request = this.extend(subscribe, message);
+        return await this.watchMultiple(url, messageHashes, request, messageHashes, subscribe);
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -558,10 +568,13 @@ class woo extends woo$1 {
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {bool} [params.trigger] true if trigger order
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
-        const topic = 'executionreport';
+        const trigger = this.safeBool2(params, 'stop', 'trigger', false);
+        const topic = (trigger) ? 'algoexecutionreportv2' : 'executionreport';
+        params = this.omit(params, ['stop', 'trigger']);
         let messageHash = topic;
         if (symbol !== undefined) {
             const market = this.market(symbol);
@@ -584,15 +597,19 @@ class woo extends woo$1 {
          * @method
          * @name woo#watchOrders
          * @see https://docs.woo.org/#executionreport
+         * @see https://docs.woo.org/#algoexecutionreportv2
          * @description watches information on multiple trades made by the user
          * @param {string} symbol unified market symbol of the market orders were made in
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {bool} [params.trigger] true if trigger order
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
-        const topic = 'executionreport';
+        const trigger = this.safeBool2(params, 'stop', 'trigger', false);
+        const topic = (trigger) ? 'algoexecutionreportv2' : 'executionreport';
+        params = this.omit(params, ['stop', 'trigger']);
         let messageHash = 'myTrades';
         if (symbol !== undefined) {
             const market = this.market(symbol);
@@ -718,15 +735,29 @@ class woo extends woo$1 {
         //         }
         //     }
         //
-        const order = this.safeDict(message, 'data');
-        const tradeId = this.safeString(order, 'tradeId');
-        if ((tradeId !== undefined) && (tradeId !== '0')) {
-            this.handleMyTrade(client, order);
+        const topic = this.safeString(message, 'topic');
+        const data = this.safeValue(message, 'data');
+        if (Array.isArray(data)) {
+            // algoexecutionreportv2
+            for (let i = 0; i < data.length; i++) {
+                const order = data[i];
+                const tradeId = this.omitZero(this.safeString(data, 'tradeId'));
+                if (tradeId !== undefined) {
+                    this.handleMyTrade(client, order);
+                }
+                this.handleOrder(client, order, topic);
+            }
+        }
+        else {
+            // executionreport
+            const tradeId = this.omitZero(this.safeString(data, 'tradeId'));
+            if (tradeId !== undefined) {
+                this.handleMyTrade(client, data);
+            }
+            this.handleOrder(client, data, topic);
         }
-        this.handleOrder(client, order);
     }
-    handleOrder(client, message) {
-        const topic = 'executionreport';
+    handleOrder(client, message, topic) {
         const parsed = this.parseWsOrder(message);
         const symbol = this.safeString(parsed, 'symbol');
         const orderId = this.safeString(parsed, 'id');
@@ -811,12 +842,17 @@ class woo extends woo$1 {
          * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
          */
         await this.loadMarkets();
-        let messageHash = '';
+        const messageHashes = [];
         symbols = this.marketSymbols(symbols);
         if (!this.isEmpty(symbols)) {
-            messageHash = '::' + symbols.join(',');
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                messageHashes.push('positions::' + symbol);
+            }
+        }
+        else {
+            messageHashes.push('positions');
         }
-        messageHash = 'positions' + messageHash;
         const url = this.urls['api']['ws']['private'] + '/' + this.uid;
         const client = this.client(url);
         this.setPositionsCache(client, symbols);
@@ -830,7 +866,7 @@ class woo extends woo$1 {
             'event': 'subscribe',
             'topic': 'position',
         };
-        const newPositions = await this.watchPrivate(messageHash, request, params);
+        const newPositions = await this.watchPrivateMultiple(messageHashes, request, params);
         if (this.newUpdates) {
             return newPositions;
         }
@@ -906,17 +942,8 @@ class woo extends woo$1 {
             const position = this.parsePosition(rawPosition, market);
             newPositions.push(position);
             cache.append(position);
-        }
-        const messageHashes = this.findMessageHashes(client, 'positions::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
-            if (!this.isEmpty(positions)) {
-                client.resolve(positions, messageHash);
-            }
+            const messageHash = 'positions::' + market['symbol'];
+            client.resolve(position, messageHash);
         }
         client.resolve(newPositions, 'positions');
     }
@@ -1037,6 +1064,7 @@ class woo extends woo$1 {
             'kline': this.handleOHLCV,
             'auth': this.handleAuth,
             'executionreport': this.handleOrderUpdate,
+            'algoexecutionreportv2': this.handleOrderUpdate,
             'trade': this.handleTrade,
             'balance': this.handleBalance,
             'position': this.handlePositions,

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks, Leverage, Leverages, Option, OptionChain, Conversion } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
-declare const version = "4.3.18";
+declare const version = "4.3.20";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.19';
+const version = '4.3.21';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/binance.d.ts

@@ -464,6 +464,7 @@ interface Exchange {
     fapiPublicGetContinuousKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetMarkPriceKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetIndexPriceKlines(params?: {}): Promise<implicitReturnType>;
+    fapiPublicGetPremiumIndexKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingRate(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingInfo(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetPremiumIndex(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/binancecoinm.d.ts

@@ -464,6 +464,7 @@ interface binance {
     fapiPublicGetContinuousKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetMarkPriceKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetIndexPriceKlines(params?: {}): Promise<implicitReturnType>;
+    fapiPublicGetPremiumIndexKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingRate(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingInfo(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetPremiumIndex(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/binanceus.d.ts

@@ -516,6 +516,7 @@ interface binance {
     fapiPublicGetContinuousKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetMarkPriceKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetIndexPriceKlines(params?: {}): Promise<implicitReturnType>;
+    fapiPublicGetPremiumIndexKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingRate(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingInfo(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetPremiumIndex(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/binanceusdm.d.ts

@@ -464,6 +464,7 @@ interface binance {
     fapiPublicGetContinuousKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetMarkPriceKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetIndexPriceKlines(params?: {}): Promise<implicitReturnType>;
+    fapiPublicGetPremiumIndexKlines(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingRate(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetFundingInfo(params?: {}): Promise<implicitReturnType>;
     fapiPublicGetPremiumIndex(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/bitget.d.ts

@@ -100,6 +100,9 @@ interface Exchange {
     privateSpotGetV2SpotAccountSubaccountAssets(params?: {}): Promise<implicitReturnType>;
     privateSpotGetV2SpotAccountBills(params?: {}): Promise<implicitReturnType>;
     privateSpotGetV2SpotAccountTransferRecords(params?: {}): Promise<implicitReturnType>;
+    privateSpotGetV2AccountFundingAssets(params?: {}): Promise<implicitReturnType>;
+    privateSpotGetV2AccountBotAssets(params?: {}): Promise<implicitReturnType>;
+    privateSpotGetV2AccountAllAccountBalance(params?: {}): Promise<implicitReturnType>;
     privateSpotGetV2SpotWalletDepositAddress(params?: {}): Promise<implicitReturnType>;
     privateSpotGetV2SpotWalletDepositRecords(params?: {}): Promise<implicitReturnType>;
     privateSpotGetV2SpotWalletWithdrawalRecords(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/okx.d.ts

@@ -58,6 +58,9 @@ interface Exchange {
     publicGetSprdBooks(params?: {}): Promise<implicitReturnType>;
     publicGetSprdTicker(params?: {}): Promise<implicitReturnType>;
     publicGetSprdPublicTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketSprdTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketSprdCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketSprdHistoryCandles(params?: {}): Promise<implicitReturnType>;
     publicGetTradingBotGridAiParam(params?: {}): Promise<implicitReturnType>;
     publicGetTradingBotGridMinInvestment(params?: {}): Promise<implicitReturnType>;
     publicGetTradingBotPublicRsiBackTesting(params?: {}): Promise<implicitReturnType>;

package/js/src/ascendex.d.ts

@@ -71,7 +71,7 @@ export default class ascendex extends Exchange {
     };
     fetchFundingRates(symbols?: Strings, params?: {}): Promise<any>;
     modifyMarginHelper(symbol: string, amount: any, type: any, params?: {}): Promise<MarginModification>;
-    parseMarginModification(data: any, market?: Market): MarginModification;
+    parseMarginModification(data: Dict, market?: Market): MarginModification;
     reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;

package/js/src/base/Exchange.d.ts

@@ -1091,7 +1091,7 @@ export default class Exchange {
     convertMarketIdExpireDate(date: string): string;
     fetchPositionHistory(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Position>;
     fetchPositionsHistory(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    parseMarginModification(data: any, market?: Market): MarginModification;
+    parseMarginModification(data: Dict, market?: Market): MarginModification;
     parseMarginModifications(response: object[], symbols?: string[], symbolKey?: Str, marketType?: MarketType): MarginModification[];
     fetchTransfer(id: string, code?: Str, params?: {}): Promise<TransferEntry>;
     fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<TransferEntries>;

package/js/src/base/Exchange.js

@@ -5935,6 +5935,9 @@ export default class Exchange {
                 if (method === 'fetchAccounts') {
                     response = await this[method](params);
                 }
+                else if (method === 'getLeverageTiersPaginated') {
+                    response = await this[method](symbol, params);
+                }
                 else {
                     response = await this[method](symbol, since, maxEntriesPerRequest, params);
                 }

package/js/src/base/functions/platform.d.ts

@@ -2,5 +2,6 @@ declare const isBrowser: boolean;
 declare const isElectron: boolean;
 declare const isWebWorker: boolean;
 declare const isWindows: boolean;
+declare const isDeno: boolean;
 declare const isNode: boolean;
-export { isBrowser, isElectron, isWebWorker, isNode, isWindows, };
+export { isBrowser, isElectron, isWebWorker, isNode, isDeno, isWindows, };

package/js/src/base/functions/platform.js

@@ -21,6 +21,7 @@ const isElectron = typeof process !== 'undefined' &&
     typeof process.versions.electron !== 'undefined';
 const isWebWorker = typeof WorkerGlobalScope !== 'undefined' && (self instanceof WorkerGlobalScope);
 const isWindows = typeof process !== 'undefined' && process.platform === "win32";
-const isNode = !(isBrowser || isWebWorker);
+const isDeno = typeof Deno !== 'undefined';
+const isNode = !(isBrowser || isWebWorker || isDeno);
 // ----------------------------------------------------------------------------
-export { isBrowser, isElectron, isWebWorker, isNode, isWindows, };
+export { isBrowser, isElectron, isWebWorker, isNode, isDeno, isWindows, };

package/js/src/binance.d.ts

@@ -280,7 +280,7 @@ export default class binance extends Exchange {
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
     request(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;
     modifyMarginHelper(symbol: string, amount: any, addOrReduce: any, params?: {}): Promise<any>;
-    parseMarginModification(data: any, market?: Market): MarginModification;
+    parseMarginModification(data: Dict, market?: Market): MarginModification;
     reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     fetchCrossBorrowRate(code: string, params?: {}): Promise<CrossBorrowRate>;

package/js/src/binance.js

@@ -133,7 +133,7 @@ export default class binance extends Exchange {
                 'fetchPositions': true,
                 'fetchPositionsHistory': false,
                 'fetchPositionsRisk': true,
-                'fetchPremiumIndexOHLCV': false,
+                'fetchPremiumIndexOHLCV': true,
                 'fetchSettlementHistory': true,
                 'fetchStatus': true,
                 'fetchTicker': true,
@@ -782,6 +782,7 @@ export default class binance extends Exchange {
                         'continuousKlines': { 'cost': 1, 'byLimit': [[99, 1], [499, 2], [1000, 5], [10000, 10]] },
                         'markPriceKlines': { 'cost': 1, 'byLimit': [[99, 1], [499, 2], [1000, 5], [10000, 10]] },
                         'indexPriceKlines': { 'cost': 1, 'byLimit': [[99, 1], [499, 2], [1000, 5], [10000, 10]] },
+                        'premiumIndexKlines': { 'cost': 1, 'byLimit': [[99, 1], [499, 2], [1000, 5], [10000, 10]] },
                         'fundingRate': 1,
                         'fundingInfo': 1,
                         'premiumIndex': 1,
@@ -4299,6 +4300,14 @@ export default class binance extends Exchange {
                 response = await this.fapiPublicGetIndexPriceKlines(this.extend(request, params));
             }
         }
+        else if (price === 'premiumIndex') {
+            if (market['inverse']) {
+                response = await this.dapiPublicGetPremiumIndexKlines(this.extend(request, params));
+            }
+            else {
+                response = await this.fapiPublicGetPremiumIndexKlines(this.extend(request, params));
+            }
+        }
         else if (market['linear']) {
             response = await this.fapiPublicGetKlines(this.extend(request, params));
         }

package/js/src/bingx.d.ts

@@ -104,7 +104,7 @@ export default class bingx extends Exchange {
     addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     setMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
-    parseMarginModification(data: any, market?: Market): MarginModification;
+    parseMarginModification(data: Dict, market?: Market): MarginModification;
     fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;
     parseLeverage(leverage: Dict, market?: Market): Leverage;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;

package/js/src/bitget.d.ts

@@ -144,7 +144,7 @@ export default class bitget extends Exchange {
     };
     parseFundingHistories(contracts: any, market?: any, since?: Int, limit?: Int): FundingHistory[];
     modifyMarginHelper(symbol: string, amount: any, type: any, params?: {}): Promise<MarginModification>;
-    parseMarginModification(data: any, market?: Market): MarginModification;
+    parseMarginModification(data: Dict, market?: Market): MarginModification;
     reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;

package/js/src/bitget.js

@@ -313,6 +313,9 @@ export default class bitget extends Exchange {
                             'v2/spot/account/subaccount-assets': 2,
                             'v2/spot/account/bills': 2,
                             'v2/spot/account/transferRecords': 1,
+                            'v2/account/funding-assets': 2,
+                            'v2/account/bot-assets': 2,
+                            'v2/account/all-account-balance': 20,
                             'v2/spot/wallet/deposit-address': 2,
                             'v2/spot/wallet/deposit-records': 2,
                             'v2/spot/wallet/withdrawal-records': 2,

package/js/src/bitmex.js

@@ -244,6 +244,7 @@ export default class bitmex extends Exchange {
                     'orderQty is invalid': InvalidOrder,
                     'Invalid price': InvalidOrder,
                     'Invalid stopPx for ordType': InvalidOrder,
+                    'Account is restricted': PermissionDenied, // {"error":{"message":"Account is restricted","name":"HTTPError"}}
                 },
                 'broad': {
                     'Signature not valid': AuthenticationError,

package/js/src/bybit.d.ts

@@ -211,6 +211,7 @@ export default class bybit extends Exchange {
     parseGreeks(greeks: Dict, market?: Market): Greeks;
     fetchMyLiquidations(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
     parseLiquidation(liquidation: any, market?: Market): Liquidation;
+    getLeverageTiersPaginated(symbol?: Str, params?: {}): Promise<any>;
     fetchLeverageTiers(symbols?: Strings, params?: {}): Promise<{}>;
     parseLeverageTiers(response: any, symbols?: Strings, marketIdKey?: any): {};
     parseMarketLeverageTiers(info: any, market?: Market): any[];