ccxt 4.2.11 → 4.2.12

package/js/src/pro/binance.js

@@ -73,6 +73,12 @@ export default class binance extends binanceRest {
                     'future': 50,
                     'delivery': 50, // max 200
                 },
+                'subscriptionLimitByStream': {
+                    'spot': 200,
+                    'margin': 200,
+                    'future': 200,
+                    'delivery': 200,
+                },
                 'streamBySubscriptionsHash': {},
                 'streamIndex': -1,
                 // get updates every 1000ms or 100ms
@@ -121,7 +127,7 @@ export default class binance extends binanceRest {
         this.options['requestId'][url] = newValue;
         return newValue;
     }
-    stream(type, subscriptionHash) {
+    stream(type, subscriptionHash, numSubscriptions = 1) {
         const streamBySubscriptionsHash = this.safeValue(this.options, 'streamBySubscriptionsHash', {});
         let stream = this.safeString(streamBySubscriptionsHash, subscriptionHash);
         if (stream === undefined) {
@@ -133,6 +139,17 @@ export default class binance extends binanceRest {
             this.options['streamIndex'] = streamIndex;
             stream = this.numberToString(normalizedIndex);
             this.options['streamBySubscriptionsHash'][subscriptionHash] = stream;
+            const subscriptionsByStreams = this.safeValue(this.options, 'numSubscriptionsByStream');
+            if (subscriptionsByStreams === undefined) {
+                this.options['numSubscriptionsByStream'] = {};
+            }
+            const subscriptionsByStream = this.safeInteger(this.options['numSubscriptionsByStream'], stream, 0);
+            const newNumSubscriptions = subscriptionsByStream + numSubscriptions;
+            const subscriptionLimitByStream = this.safeInteger(this.options, 'subscriptionLimitByStream', 200);
+            if (newNumSubscriptions > subscriptionLimitByStream) {
+                throw new BadRequest(this.id + ' reached the limit of subscriptions by stream. Increase the number of streams, or increase the stream limit or subscription limit by stream if the exchange allows.');
+            }
+            this.options['numSubscriptionsByStream'][stream] = subscriptionsByStream + numSubscriptions;
         }
         return stream;
     }
@@ -203,8 +220,14 @@ export default class binance extends binanceRest {
             type = firstMarket['linear'] ? 'future' : 'delivery';
         }
         const name = 'depth';
-        const url = this.urls['api']['ws'][type] + '/' + this.stream(type, 'multipleOrderbook');
-        const requestId = this.requestId(url);
+        let streamHash = 'multipleOrderbook';
+        if (symbols !== undefined) {
+            const symbolsLength = symbols.length;
+            if (symbolsLength > 200) {
+                throw new BadRequest(this.id + ' watchOrderBookForSymbols() accepts 200 symbols at most. To watch more symbols call watchOrderBookForSymbols() multiple times');
+            }
+            streamHash += '::' + symbols.join(',');
+        }
         const watchOrderBookRate = this.safeString(this.options, 'watchOrderBookRate', '100');
         const subParams = [];
         const messageHashes = [];
@@ -216,6 +239,9 @@ export default class binance extends binanceRest {
             const symbolHash = messageHash + '@' + watchOrderBookRate + 'ms';
             subParams.push(symbolHash);
         }
+        const messageHashesLength = messageHashes.length;
+        const url = this.urls['api']['ws'][type] + '/' + this.stream(type, streamHash, messageHashesLength);
+        const requestId = this.requestId(url);
         const request = {
             'method': 'SUBSCRIBE',
             'params': subParams,
@@ -459,6 +485,14 @@ export default class binance extends binanceRest {
          */
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols, undefined, false, true, true);
+        let streamHash = 'multipleTrades';
+        if (symbols !== undefined) {
+            const symbolsLength = symbols.length;
+            if (symbolsLength > 200) {
+                throw new BadRequest(this.id + ' watchTradesForSymbols() accepts 200 symbols at most. To watch more symbols call watchTradesForSymbols() multiple times');
+            }
+            streamHash += '::' + symbols.join(',');
+        }
         const options = this.safeValue(this.options, 'watchTradesForSymbols', {});
         const name = this.safeString(options, 'name', 'trade');
         const firstMarket = this.market(symbols[0]);
@@ -474,7 +508,8 @@ export default class binance extends binanceRest {
             subParams.push(currentMessageHash);
         }
         const query = this.omit(params, 'type');
-        const url = this.urls['api']['ws'][type] + '/' + this.stream(type, 'multipleTrades');
+        const subParamsLength = subParams.length;
+        const url = this.urls['api']['ws'][type] + '/' + this.stream(type, streamHash, subParamsLength);
         const requestId = this.requestId(url);
         const request = {
             'method': 'SUBSCRIBE',
@@ -958,30 +993,30 @@ export default class binance extends binanceRest {
         }
         const marketId = this.safeString(message, 's');
         const symbol = this.safeSymbol(marketId, undefined, undefined, marketType);
-        const last = this.safeFloat(message, 'c');
-        const ticker = {
+        const market = this.safeMarket(marketId, undefined, undefined, marketType);
+        const last = this.safeString(message, 'c');
+        return this.safeTicker({
             'symbol': symbol,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'high': this.safeFloat(message, 'h'),
-            'low': this.safeFloat(message, 'l'),
-            'bid': this.safeFloat(message, 'b'),
-            'bidVolume': this.safeFloat(message, 'B'),
-            'ask': this.safeFloat(message, 'a'),
-            'askVolume': this.safeFloat(message, 'A'),
-            'vwap': this.safeFloat(message, 'w'),
-            'open': this.safeFloat(message, 'o'),
+            'high': this.safeString(message, 'h'),
+            'low': this.safeString(message, 'l'),
+            'bid': this.safeString(message, 'b'),
+            'bidVolume': this.safeString(message, 'B'),
+            'ask': this.safeString(message, 'a'),
+            'askVolume': this.safeString(message, 'A'),
+            'vwap': this.safeString(message, 'w'),
+            'open': this.safeString(message, 'o'),
             'close': last,
             'last': last,
-            'previousClose': this.safeFloat(message, 'x'),
-            'change': this.safeFloat(message, 'p'),
-            'percentage': this.safeFloat(message, 'P'),
+            'previousClose': this.safeString(message, 'x'),
+            'change': this.safeString(message, 'p'),
+            'percentage': this.safeString(message, 'P'),
             'average': undefined,
-            'baseVolume': this.safeFloat(message, 'v'),
-            'quoteVolume': this.safeFloat(message, 'q'),
+            'baseVolume': this.safeString(message, 'v'),
+            'quoteVolume': this.safeString(message, 'q'),
             'info': message,
-        };
-        return ticker;
+        }, market);
     }
     handleTicker(client, message) {
         //
@@ -2246,7 +2281,8 @@ export default class binance extends binanceRest {
             market = this.getMarketFromSymbols(symbols);
             messageHash = '::' + symbols.join(',');
         }
-        let type = this.handleMarketTypeAndParams('watchPositions', market, params);
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('watchPositions', market, params);
         if (type === 'spot' || type === 'margin') {
             type = 'future';
         }

package/js/src/pro/coinbase.d.ts

@@ -1,10 +1,10 @@
 import coinbaseRest from '../coinbase.js';
-import { Ticker, Int, Trade, OrderBook, Order } from '../base/types.js';
+import { Strings, Tickers, Ticker, Int, Trade, OrderBook, Order } from '../base/types.js';
 export default class coinbase extends coinbaseRest {
     describe(): any;
     subscribe(name: any, symbol?: any, params?: {}): Promise<any>;
     watchTicker(symbol: any, params?: {}): Promise<Ticker>;
-    watchTickers(symbols?: any, params?: {}): Promise<any>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: any, message: any): any;
     parseWsTicker(ticker: any, market?: any): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/coinbase.js

@@ -117,7 +117,10 @@ export default class coinbase extends coinbaseRest {
         }
         const name = 'ticker_batch';
         const tickers = await this.subscribe(name, symbols, params);
-        return tickers;
+        if (this.newUpdates) {
+            return tickers;
+        }
+        return this.tickers;
     }
     handleTickers(client, message) {
         //

package/js/src/pro/coinbasepro.d.ts

@@ -1,5 +1,5 @@
 import coinbaseproRest from '../coinbasepro.js';
-import type { Int, Ticker, Str, Strings, OrderBook, Trade, Order } from '../base/types.js';
+import type { Tickers, Int, Ticker, Str, Strings, OrderBook, Trade, Order } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class coinbasepro extends coinbaseproRest {
     describe(): any;
@@ -12,7 +12,7 @@ export default class coinbasepro extends coinbaseproRest {
     subscribe(name: any, symbol?: any, messageHashStart?: any, params?: {}): Promise<any>;
     subscribeMultiple(name: any, symbols?: any[], messageHashStart?: any, params?: {}): Promise<any>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/hitbtc.d.ts

@@ -1,5 +1,5 @@
 import hitbtcRest from '../hitbtc.js';
-import type { Int, OHLCV, OrderSide, OrderType, Strings } from '../base/types.js';
+import type { Tickers, Int, OHLCV, OrderSide, OrderType, Strings } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 import { Str, OrderBook, Order, Trade, Ticker, Balances } from '../base/types';
 export default class hitbtc extends hitbtcRest {
@@ -13,7 +13,7 @@ export default class hitbtc extends hitbtcRest {
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    watchTickers(symbols?: any, params?: {}): Promise<any>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): any;
     parseWsTicker(ticker: any, market?: any): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/poloniex.d.ts

@@ -1,5 +1,5 @@
 import poloniexRest from '../poloniex.js';
-import type { Int, OHLCV, OrderSide, OrderType, Str, Strings, OrderBook, Order, Trade, Ticker, Balances } from '../base/types.js';
+import type { Tickers, Int, OHLCV, OrderSide, OrderType, Str, Strings, OrderBook, Order, Trade, Ticker, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class poloniex extends poloniexRest {
     describe(): any;
@@ -13,7 +13,7 @@ export default class poloniex extends poloniexRest {
     handleOrderRequest(client: Client, message: any): void;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    watchTickers(symbols?: any, params?: {}): Promise<any>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/upbit.d.ts

@@ -17,7 +17,7 @@ export default class upbit extends Exchange {
         limits: {
             withdraw: {
                 min: number;
-                max: any;
+                max: number;
             };
         };
     }>;
@@ -31,111 +31,13 @@ export default class upbit extends Exchange {
         precision: any;
         limits: {
             withdraw: {
-                min: number;
-                max: any;
-            };
-        };
-    }>;
-    fetchMarket(symbol: string, params?: {}): Promise<{
-        id: string;
-        symbol: string;
-        base: string;
-        quote: string;
-        settle: any;
-        baseId: string;
-        quoteId: string;
-        settleId: any;
-        type: string;
-        spot: boolean;
-        margin: boolean;
-        swap: boolean;
-        future: boolean;
-        option: boolean;
-        active: boolean;
-        contract: boolean;
-        linear: any;
-        inverse: any;
-        taker: number;
-        maker: number;
-        contractSize: any;
-        expiry: any;
-        expiryDatetime: any;
-        strike: any;
-        optionType: any;
-        precision: {
-            amount: number;
-            price: number;
-        };
-        limits: {
-            leverage: {
-                min: any;
-                max: any;
-            };
-            amount: {
-                min: number;
-                max: any;
-            };
-            price: {
-                min: any;
-                max: any;
-            };
-            cost: {
-                min: number;
-                max: number;
-            };
-            info: any;
-        };
-    }>;
-    fetchMarketById(id: string, params?: {}): Promise<{
-        id: string;
-        symbol: string;
-        base: string;
-        quote: string;
-        settle: any;
-        baseId: string;
-        quoteId: string;
-        settleId: any;
-        type: string;
-        spot: boolean;
-        margin: boolean;
-        swap: boolean;
-        future: boolean;
-        option: boolean;
-        active: boolean;
-        contract: boolean;
-        linear: any;
-        inverse: any;
-        taker: number;
-        maker: number;
-        contractSize: any;
-        expiry: any;
-        expiryDatetime: any;
-        strike: any;
-        optionType: any;
-        precision: {
-            amount: number;
-            price: number;
-        };
-        limits: {
-            leverage: {
-                min: any;
-                max: any;
-            };
-            amount: {
-                min: number;
-                max: any;
-            };
-            price: {
-                min: any;
-                max: any;
-            };
-            cost: {
                 min: number;
                 max: number;
             };
-            info: any;
         };
     }>;
+    fetchMarket(symbol: string, params?: {}): Promise<import("./base/types.js").MarketInterface>;
+    fetchMarketById(id: string, params?: {}): Promise<import("./base/types.js").MarketInterface>;
     fetchMarkets(params?: {}): Promise<import("./base/types.js").MarketInterface[]>;
     parseMarket(market: any): Market;
     parseBalance(response: any): Balances;

package/js/src/upbit.js

@@ -264,11 +264,11 @@ export default class upbit extends Exchange {
         else if ((locked !== undefined) && locked) {
             active = false;
         }
-        const maxOnetimeWithdrawal = this.safeNumber(withdrawLimits, 'onetime');
-        const maxDailyWithdrawal = this.safeNumber(withdrawLimits, 'daily', maxOnetimeWithdrawal);
-        const remainingDailyWithdrawal = this.safeNumber(withdrawLimits, 'remaining_daily', maxDailyWithdrawal);
+        const maxOnetimeWithdrawal = this.safeString(withdrawLimits, 'onetime');
+        const maxDailyWithdrawal = this.safeString(withdrawLimits, 'daily', maxOnetimeWithdrawal);
+        const remainingDailyWithdrawal = this.safeString(withdrawLimits, 'remaining_daily', maxDailyWithdrawal);
         let maxWithdrawLimit = undefined;
-        if (remainingDailyWithdrawal > 0) {
+        if (Precise.stringGt(remainingDailyWithdrawal, '0')) {
             maxWithdrawLimit = remainingDailyWithdrawal;
         }
         else {
@@ -287,7 +287,7 @@ export default class upbit extends Exchange {
             'limits': {
                 'withdraw': {
                     'min': this.safeNumber(withdrawLimits, 'minimum'),
-                    'max': maxWithdrawLimit,
+                    'max': this.parseNumber(maxWithdrawLimit),
                 },
             },
         };
@@ -347,10 +347,10 @@ export default class upbit extends Exchange {
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
         const state = this.safeString(marketInfo, 'state');
-        const bidFee = this.safeNumber(response, 'bid_fee');
-        const askFee = this.safeNumber(response, 'ask_fee');
-        const fee = Math.max(bidFee, askFee);
-        return {
+        const bidFee = this.safeString(response, 'bid_fee');
+        const askFee = this.safeString(response, 'ask_fee');
+        const fee = this.parseNumber(Precise.stringMax(bidFee, askFee));
+        return this.safeMarketStructure({
             'id': marketId,
             'symbol': base + '/' + quote,
             'base': base,
@@ -399,7 +399,7 @@ export default class upbit extends Exchange {
                 },
                 'info': response,
             },
-        };
+        });
     }
     async fetchMarkets(params = {}) {
         /**
@@ -428,7 +428,7 @@ export default class upbit extends Exchange {
         const [quoteId, baseId] = id.split('-');
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
-        return {
+        return this.safeMarketStructure({
             'id': id,
             'symbol': base + '/' + quote,
             'base': base,
@@ -478,7 +478,7 @@ export default class upbit extends Exchange {
             },
             'created': undefined,
             'info': market,
-        };
+        });
     }
     parseBalance(response) {
         const result = {

package/js/src/woo.js

@@ -44,6 +44,8 @@ export default class woo extends Exchange {
                 'createMarketOrder': false,
                 'createMarketOrderWithCost': false,
                 'createMarketSellOrderWithCost': false,
+                'createTrailingAmountOrder': true,
+                'createTrailingPercentOrder': true,
                 'createOrder': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': false,

package/package.json

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

package/skip-tests.json

@@ -625,6 +625,11 @@
                 "bid": "broken bid-ask",
                 "ask": "broken bid-ask",
                 "baseVolume": "negative value"
+            },
+            "loadMarkets": {
+                "taker": "key is there when run locally, but not on travis",
+                "maker": "key is there when run locally, but not on travis",
+                "currencyIdAndCode": true
             }
         }
     },