ccxt 4.4.28 → 4.4.30

package/js/src/coincatch.d.ts

@@ -60,7 +60,7 @@ export default class coincatch extends Exchange {
     parseDepositAddress(depositAddress: any, currency?: Currency): DepositAddress;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<any>;
+    withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     parseTransaction(transaction: any, currency?: Currency): Transaction;
     createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;

package/js/src/coincatch.js

@@ -2076,13 +2076,23 @@ export default class coincatch extends Exchange {
             request['chain'] = this.networkCodeToId(networkCode);
         }
         const response = await this.privatePostApiSpotV1WalletWithdrawalV2(this.extend(request, params));
-        // todo add after withdrawal
         //
-        return response;
+        //     {
+        //         "code": "00000",
+        //         "msg": "success",
+        //         "data": {
+        //             "orderId":888291686266343424",
+        //             "clientOrderId":"123"
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseTransaction(data, currency);
     }
     parseTransaction(transaction, currency = undefined) {
         //
         // fetchDeposits
+        //
         //     {
         //         "id": "1213046466852196352",
         //         "txId": "824246b030cd84d56400661303547f43a1d9fef66cf968628dd5112f362053ff",
@@ -2102,7 +2112,17 @@ export default class coincatch extends Exchange {
         //         "uTime": "1724938746015"
         //     }
         //
-        const id = this.safeString(transaction, 'id');
+        // withdraw
+        //
+        //     {
+        //         "code": "00000",
+        //         "msg": "success",
+        //         "data": {
+        //             "orderId":888291686266343424",
+        //             "clientOrderId":"123"
+        //         }
+        //     }
+        //
         let status = this.safeString(transaction, 'status');
         if (status === 'success') {
             status = 'ok';
@@ -2128,7 +2148,7 @@ export default class coincatch extends Exchange {
         }
         return {
             'info': transaction,
-            'id': id,
+            'id': this.safeString2(transaction, 'id', 'orderId'),
             'txid': txid,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),

package/js/src/deribit.js

@@ -857,6 +857,8 @@ export default class deribit extends Exchange {
                 else if (isSpot) {
                     type = 'spot';
                 }
+                let inverse = undefined;
+                let linear = undefined;
                 if (isSpot) {
                     symbol = base + '/' + quote;
                 }
@@ -871,6 +873,8 @@ export default class deribit extends Exchange {
                             symbol = symbol + '-' + this.numberToString(strike) + '-' + letter;
                         }
                     }
+                    inverse = (quote !== settle);
+                    linear = (settle === quote);
                 }
                 const parsedMarketValue = this.safeValue(parsedMarkets, symbol);
                 if (parsedMarketValue) {
@@ -896,8 +900,8 @@ export default class deribit extends Exchange {
                     'option': option,
                     'active': this.safeValue(market, 'is_active'),
                     'contract': !isSpot,
-                    'linear': (settle === quote),
-                    'inverse': (settle !== quote),
+                    'linear': linear,
+                    'inverse': inverse,
                     'taker': this.safeNumber(market, 'taker_commission'),
                     'maker': this.safeNumber(market, 'maker_commission'),
                     'contractSize': this.safeNumber(market, 'contract_size'),
@@ -1763,7 +1767,7 @@ export default class deribit extends Exchange {
         const filledString = this.safeString(order, 'filled_amount');
         const amount = this.safeString(order, 'amount');
         let cost = Precise.stringMul(filledString, averageString);
-        if (market['inverse']) {
+        if (this.safeBool(market, 'inverse')) {
             if (averageString !== '0') {
                 cost = Precise.stringDiv(amount, averageString);
             }

package/js/src/hyperliquid.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/hyperliquid.js';
-import type { Market, TransferEntry, Balances, Int, OrderBook, OHLCV, Str, FundingRateHistory, Order, OrderType, OrderSide, Trade, Strings, Position, OrderRequest, Dict, Num, MarginModification, Currencies, CancellationRequest, int, Transaction, Currency, TradingFeeInterface, Ticker, Tickers, LedgerEntry } from './base/types.js';
+import type { Market, TransferEntry, Balances, Int, OrderBook, OHLCV, Str, FundingRateHistory, Order, OrderType, OrderSide, Trade, Strings, Position, OrderRequest, Dict, Num, MarginModification, Currencies, CancellationRequest, int, Transaction, Currency, TradingFeeInterface, Ticker, Tickers, LedgerEntry, FundingRates, FundingRate } from './base/types.js';
 /**
  * @class hyperliquid
  * @augments Exchange
@@ -15,6 +15,8 @@ export default class hyperliquid extends Exchange {
     fetchBalance(params?: {}): Promise<Balances>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    fetchFundingRates(symbols?: Strings, params?: {}): Promise<FundingRates>;
+    parseFundingRate(info: any, market?: Market): FundingRate;
     parseTicker(ticker: Dict, market?: Market): Ticker;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;

package/js/src/hyperliquid.js

@@ -71,7 +71,7 @@ export default class hyperliquid extends Exchange {
                 'fetchFundingHistory': false,
                 'fetchFundingRate': false,
                 'fetchFundingRateHistory': true,
-                'fetchFundingRates': false,
+                'fetchFundingRates': true,
                 'fetchIndexOHLCV': false,
                 'fetchIsolatedBorrowRate': false,
                 'fetchIsolatedBorrowRates': false,
@@ -127,12 +127,12 @@ export default class hyperliquid extends Exchange {
                 '1h': '1h',
                 '2h': '2h',
                 '4h': '4h',
-                '6h': '6h',
+                '8h': '8h',
                 '12h': '12h',
                 '1d': '1d',
                 '3d': '3d',
                 '1w': '1w',
-                '1M': '1m',
+                '1M': '1M',
             },
             'hostname': 'hyperliquid.xyz',
             'urls': {
@@ -749,6 +749,110 @@ export default class hyperliquid extends Exchange {
         }
         return this.filterByArrayTickers(result, 'symbol', symbols);
     }
+    async fetchFundingRates(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#fetchFundingRates
+         * @description retrieves data on all swap markets for hyperliquid
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-perpetuals-asset-contexts-includes-mark-price-current-funding-open-interest-etc
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} an array of objects representing market data
+         */
+        const request = {
+            'type': 'metaAndAssetCtxs',
+        };
+        const response = await this.publicPostInfo(this.extend(request, params));
+        //
+        //     [
+        //         {
+        //             "universe": [
+        //                 {
+        //                     "maxLeverage": 50,
+        //                     "name": "SOL",
+        //                     "onlyIsolated": false,
+        //                     "szDecimals": 2
+        //                 }
+        //             ]
+        //         },
+        //         [
+        //             {
+        //                 "dayNtlVlm": "9450588.2273",
+        //                 "funding": "0.0000198",
+        //                 "impactPxs": [
+        //                     "108.04",
+        //                     "108.06"
+        //                 ],
+        //                 "markPx": "108.04",
+        //                 "midPx": "108.05",
+        //                 "openInterest": "10764.48",
+        //                 "oraclePx": "107.99",
+        //                 "premium": "0.00055561",
+        //                 "prevDayPx": "111.81"
+        //             }
+        //         ]
+        //     ]
+        //
+        //
+        const meta = this.safeDict(response, 0, {});
+        const universe = this.safeList(meta, 'universe', []);
+        const assetCtxs = this.safeList(response, 1, []);
+        const result = [];
+        for (let i = 0; i < universe.length; i++) {
+            const data = this.extend(this.safeDict(universe, i, {}), this.safeDict(assetCtxs, i, {}));
+            result.push(data);
+        }
+        const funding_rates = this.parseFundingRates(result);
+        return this.filterByArray(funding_rates, 'symbol', symbols);
+    }
+    parseFundingRate(info, market = undefined) {
+        //
+        //     {
+        //         "maxLeverage": "50",
+        //         "name": "ETH",
+        //         "onlyIsolated": false,
+        //         "szDecimals": "4",
+        //         "dayNtlVlm": "1709813.11535",
+        //         "funding": "0.00004807",
+        //         "impactPxs": [
+        //             "2369.3",
+        //             "2369.6"
+        //         ],
+        //         "markPx": "2369.6",
+        //         "midPx": "2369.45",
+        //         "openInterest": "1815.4712",
+        //         "oraclePx": "2367.3",
+        //         "premium": "0.00090821",
+        //         "prevDayPx": "2381.5"
+        //     }
+        //
+        const base = this.safeString(info, 'name');
+        const marketId = this.coinToMarketId(base);
+        const symbol = this.safeSymbol(marketId, market);
+        const funding = this.safeNumber(info, 'funding');
+        const markPx = this.safeNumber(info, 'markPx');
+        const oraclePx = this.safeNumber(info, 'oraclePx');
+        const fundingTimestamp = (Math.floor(this.milliseconds() / 60 / 60 / 1000) + 1) * 60 * 60 * 1000;
+        return {
+            'info': info,
+            'symbol': symbol,
+            'markPrice': markPx,
+            'indexPrice': oraclePx,
+            'interestRate': undefined,
+            'estimatedSettlePrice': undefined,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'fundingRate': funding,
+            'fundingTimestamp': fundingTimestamp,
+            'fundingDatetime': this.iso8601(fundingTimestamp),
+            'nextFundingRate': undefined,
+            'nextFundingTimestamp': undefined,
+            'nextFundingDatetime': undefined,
+            'previousFundingRate': undefined,
+            'previousFundingTimestamp': undefined,
+            'previousFundingDatetime': undefined,
+            'interval': '1h',
+        };
+    }
     parseTicker(ticker, market = undefined) {
         //
         //     {
@@ -813,7 +917,7 @@ export default class hyperliquid extends Exchange {
             'type': 'candleSnapshot',
             'req': {
                 'coin': market['swap'] ? market['base'] : market['id'],
-                'interval': timeframe,
+                'interval': this.safeString(this.timeframes, timeframe, timeframe),
                 'startTime': since,
                 'endTime': until,
             },

package/js/src/lbank.js

@@ -1196,6 +1196,12 @@ export default class lbank extends Exchange {
         const indexPrice = this.safeNumber(ticker, 'underlyingPrice');
         const fundingRate = this.safeNumber(ticker, 'fundingRate');
         const fundingTime = this.safeInteger(ticker, 'nextFeeTime');
+        const positionFeeTime = this.safeInteger(ticker, 'positionFeeTime');
+        let intervalString = undefined;
+        if (positionFeeTime !== undefined) {
+            const interval = this.parseToInt(positionFeeTime / 60 / 60);
+            intervalString = interval.toString() + 'h';
+        }
         return {
             'info': ticker,
             'symbol': symbol,
@@ -1212,7 +1218,7 @@ export default class lbank extends Exchange {
             'previousFundingRate': undefined,
             'previousFundingTimestamp': undefined,
             'previousFundingDatetime': undefined,
-            'interval': undefined,
+            'interval': intervalString,
         };
     }
     async fetchFundingRate(symbol, params = {}) {

package/js/src/pro/bitvavo.js

@@ -776,7 +776,8 @@ export default class bitvavo extends bitvavoRest {
         const messageHash = this.buildMessageHash(action, request);
         this.checkMessageHashDoesNotExist(messageHash);
         const url = this.urls['api']['ws'];
-        return await this.watch(url, messageHash, request, messageHash);
+        const randomSubHash = this.randNumber(5).toString() + ':' + messageHash;
+        return await this.watch(url, messageHash, request, randomSubHash);
     }
     async fetchOpenOrdersWs(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**

package/js/src/pro/blofin.js

@@ -688,7 +688,8 @@ export default class blofin extends blofinRest {
                 return;
             }
             else if (event === 'login') {
-                client.resolve(message, 'authenticate_hash');
+                const future = this.safeValue(client.futures, 'authenticate_hash');
+                future.resolve(true);
                 return;
             }
             else if (event === 'error') {

package/js/src/pro/mexc.js

@@ -78,15 +78,25 @@ export default class mexc extends mexcRest {
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
          * @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
          * @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+         * @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#miniticker
          * @param {string} symbol unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.miniTicker] set to true for using the miniTicker endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
         const messageHash = 'ticker:' + market['symbol'];
         if (market['spot']) {
-            const channel = 'spot@public.bookTicker.v3.api@' + market['id'];
+            let miniTicker = false;
+            [miniTicker, params] = this.handleOptionAndParams(params, 'watchTicker', 'miniTicker');
+            let channel = undefined;
+            if (miniTicker) {
+                channel = 'spot@public.miniTicker.v3.api@' + market['id'] + '@UTC+8';
+            }
+            else {
+                channel = 'spot@public.bookTicker.v3.api@' + market['id'];
+            }
             return await this.watchSpotPublic(channel, messageHash, params);
         }
         else {
@@ -98,6 +108,38 @@ export default class mexc extends mexcRest {
         }
     }
     handleTicker(client, message) {
+        //
+        // swap
+        //
+        //     {
+        //         "symbol": "BTC_USDT",
+        //         "data": {
+        //             "symbol": "BTC_USDT",
+        //             "lastPrice": 76376.2,
+        //             "riseFallRate": -0.0006,
+        //             "fairPrice": 76374.4,
+        //             "indexPrice": 76385.8,
+        //             "volume24": 962062810,
+        //             "amount24": 7344207079.96768,
+        //             "maxBidPrice": 84024.3,
+        //             "minAskPrice": 68747.2,
+        //             "lower24Price": 75620.2,
+        //             "high24Price": 77210,
+        //             "timestamp": 1731137509138,
+        //             "bid1": 76376.2,
+        //             "ask1": 76376.3,
+        //             "holdVol": 95479623,
+        //             "riseFallValue": -46.5,
+        //             "fundingRate": 0.0001,
+        //             "zone": "UTC+8",
+        //             "riseFallRates": [ -0.0006, 0.1008, 0.2262, 0.2628, 0.2439, 1.0564 ],
+        //             "riseFallRatesOfTimezone": [ 0.0065, -0.0013, -0.0006 ]
+        //         },
+        //         "channel": "push.ticker",
+        //         "ts": 1731137509138
+        //     }
+        //
+        // spot
         //
         //    {
         //        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
@@ -111,8 +153,30 @@ export default class mexc extends mexcRest {
         //        "t": 1678643605721
         //    }
         //
+        // spot miniTicker
+        //
+        //     {
+        //         "d": {
+        //             "s": "BTCUSDT",
+        //             "p": "76522",
+        //             "r": "0.0012",
+        //             "tr": "0.0012",
+        //             "h": "77196.3",
+        //             "l": "75630.77",
+        //             "v": "584664223.92",
+        //             "q": "7666.720258",
+        //             "lastRT": "-1",
+        //             "MT": "0",
+        //             "NV": "--",
+        //             "t": "1731135533126"
+        //         },
+        //         "c": "spot@public.miniTicker.v3.api@BTCUSDT@UTC+8",
+        //         "t": 1731135533126,
+        //         "s": "BTCUSDT"
+        //     }
+        //
         this.handleBidAsk(client, message);
-        const rawTicker = this.safeValue2(message, 'd', 'data');
+        const rawTicker = this.safeDict2(message, 'd', 'data');
         const marketId = this.safeString2(message, 's', 'symbol');
         const timestamp = this.safeInteger(message, 't');
         const market = this.safeMarket(marketId);
@@ -137,24 +201,51 @@ export default class mexc extends mexcRest {
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
          * @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
          * @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+         * @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#minitickers
          * @param {string[]} symbols unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.miniTicker] set to true for using the miniTicker endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
-        symbols = this.marketSymbols(symbols, undefined, false);
+        symbols = this.marketSymbols(symbols, undefined);
         const messageHashes = [];
-        const marketIds = this.marketIds(symbols);
-        const firstMarket = this.market(symbols[0]);
-        const isSpot = firstMarket['spot'];
+        const firstSymbol = this.safeString(symbols, 0);
+        let market = undefined;
+        if (firstSymbol !== undefined) {
+            market = this.market(firstSymbol);
+        }
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
+        const isSpot = (type === 'spot');
         const url = (isSpot) ? this.urls['api']['ws']['spot'] : this.urls['api']['ws']['swap'];
         const request = {};
         if (isSpot) {
+            let miniTicker = false;
+            [miniTicker, params] = this.handleOptionAndParams(params, 'watchTickers', 'miniTicker');
             const topics = [];
-            for (let i = 0; i < marketIds.length; i++) {
-                const marketId = marketIds[i];
-                messageHashes.push('ticker:' + symbols[i]);
-                topics.push('spot@public.bookTicker.v3.api@' + marketId);
+            if (!miniTicker) {
+                if (symbols === undefined) {
+                    throw new ArgumentsRequired(this.id + 'watchTickers required symbols argument for the bookTicker channel');
+                }
+                const marketIds = this.marketIds(symbols);
+                for (let i = 0; i < marketIds.length; i++) {
+                    const marketId = marketIds[i];
+                    messageHashes.push('ticker:' + symbols[i]);
+                    const channel = 'spot@public.bookTicker.v3.api@' + marketId;
+                    topics.push(channel);
+                }
+            }
+            else {
+                topics.push('spot@public.miniTickers.v3.api@UTC+8');
+                if (symbols === undefined) {
+                    messageHashes.push('spot:ticker');
+                }
+                else {
+                    for (let i = 0; i < symbols.length; i++) {
+                        messageHashes.push('ticker:' + symbols[i]);
+                    }
+                }
             }
             request['method'] = 'SUBSCRIPTION';
             request['params'] = topics;
@@ -173,6 +264,8 @@ export default class mexc extends mexcRest {
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
     handleTickers(client, message) {
+        //
+        // swap
         //
         //     {
         //       "channel": "push.tickers",
@@ -195,15 +288,66 @@ export default class mexc extends mexcRest {
         //       "ts": 1725872514111
         //     }
         //
-        const data = this.safeList(message, 'data');
-        const topic = 'ticker';
+        // spot
+        //
+        //    {
+        //        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
+        //        "d": {
+        //            "A": "4.70432",
+        //            "B": "6.714863",
+        //            "a": "20744.54",
+        //            "b": "20744.17"
+        //        },
+        //        "s": "BTCUSDT",
+        //        "t": 1678643605721
+        //    }
+        //
+        // spot miniTicker
+        //
+        //     {
+        //         "d": {
+        //             "s": "BTCUSDT",
+        //             "p": "76522",
+        //             "r": "0.0012",
+        //             "tr": "0.0012",
+        //             "h": "77196.3",
+        //             "l": "75630.77",
+        //             "v": "584664223.92",
+        //             "q": "7666.720258",
+        //             "lastRT": "-1",
+        //             "MT": "0",
+        //             "NV": "--",
+        //             "t": "1731135533126"
+        //         },
+        //         "c": "spot@public.miniTicker.v3.api@BTCUSDT@UTC+8",
+        //         "t": 1731135533126,
+        //         "s": "BTCUSDT"
+        //     }
+        //
+        const data = this.safeList2(message, 'data', 'd');
+        const channel = this.safeString(message, 'c', '');
+        const marketId = this.safeString(message, 's');
+        const market = this.safeMarket(marketId);
+        const channelStartsWithSpot = channel.startsWith('spot');
+        const marketIdIsUndefined = marketId === undefined;
+        const isSpot = marketIdIsUndefined ? channelStartsWithSpot : market['spot'];
+        const spotPrefix = 'spot:';
+        const messageHashPrefix = isSpot ? spotPrefix : '';
+        const topic = messageHashPrefix + 'ticker';
         const result = [];
         for (let i = 0; i < data.length; i++) {
-            const ticker = this.parseTicker(data[i]);
+            const entry = data[i];
+            let ticker = undefined;
+            if (isSpot) {
+                ticker = this.parseWsTicker(entry, market);
+            }
+            else {
+                ticker = this.parseTicker(entry);
+            }
             const symbol = ticker['symbol'];
             this.tickers[symbol] = ticker;
             result.push(ticker);
-            const messageHash = topic + ':' + symbol;
+            const messageHash = 'ticker:' + symbol;
             client.resolve(ticker, messageHash);
         }
         client.resolve(result, topic);
@@ -211,21 +355,44 @@ export default class mexc extends mexcRest {
     parseWsTicker(ticker, market = undefined) {
         //
         // spot
-        //    {
-        //        "A": "4.70432",
-        //        "B": "6.714863",
-        //        "a": "20744.54",
-        //        "b": "20744.17"
-        //    }
         //
+        //     {
+        //         "A": "4.70432",
+        //         "B": "6.714863",
+        //         "a": "20744.54",
+        //         "b": "20744.17"
+        //     }
+        //
+        // spot miniTicker
+        //
+        //     {
+        //         "s": "BTCUSDT",
+        //         "p": "76522",
+        //         "r": "0.0012",
+        //         "tr": "0.0012",
+        //         "h": "77196.3",
+        //         "l": "75630.77",
+        //         "v": "584664223.92",
+        //         "q": "7666.720258",
+        //         "lastRT": "-1",
+        //         "MT": "0",
+        //         "NV": "--",
+        //         "t": "1731135533126"
+        //     }
+        //
+        const marketId = this.safeString(ticker, 's');
+        const timestamp = this.safeInteger(ticker, 't');
+        const price = this.safeString(ticker, 'p');
         return this.safeTicker({
-            'symbol': this.safeSymbol(undefined, market),
-            'timestamp': undefined,
-            'datetime': undefined,
+            'info': ticker,
+            'symbol': this.safeSymbol(marketId, market),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
             'open': undefined,
-            'high': undefined,
-            'low': undefined,
-            'close': undefined,
+            'high': this.safeNumber(ticker, 'h'),
+            'low': this.safeNumber(ticker, 'l'),
+            'close': price,
+            'last': price,
             'bid': this.safeNumber(ticker, 'b'),
             'bidVolume': this.safeNumber(ticker, 'B'),
             'ask': this.safeNumber(ticker, 'a'),
@@ -233,11 +400,10 @@ export default class mexc extends mexcRest {
             'vwap': undefined,
             'previousClose': undefined,
             'change': undefined,
-            'percentage': undefined,
+            'percentage': this.safeNumber(ticker, 'tr'),
             'average': undefined,
-            'baseVolume': undefined,
-            'quoteVolume': undefined,
-            'info': ticker,
+            'baseVolume': this.safeNumber(ticker, 'v'),
+            'quoteVolume': this.safeNumber(ticker, 'q'),
         }, market);
     }
     async watchBidsAsks(symbols = undefined, params = {}) {
@@ -1340,6 +1506,8 @@ export default class mexc extends mexcRest {
             'public.kline.v3.api': this.handleOHLCV,
             'push.kline': this.handleOHLCV,
             'public.bookTicker.v3.api': this.handleTicker,
+            'public.miniTicker.v3.api': this.handleTicker,
+            'public.miniTickers.v3.api': this.handleTickers,
             'push.ticker': this.handleTicker,
             'push.tickers': this.handleTickers,
             'public.increase.depth.v3.api': this.handleOrderBook,

package/js/src/vertex.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/vertex.js';
-import type { Market, Ticker, Tickers, TradingFees, Balances, Int, OrderBook, OHLCV, Str, Order, OrderType, OrderSide, Trade, Strings, Dict, Num, Currencies, FundingRate, FundingRates } from './base/types.js';
+import type { Market, Ticker, Tickers, TradingFees, Balances, Int, OrderBook, OHLCV, Str, Order, OrderType, OrderSide, Trade, Strings, Dict, Num, Currencies, FundingRate, FundingRates, Currency, Transaction } from './base/types.js';
 /**
  * @class vertex
  * @augments Exchange
@@ -64,7 +64,9 @@ export default class vertex extends Exchange {
     parsePosition(position: any, market?: Market): import("./base/types.js").Position;
     fetchPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;
     queryNonces(): Promise<import("./base/types.js").Dictionary<any>>;
-    withdraw(code: string, amount: any, address: any, tag?: any, params?: {}): Promise<any>;
+    withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
+    parseTransactionStatus(status: Str): string;
     handlePublicAddress(methodName: string, params: Dict): any[];
     handleErrors(code: any, reason: any, url: any, method: any, headers: any, body: any, response: any, requestHeaders: any, requestBody: any): any;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {