ccxt 4.5.40 → 4.5.42

package/dist/cjs/src/mexc.js

@@ -4714,7 +4714,6 @@ class mexc extends mexc$1["default"] {
         const address = this.safeString(depositAddress, 'address');
         const currencyId = this.safeString(depositAddress, 'coin');
         const networkId = this.safeString(depositAddress, 'netWork');
-        this.checkAddress(address);
         return {
             'info': depositAddress,
             'currency': this.safeCurrencyCode(currencyId, currency),

package/dist/cjs/src/phemex.js

@@ -89,8 +89,8 @@ class phemex extends phemex$1["default"] {
                 'fetchOrderBook': true,
                 'fetchOrders': true,
                 'fetchPositionADLRank': true,
-                'fetchPositionsADLRank': true,
                 'fetchPositions': true,
+                'fetchPositionsADLRank': true,
                 'fetchPositionsRisk': false,
                 'fetchPremiumIndexOHLCV': false,
                 'fetchTicker': true,

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

@@ -156,7 +156,7 @@ class binance extends binance$1["default"] {
                     'name': 'ticker', // ticker or miniTicker or ticker_<window_size>
                 },
                 'watchTickers': {
-                    'name': 'ticker', // ticker or miniTicker or ticker_<window_size>
+                    'name': 'miniTicker', // miniTicker or ticker_<window_size>
                 },
                 'watchOHLCV': {
                     'name': 'kline', // or indexPriceKline or markPriceKline (coin-m futures)
@@ -1867,7 +1867,7 @@ class binance extends binance$1["default"] {
      */
     async watchTickers(symbols = undefined, params = {}) {
         let channelName = undefined;
-        [channelName, params] = this.handleOptionAndParams(params, 'watchTickers', 'name', 'ticker');
+        [channelName, params] = this.handleOptionAndParams(params, 'watchTickers', 'name', 'miniTicker');
         if (channelName === 'bookTicker') {
             throw new errors.BadRequest(this.id + ' deprecation notice - to subscribe for bids-asks, use watch_bids_asks() method instead');
         }

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var bingx$1 = require('../bingx.js');
 var errors = require('../base/errors.js');
+var Precise = require('../base/Precise.js');
 var Cache = require('../base/ws/Cache.js');
 
 // ----------------------------------------------------------------------------
@@ -24,12 +25,18 @@ class bingx extends bingx$1["default"] {
                 'watchTicker': true,
                 'watchTickers': false,
                 'watchBalance': true,
+                'watchPositions': true,
                 'unWatchOHLCV': true,
                 'unWatchOrderBook': true,
                 'unWatchTicker': true,
                 'unWatchTrades': true,
             },
             'urls': {
+                'test': {
+                    'ws': {
+                        'linear': 'wss://vst-open-api-ws.bingx.com/swap-market',
+                    },
+                },
                 'api': {
                     'ws': {
                         'spot': 'wss://open-api-ws.bingx.com/market',
@@ -73,7 +80,11 @@ class bingx extends bingx$1["default"] {
                 },
                 'watchBalance': {
                     'fetchBalanceSnapshot': true,
-                    'awaitBalanceSnapshot': false, // whether to wait for the balance snapshot before providing updates
+                    'awaitBalanceSnapshot': true, // whether to wait for the balance snapshot before providing updates
+                },
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': false,
                 },
                 'watchOrderBook': {
                     'depth': 100, // 5, 10, 20, 50, 100
@@ -1140,6 +1151,203 @@ class bingx extends bingx$1["default"] {
             client.resolve(this.balance[type], type + ':balance');
         }
     }
+    /**
+     * @method
+     * @name bingx#watchPositions
+     * @description watch all open positions
+     * @see https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
+     * @param {string[]|undefined} [symbols] list of unified market symbols
+     * @param {int} [since] the earliest time in ms to fetch positions for
+     * @param {int} [limit] the maximum number of position structures to retrieve
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+     */
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        await this.loadMarkets();
+        await this.authenticate();
+        let market = undefined;
+        let messageHash = '';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            market = this.getMarketFromSymbols(symbols);
+            messageHash = '::' + symbols.join(',');
+        }
+        let type = undefined;
+        let subType = undefined;
+        [type, params] = this.handleMarketTypeAndParams('watchPositions', market, params);
+        [subType, params] = this.handleSubTypeAndParams('watchPositions', market, params, 'linear');
+        if (type === 'spot') {
+            throw new errors.NotSupported(this.id + ' watchPositions is not supported for spot markets');
+        }
+        if (subType === 'inverse') {
+            throw new errors.NotSupported(this.id + ' watchPositions is not supported for inverse swap markets yet');
+        }
+        const subscriptionHash = 'swap:private';
+        messageHash = 'swap:positions' + messageHash;
+        const baseUrl = this.safeString(this.urls['api']['ws'], subType);
+        const url = baseUrl + '?listenKey=' + this.options['listenKey'];
+        const client = this.client(url);
+        this.setPositionsCache(client, type, symbols);
+        let fetchPositionsSnapshot = undefined;
+        let awaitPositionsSnapshot = undefined;
+        [fetchPositionsSnapshot, params] = this.handleOptionAndParams(params, 'watchPositions', 'fetchPositionsSnapshot', true);
+        [awaitPositionsSnapshot, params] = this.handleOptionAndParams(params, 'watchPositions', 'awaitPositionsSnapshot', false);
+        const uuid = this.uuid();
+        const subscription = {
+            'unsubscribe': false,
+            'id': uuid,
+        };
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && this.positions === undefined) {
+            const snapshot = await client.future(type + ':fetchPositionsSnapshot');
+            return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);
+        }
+        const newPositions = await this.watch(url, messageHash, undefined, subscriptionHash, subscription);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    setPositionsCache(client, type, symbols = undefined) {
+        if (this.positions !== undefined) {
+            return;
+        }
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        if (fetchPositionsSnapshot) {
+            const messageHash = type + ':fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash, type);
+            }
+        }
+        else {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash, type) {
+        const positions = await this.fetchPositions(undefined, { 'type': type, 'subType': 'linear' });
+        this.positions = new Cache.ArrayCacheBySymbolBySide();
+        const cache = this.positions;
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            const contracts = this.safeNumber(position, 'contracts', 0);
+            if (contracts > 0) {
+                cache.append(position);
+            }
+        }
+        // don't remove the future from the .futures cache
+        if (messageHash in client.futures) {
+            const future = client.futures[messageHash];
+            future.resolve(cache);
+            client.resolve(cache, 'swap:positions');
+        }
+    }
+    parseWsPosition(position, market = undefined) {
+        //
+        //     {
+        //         "s": "LINK-USDT",     // Symbol
+        //         "pa": "5.000",        // Position Amount
+        //         "ep": "11.2345",      // Entry Price
+        //         "up": "0.5000",       // Unrealized PnL
+        //         "mt": "isolated",     // Margin Type
+        //         "iw": "50.00000000",  // Isolated Wallet
+        //         "ps": "LONG"          // Position Side
+        //     }
+        //
+        const marketId = this.safeString(position, 's');
+        const contracts = this.safeString(position, 'pa');
+        const contractsAbs = Precise["default"].stringAbs(contracts);
+        let positionSide = this.safeStringLower(position, 'ps');
+        let hedged = true;
+        if (positionSide === 'both') {
+            hedged = false;
+            if (!Precise["default"].stringEq(contracts, '0')) {
+                if (Precise["default"].stringLt(contracts, '0')) {
+                    positionSide = 'short';
+                }
+                else {
+                    positionSide = 'long';
+                }
+            }
+        }
+        const marginMode = this.safeString(position, 'mt');
+        const collateral = (marginMode === 'isolated') ? this.safeNumber(position, 'iw') : undefined;
+        return this.safePosition({
+            'info': position,
+            'id': undefined,
+            'symbol': this.safeSymbol(marketId, undefined, undefined, 'swap'),
+            'notional': undefined,
+            'marginMode': marginMode,
+            'liquidationPrice': undefined,
+            'entryPrice': this.safeNumber(position, 'ep'),
+            'unrealizedPnl': this.safeNumber(position, 'up'),
+            'percentage': undefined,
+            'contracts': this.parseNumber(contractsAbs),
+            'contractSize': undefined,
+            'markPrice': undefined,
+            'side': positionSide,
+            'hedged': hedged,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'maintenanceMargin': undefined,
+            'maintenanceMarginPercentage': undefined,
+            'collateral': collateral,
+            'initialMargin': undefined,
+            'initialMarginPercentage': undefined,
+            'leverage': undefined,
+            'marginRatio': undefined,
+        });
+    }
+    handlePositions(client, message) {
+        //
+        //     {
+        //         "e": "ACCOUNT_UPDATE",
+        //         "E": 1696244249320,
+        //         "a": {
+        //             "m": "ORDER",
+        //             "B": [...],
+        //             "P": [
+        //                 {
+        //                     "s": "LINK-USDT",
+        //                     "pa": "5.000",
+        //                     "ep": "11.2345",
+        //                     "up": "0.5000",
+        //                     "mt": "isolated",
+        //                     "iw": "50.00000000",
+        //                     "ps": "LONG"
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        if (this.positions === undefined) {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        const data = this.safeDict(message, 'a', {});
+        const rawPositions = this.safeList(data, 'P', []);
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parseWsPosition(rawPosition);
+            const timestamp = this.safeInteger(message, 'E');
+            position['timestamp'] = timestamp;
+            position['datetime'] = this.iso8601(timestamp);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, 'swap:positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const filteredSymbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', filteredSymbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, 'swap:positions');
+    }
     handleErrorMessage(client, message) {
         //
         // { code: 100400, msg: '', timestamp: 1696245808833 }
@@ -1175,7 +1383,11 @@ class bingx extends bingx$1["default"] {
             const types = ['spot', 'linear', 'inverse'];
             for (let i = 0; i < types.length; i++) {
                 const type = types[i];
-                const url = this.urls['api']['ws'][type] + '?listenKey=' + listenKey;
+                const baseUrl = this.safeString(this.urls['api']['ws'], type);
+                if (baseUrl === undefined) {
+                    continue;
+                }
+                const url = baseUrl + '?listenKey=' + listenKey;
                 const client = this.client(url);
                 const messageHashes = Object.keys(client.futures);
                 for (let j = 0; j < messageHashes.length; j++) {
@@ -1505,6 +1717,7 @@ class bingx extends bingx$1["default"] {
         const e = this.safeString(message, 'e');
         if (e === 'ACCOUNT_UPDATE') {
             this.handleBalance(client, message);
+            this.handlePositions(client, message);
         }
         if (e === 'ORDER_TRADE_UPDATE') {
             this.handleOrder(client, message);

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

@@ -2010,6 +2010,7 @@ class bitget extends bitget$1["default"] {
     }
     parseWsOrderStatus(status) {
         const statuses = {
+            'new': 'open',
             'live': 'open',
             'partially_filled': 'open',
             'filled': 'closed',

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

@@ -673,7 +673,7 @@ class defx extends defx$1["default"] {
         //
         // {
         //     "event": "WALLET_BALANCE_UPDATE",
-        //     "timestamp": 1711015961397,
+        //     "timestamp": 1711015961396,
         //     "data": {
         //         "asset": "USDC", "balance": "27.64712963"
         //     }

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

@@ -718,9 +718,9 @@ class kucoinfutures extends kucoinfutures$1["default"] {
         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, 2),
             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, {});