ccxt 4.0.66 → 4.0.68

package/js/src/lykke.js

@@ -57,7 +57,7 @@ export default class lykke extends Exchange {
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': false,
                 'fetchMyTrades': true,
-                'fetchOHLCV': 'emulated',
+                'fetchOHLCV': undefined,
                 'fetchOpenInterestHistory': false,
                 'fetchOpenOrders': true,
                 'fetchOrder': true,

package/js/src/phemex.js

@@ -3551,6 +3551,7 @@ export default class phemex extends Exchange {
         }
         const unrealizedPnl = Precise.stringMul(Precise.stringMul(priceDiff, contracts), contractSizeString);
         const marginRatio = Precise.stringDiv(maintenanceMarginString, collateral);
+        const isCross = this.safeValue(position, 'crossMargin');
         return this.safePosition({
             'info': position,
             'id': undefined,
@@ -3573,7 +3574,7 @@ export default class phemex extends Exchange {
             'maintenanceMarginPercentage': this.parseNumber(maintenanceMarginPercentageString),
             'marginRatio': this.parseNumber(marginRatio),
             'datetime': undefined,
-            'marginMode': undefined,
+            'marginMode': isCross ? 'cross' : 'isolated',
             'side': side,
             'hedged': false,
             'percentage': undefined,

package/js/src/pro/binance.js

@@ -88,7 +88,7 @@ export default class binance extends binanceRest {
                     'name': 'kline', // or indexPriceKline or markPriceKline (coin-m futures)
                 },
                 'watchOrderBook': {
-                    'snapshotMaxRetries': 3,
+                    'maxRetries': 3,
                 },
                 'watchBalance': {
                     'fetchBalanceSnapshot': false,

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

@@ -23,7 +23,7 @@ export default class bitfinex2 extends bitfinex2Rest {
     parseWsBalance(balance: any): import("../base/types.js").Balance;
     handleSystemStatus(client: Client, message: any): any;
     handleSubscriptionStatus(client: Client, message: any): any;
-    authenticate(params?: {}): any;
+    authenticate(params?: {}): Promise<any>;
     handleAuthenticationMessage(client: Client, message: any): void;
     watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     handleOrders(client: Client, message: any, subscription: any): void;

package/js/src/pro/bitfinex2.js

@@ -834,12 +834,13 @@ export default class bitfinex2 extends bitfinex2Rest {
         client.subscriptions[channelId] = message;
         return message;
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         const url = this.urls['api']['ws']['private'];
         const client = this.client(url);
         const messageHash = 'authenticated';
-        let future = this.safeValue(client.subscriptions, messageHash);
-        if (future === undefined) {
+        const future = client.future(messageHash);
+        const authenticated = this.safeValue(client.subscriptions, messageHash);
+        if (authenticated === undefined) {
             const nonce = this.milliseconds();
             const payload = 'AUTH' + nonce.toString();
             const signature = this.hmac(this.encode(payload), this.encode(this.secret), sha384, 'hex');
@@ -852,8 +853,7 @@ export default class bitfinex2 extends bitfinex2Rest {
                 'event': event,
             };
             const message = this.extend(request, params);
-            future = this.watch(url, messageHash, message);
-            client.subscriptions[messageHash] = future;
+            this.watch(url, messageHash, message, messageHash);
         }
         return future;
     }
@@ -862,7 +862,8 @@ export default class bitfinex2 extends bitfinex2Rest {
         const status = this.safeString(message, 'status');
         if (status === 'OK') {
             // we resolve the future here permanently so authentication only happens once
-            client.resolve(message, messageHash);
+            const future = this.safeValue(client.futures, messageHash);
+            future.resolve(true);
         }
         else {
             const error = new AuthenticationError(this.json(message));

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

@@ -28,7 +28,7 @@ export default class bitget extends bitgetRest {
     watchBalance(params?: {}): Promise<any>;
     handleBalance(client: Client, message: any): void;
     watchPublic(messageHash: any, args: any, params?: {}): Promise<any>;
-    authenticate(params?: {}): any;
+    authenticate(params?: {}): Promise<any>;
     watchPrivate(messageHash: any, subscriptionHash: any, args: any, params?: {}): Promise<any>;
     handleAuthenticate(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;

package/js/src/pro/bitget.js

@@ -54,7 +54,9 @@ export default class bitget extends bitgetRest {
                 'ws': {
                     'exact': {
                         '30001': BadRequest,
-                        '30015': AuthenticationError, // { event: 'error', code: 30015, msg: 'Invalid sign' }
+                        '30015': AuthenticationError,
+                        '30016': BadRequest,
+                        '30011': AuthenticationError, // { event: 'error', code: 30011, msg: 'Invalid ACCESS_KEY' }
                     },
                 },
             },
@@ -1088,13 +1090,14 @@ export default class bitget extends bitgetRest {
         const message = this.extend(request, params);
         return await this.watch(url, messageHash, message, messageHash);
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         this.checkRequiredCredentials();
         const url = this.urls['api']['ws'];
         const client = this.client(url);
         const messageHash = 'authenticated';
-        let future = this.safeValue(client.subscriptions, messageHash);
-        if (future === undefined) {
+        const future = client.future(messageHash);
+        const authenticated = this.safeValue(client.subscriptions, messageHash);
+        if (authenticated === undefined) {
             const timestamp = this.seconds().toString();
             const auth = timestamp + 'GET' + '/user/verify';
             const signature = this.hmac(this.encode(auth), this.encode(this.secret), sha256, 'base64');
@@ -1111,8 +1114,7 @@ export default class bitget extends bitgetRest {
                 ],
             };
             const message = this.extend(request, params);
-            future = this.watch(url, messageHash, message);
-            client.subscriptions[messageHash] = future;
+            this.watch(url, messageHash, message, messageHash);
         }
         return future;
     }
@@ -1131,7 +1133,8 @@ export default class bitget extends bitgetRest {
         //  { event: 'login', code: 0 }
         //
         const messageHash = 'authenticated';
-        client.resolve(message, messageHash);
+        const future = this.safeValue(client.futures, messageHash);
+        future.resolve(true);
     }
     handleErrorMessage(client, message) {
         //

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

@@ -19,7 +19,7 @@ export default class bitmart extends bitmartRest {
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBookMessage(client: Client, message: any, orderbook: any): any;
     handleOrderBook(client: Client, message: any): any;
-    authenticate(params?: {}): any;
+    authenticate(params?: {}): Promise<any>;
     handleSubscriptionStatus(client: Client, message: any): any;
     handleAuthenticate(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;

package/js/src/pro/bitmart.js

@@ -485,13 +485,14 @@ export default class bitmart extends bitmartRest {
         }
         return message;
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         this.checkRequiredCredentials();
         const url = this.implodeHostname(this.urls['api']['ws']['private']);
         const messageHash = 'authenticated';
         const client = this.client(url);
-        let future = this.safeValue(client.subscriptions, messageHash);
-        if (future === undefined) {
+        const future = client.future(messageHash);
+        const authenticated = this.safeValue(client.subscriptions, messageHash);
+        if (authenticated === undefined) {
             const timestamp = this.milliseconds().toString();
             const memo = this.uid;
             const path = 'bitmart.WebSocket';
@@ -507,8 +508,7 @@ export default class bitmart extends bitmartRest {
                 ],
             };
             const message = this.extend(request, params);
-            future = this.watch(url, messageHash, message);
-            client.subscriptions[messageHash] = future;
+            this.watch(url, messageHash, message, messageHash);
         }
         return future;
     }
@@ -523,7 +523,8 @@ export default class bitmart extends bitmartRest {
         //     { event: 'login' }
         //
         const messageHash = 'authenticated';
-        client.resolve(message, messageHash);
+        const future = this.safeValue(client.futures, messageHash);
+        future.resolve(true);
     }
     handleErrorMessage(client, message) {
         //

package/js/src/pro/bittrex.js

@@ -46,7 +46,7 @@ export default class bittrex extends bittrexRest {
                 'hub': 'c3',
                 'I': this.milliseconds(),
                 'watchOrderBook': {
-                    'snapshotMaxRetries': 3,
+                    'maxRetries': 3,
                 },
             },
         });
@@ -632,8 +632,7 @@ export default class bittrex extends bittrexRest {
             // then we cannot align it with the cached deltas and we need to
             // retry synchronizing in maxAttempts
             if ((sequence !== undefined) && (nonce < sequence)) {
-                const options = this.safeValue(this.options, 'fetchOrderBookSnapshot', {});
-                const maxAttempts = this.safeInteger(options, 'maxAttempts', 3);
+                const maxAttempts = this.handleOption('watchOrderBook', 'maxRetries', 3);
                 let numAttempts = this.safeInteger(subscription, 'numAttempts', 0);
                 // retry to syncrhonize if we haven't reached maxAttempts yet
                 if (numAttempts < maxAttempts) {

package/js/src/pro/bybit.js

@@ -286,7 +286,8 @@ export default class bybit extends bybitRest {
         const topic = this.safeString(message, 'topic', '');
         const updateType = this.safeString(message, 'type', '');
         const data = this.safeValue(message, 'data', {});
-        const isSpot = this.safeString(data, 's') !== undefined;
+        const isSpot = this.safeString(data, 'openInterestValue') === undefined;
+        const type = isSpot ? 'spot' : 'contract';
         let symbol = undefined;
         let parsed = undefined;
         if ((updateType === 'snapshot') || isSpot) {
@@ -297,7 +298,7 @@ export default class bybit extends bybitRest {
             const topicParts = topic.split('.');
             const topicLength = topicParts.length;
             const marketId = this.safeString(topicParts, topicLength - 1);
-            const market = this.market(marketId);
+            const market = this.safeMarket(marketId, undefined, undefined, type);
             symbol = market['symbol'];
             // update the info in place
             const ticker = this.safeValue(this.tickers, symbol, {});

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

@@ -9,8 +9,10 @@ export default class coinbasepro extends coinbaseproRest {
         signature: any;
         passphrase: string;
     };
-    subscribe(name: any, symbol: any, messageHashStart: any, params?: {}): Promise<any>;
+    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<any>;
+    watchTickers(symbols?: string[], params?: {}): Promise<any>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;

package/js/src/pro/coinbasepro.js

@@ -18,7 +18,7 @@ export default class coinbasepro extends coinbaseproRest {
                 'watchOHLCV': false,
                 'watchOrderBook': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchBalance': false,
                 'watchStatus': false,
@@ -53,10 +53,16 @@ export default class coinbasepro extends coinbaseproRest {
             'passphrase': this.password,
         };
     }
-    async subscribe(name, symbol, messageHashStart, params = {}) {
+    async subscribe(name, symbol = undefined, messageHashStart = undefined, params = {}) {
         await this.loadMarkets();
-        const market = this.market(symbol);
-        const messageHash = messageHashStart + ':' + market['id'];
+        let market = undefined;
+        let messageHash = messageHashStart;
+        const productIds = [];
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            messageHash += ':' + market['id'];
+            productIds.push(market['id']);
+        }
         let url = this.urls['api']['ws'];
         if ('signature' in params) {
             // need to distinguish between public trades and user trades
@@ -64,9 +70,33 @@ export default class coinbasepro extends coinbaseproRest {
         }
         const subscribe = {
             'type': 'subscribe',
-            'product_ids': [
-                market['id'],
+            'product_ids': productIds,
+            'channels': [
+                name,
             ],
+        };
+        const request = this.extend(subscribe, params);
+        return await this.watch(url, messageHash, request, messageHash);
+    }
+    async subscribeMultiple(name, symbols = [], messageHashStart = undefined, params = {}) {
+        await this.loadMarkets();
+        let market = undefined;
+        symbols = this.marketSymbols(symbols);
+        const messageHash = messageHashStart + symbols.join(',');
+        const productIds = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            market = this.market(symbol);
+            productIds.push(market['id']);
+        }
+        let url = this.urls['api']['ws'];
+        if ('signature' in params) {
+            // need to distinguish between public trades and user trades
+            url = url + '?';
+        }
+        const subscribe = {
+            'type': 'subscribe',
+            'product_ids': productIds,
             'channels': [
                 name,
             ],
@@ -86,6 +116,30 @@ export default class coinbasepro extends coinbaseproRest {
         const name = 'ticker';
         return await this.subscribe(name, symbol, name, params);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#watchTickers
+         * @see https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @param {string[]} [symbols] unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the okx api endpoint
+         * @param {string} [params.channel] the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        const symbolsLength = symbols.length;
+        if (symbolsLength === 0) {
+            throw new BadSymbol(this.id + ' watchTickers requires a non-empty symbols array');
+        }
+        const channel = 'ticker';
+        const messageHash = 'tickers::';
+        const newTickers = await this.subscribeMultiple(channel, symbols, messageHash, params);
+        if (this.newUpdates) {
+            return newTickers;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -117,9 +171,7 @@ export default class coinbasepro extends coinbaseproRest {
          * @param {object} [params] extra parameters specific to the coinbasepro api endpoint
          * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
          */
-        if (symbol === undefined) {
-            throw new BadSymbol(this.id + ' watchMyTrades requires a symbol');
-        }
+        this.checkRequiredSymbol('watchMyTrades', symbol);
         await this.loadMarkets();
         symbol = this.symbol(symbol);
         const name = 'user';
@@ -575,6 +627,16 @@ export default class coinbasepro extends coinbaseproRest {
             const type = this.safeString(message, 'type');
             const messageHash = type + ':' + marketId;
             client.resolve(ticker, messageHash);
+            const messageHashes = this.findMessageHashes(client, 'tickers::');
+            for (let i = 0; i < messageHashes.length; i++) {
+                const messageHash = messageHashes[i];
+                const parts = messageHash.split('::');
+                const symbolsString = parts[1];
+                const symbols = symbolsString.split(',');
+                if (this.inArray(symbol, symbols)) {
+                    client.resolve(ticker, messageHash);
+                }
+            }
         }
         return message;
     }

package/js/src/pro/huobi.js

@@ -87,7 +87,9 @@ export default class huobi extends huobiRest {
                 'tradesLimit': 1000,
                 'OHLCVLimit': 1000,
                 'api': 'api',
-                'maxOrderBookSyncAttempts': 3,
+                'watchOrderBook': {
+                    'maxRetries': 3,
+                },
                 'ws': {
                     'gunzip': true,
                 },
@@ -385,7 +387,7 @@ export default class huobi extends huobiRest {
             const snapshotOrderBook = this.orderBook(snapshot, snapshotLimit);
             client.resolve(snapshotOrderBook, id);
             if ((sequence !== undefined) && (nonce < sequence)) {
-                const maxAttempts = this.safeInteger(this.options, 'maxOrderBookSyncAttempts', 3);
+                const maxAttempts = this.handleOption('watchOrderBook', 'maxRetries', 3);
                 let numAttempts = this.safeInteger(subscription, 'numAttempts', 0);
                 // retry to synchronize if we have not reached maxAttempts yet
                 if (numAttempts < maxAttempts) {

package/js/src/pro/idex.js

@@ -37,7 +37,7 @@ export default class idex extends idexRest {
                 'orderBookSubscriptions': {},
                 'token': undefined,
                 'watchOrderBook': {
-                    'snapshotMaxRetries': 3,
+                    'maxRetries': 3,
                 },
                 'fetchOrderBookSnapshotMaxAttempts': 10,
                 'fetchOrderBookSnapshotMaxDelay': 10000, // throw if there are no orders in 10 seconds

package/js/src/wavesexchange.d.ts

@@ -1,4 +1,5 @@
 import Exchange from './abstract/wavesexchange.js';
+import { Precise } from './base/Precise.js';
 import { Int, OrderSide, OrderType } from './base/types.js';
 /**
  * @class wavesexchange
@@ -47,7 +48,7 @@ export default class wavesexchange extends Exchange {
     customAmountToPrecision(symbol: any, amount: any): number;
     currencyToPrecision(code: any, amount: any, networkCode?: any): number;
     fromPrecision(amount: any, scale: any): string;
-    toPrecision(amount: any, scale: any): string;
+    toPrecision(amount: any, scale: any): Precise;
     currencyFromPrecision(currency: any, amount: any): string;
     priceFromPrecision(symbol: any, price: any): string;
     safeGetDynamic(settings: any): any;

package/js/src/wavesexchange.js

@@ -617,19 +617,32 @@ export default class wavesexchange extends Exchange {
     }
     parseOrderBookSide(bookSide, market = undefined, limit = undefined) {
         const precision = market['precision'];
-        const wavesPrecision = this.safeInteger(this.options, 'wavesPrecision', 8);
-        const amountPrecision = Math.pow(10, precision['amount']);
-        const difference = precision['amount'] - precision['price'];
-        const pricePrecision = Math.pow(10, wavesPrecision - difference);
+        const wavesPrecision = this.safeString(this.options, 'wavesPrecision', '8');
+        const amountPrecision = '1e' + this.numberToString(precision['amount']);
+        const amountPrecisionString = this.numberToString(precision['amount']);
+        const pricePrecisionString = this.numberToString(precision['price']);
+        const difference = Precise.stringSub(amountPrecisionString, pricePrecisionString);
+        const pricePrecision = '1e' + Precise.stringSub(wavesPrecision, difference);
         const result = [];
         for (let i = 0; i < bookSide.length; i++) {
             const entry = bookSide[i];
-            const price = this.safeInteger(entry, 'price', 0) / pricePrecision;
-            const amount = this.safeInteger(entry, 'amount', 0) / amountPrecision;
+            const entryPrice = this.safeString(entry, 'price', '0');
+            const entryAmount = this.safeString(entry, 'amount', '0');
+            let price = undefined;
+            let amount = undefined;
+            if ((pricePrecision !== undefined) && (entryPrice !== undefined)) {
+                price = Precise.stringDiv(entryPrice, pricePrecision);
+            }
+            if ((amountPrecision !== undefined) && (entryAmount !== undefined)) {
+                amount = Precise.stringDiv(entryAmount, amountPrecision);
+            }
             if ((limit !== undefined) && (i > limit)) {
                 break;
             }
-            result.push([price, amount]);
+            result.push([
+                this.parseNumber(price),
+                this.parseNumber(amount),
+            ]);
         }
         return result;
     }
@@ -1209,15 +1222,21 @@ export default class wavesexchange extends Exchange {
     }
     customPriceToPrecision(symbol, price) {
         const market = this.markets[symbol];
-        const wavesPrecision = this.safeInteger(this.options, 'wavesPrecision', 8);
-        const difference = market['precision']['amount'] - market['precision']['price'];
-        return this.parseToInt(parseFloat(this.toPrecision(price, wavesPrecision - difference)));
+        const wavesPrecision = this.safeString(this.options, 'wavesPrecision', '8');
+        const amount = this.numberToString(market['precision']['amount']);
+        const precisionPrice = this.numberToString(market['precision']['price']);
+        const difference = Precise.stringSub(amount, precisionPrice);
+        const precision = Precise.stringSub(wavesPrecision, difference);
+        const pricePrecision = this.toPrecision(price, precision).toString();
+        return this.parseToInt(parseFloat(pricePrecision));
     }
     customAmountToPrecision(symbol, amount) {
-        return this.parseToInt(parseFloat(this.toPrecision(amount, this.markets[symbol]['precision']['amount'])));
+        const amountPrecision = this.numberToString(this.toPrecision(amount, this.numberToString(this.markets[symbol]['precision']['amount'])));
+        return this.parseToInt(parseFloat(amountPrecision));
     }
     currencyToPrecision(code, amount, networkCode = undefined) {
-        return this.parseToInt(parseFloat(this.toPrecision(amount, this.currencies[code]['precision'])));
+        const amountPrecision = this.numberToString(this.toPrecision(amount, this.currencies[code]['precision']));
+        return this.parseToInt(parseFloat(amountPrecision));
     }
     fromPrecision(amount, scale) {
         if (amount === undefined) {
@@ -1229,11 +1248,11 @@ export default class wavesexchange extends Exchange {
         return precise.toString();
     }
     toPrecision(amount, scale) {
-        const amountString = amount.toString();
+        const amountString = this.numberToString(amount);
         const precise = new Precise(amountString);
-        precise.decimals = precise.decimals - scale;
+        precise.decimals = Precise.stringSub(precise.decimals, scale);
         precise.reduce();
-        return precise.toString();
+        return precise;
     }
     currencyFromPrecision(currency, amount) {
         const scale = this.currencies[currency]['precision'];

package/package.json

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