ccxt 4.3.57 → 4.3.59

package/js/src/hyperliquid.js

@@ -101,7 +101,7 @@ export default class hyperliquid extends Exchange {
                 'fetchTickers': false,
                 'fetchTime': false,
                 'fetchTrades': true,
-                'fetchTradingFee': false,
+                'fetchTradingFee': true,
                 'fetchTradingFees': false,
                 'fetchTransfer': false,
                 'fetchTransfers': false,
@@ -2519,6 +2519,112 @@ export default class hyperliquid extends Exchange {
             'fee': undefined,
         };
     }
+    async fetchTradingFee(symbol, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#fetchTradingFee
+         * @description fetch the trading fees for a market
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.user] user address, will default to this.walletAddress if not provided
+         * @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
+         */
+        await this.loadMarkets();
+        let userAddress = undefined;
+        [userAddress, params] = this.handlePublicAddress('fetchTradingFee', params);
+        const market = this.market(symbol);
+        const request = {
+            'type': 'userFees',
+            'user': userAddress,
+        };
+        const response = await this.publicPostInfo(this.extend(request, params));
+        //
+        //     {
+        //         "dailyUserVlm": [
+        //             {
+        //                 "date": "2024-07-08",
+        //                 "userCross": "0.0",
+        //                 "userAdd": "0.0",
+        //                 "exchange": "90597185.23639999"
+        //             }
+        //         ],
+        //         "feeSchedule": {
+        //             "cross": "0.00035",
+        //             "add": "0.0001",
+        //             "tiers": {
+        //                 "vip": [
+        //                     {
+        //                         "ntlCutoff": "5000000.0",
+        //                         "cross": "0.0003",
+        //                         "add": "0.00005"
+        //                     }
+        //                 ],
+        //                 "mm": [
+        //                     {
+        //                         "makerFractionCutoff": "0.005",
+        //                         "add": "-0.00001"
+        //                     }
+        //                 ]
+        //             },
+        //             "referralDiscount": "0.04"
+        //         },
+        //         "userCrossRate": "0.00035",
+        //         "userAddRate": "0.0001",
+        //         "activeReferralDiscount": "0.0"
+        //     }
+        //
+        const data = {
+            'userCrossRate': this.safeString(response, 'userCrossRate'),
+            'userAddRate': this.safeString(response, 'userAddRate'),
+        };
+        return this.parseTradingFee(data, market);
+    }
+    parseTradingFee(fee, market = undefined) {
+        //
+        //     {
+        //         "dailyUserVlm": [
+        //             {
+        //                 "date": "2024-07-08",
+        //                 "userCross": "0.0",
+        //                 "userAdd": "0.0",
+        //                 "exchange": "90597185.23639999"
+        //             }
+        //         ],
+        //         "feeSchedule": {
+        //             "cross": "0.00035",
+        //             "add": "0.0001",
+        //             "tiers": {
+        //                 "vip": [
+        //                     {
+        //                         "ntlCutoff": "5000000.0",
+        //                         "cross": "0.0003",
+        //                         "add": "0.00005"
+        //                     }
+        //                 ],
+        //                 "mm": [
+        //                     {
+        //                         "makerFractionCutoff": "0.005",
+        //                         "add": "-0.00001"
+        //                     }
+        //                 ]
+        //             },
+        //             "referralDiscount": "0.04"
+        //         },
+        //         "userCrossRate": "0.00035",
+        //         "userAddRate": "0.0001",
+        //         "activeReferralDiscount": "0.0"
+        //     }
+        //
+        const symbol = this.safeSymbol(undefined, market);
+        return {
+            'info': fee,
+            'symbol': symbol,
+            'maker': this.safeNumber(fee, 'userAddRate'),
+            'taker': this.safeNumber(fee, 'userCrossRate'),
+            'percentage': undefined,
+            'tierBased': undefined,
+        };
+    }
     formatVaultAddress(address = undefined) {
         if (address === undefined) {
             return undefined;

package/js/src/kucoin.js

@@ -243,6 +243,8 @@ export default class kucoin extends Exchange {
                         'purchase/orders': 10,
                         // broker
                         'broker/api/rebase/download': 3,
+                        // affiliate
+                        'affiliate/inviter/statistics': 30,
                     },
                     'post': {
                         // account
@@ -684,6 +686,7 @@ export default class kucoin extends Exchange {
                             'redeem/orders': 'v3',
                             'purchase/orders': 'v3',
                             'margin/symbols': 'v3',
+                            'affiliate/inviter/statistics': 'v2',
                         },
                         'POST': {
                             // account

package/js/src/latoken.d.ts

@@ -45,7 +45,7 @@ export default class latoken extends Exchange {
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     fetchTransactions(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     parseTransactionStatus(status: Str): string;

package/js/src/latoken.js

@@ -1419,7 +1419,11 @@ export default class latoken extends Exchange {
         //         "status":"SUCCESS"
         //     }
         //
-        return response;
+        return [
+            this.safeOrder({
+                'info': response,
+            }),
+        ];
     }
     async fetchTransactions(code = undefined, since = undefined, limit = undefined, params = {}) {
         /**

package/js/src/mexc.js

@@ -799,24 +799,24 @@ export default class mexc extends Exchange {
             'commonCurrencies': {
                 'BEYONDPROTOCOL': 'BEYOND',
                 'BIFI': 'BIFIF',
-                'BYN': 'BeyondFi',
+                'BYN': 'BEYONDFI',
                 'COFI': 'COFIX',
-                'DFI': 'DfiStarter',
-                'DFT': 'dFuture',
+                'DFI': 'DFISTARTER',
+                'DFT': 'DFUTURE',
                 'DRK': 'DRK',
-                'EGC': 'Egoras Credit',
+                'EGC': 'EGORASCREDIT',
                 'FLUX1': 'FLUX',
                 'FLUX': 'FLUX1',
-                'FREE': 'FreeRossDAO',
+                'FREE': 'FREEROSSDAO',
                 'GAS': 'GASDAO',
                 'GASNEO': 'GAS',
-                'GMT': 'GMT Token',
+                'GMT': 'GMTTOKEN',
                 'STEPN': 'GMT',
-                'HERO': 'Step Hero',
-                'MIMO': 'Mimosa',
-                'PROS': 'Pros.Finance',
-                'SIN': 'Sin City Token',
-                'SOUL': 'Soul Swap',
+                'HERO': 'STEPHERO',
+                'MIMO': 'MIMOSA',
+                'PROS': 'PROSFINANCE',
+                'SIN': 'SINCITYTOKEN',
+                'SOUL': 'SOULSWAP',
             },
             'exceptions': {
                 'exact': {

package/js/src/okx.js

@@ -7356,6 +7356,9 @@ export default class okx extends Exchange {
                 }
                 depositWithdrawFees[code]['info'][currencyId] = feeInfo;
                 const chain = this.safeString(feeInfo, 'chain');
+                if (chain === undefined) {
+                    continue;
+                }
                 const chainSplit = chain.split('-');
                 const networkId = this.safeValue(chainSplit, 1);
                 const withdrawFee = this.safeNumber(feeInfo, 'minFee');

package/js/src/pro/binance.js

@@ -614,9 +614,9 @@ export default class binance extends binanceRest {
         for (let i = 0; i < symbols.length; i++) {
             const symbol = symbols[i];
             const market = this.market(symbol);
-            const messageHash = market['lowercaseId'] + '@' + name;
-            messageHashes.push(messageHash);
-            const symbolHash = messageHash + '@' + watchOrderBookRate + 'ms';
+            messageHashes.push('orderbook::' + symbol);
+            const subscriptionHash = market['lowercaseId'] + '@' + name;
+            const symbolHash = subscriptionHash + '@' + watchOrderBookRate + 'ms';
             subParams.push(symbolHash);
         }
         const messageHashesLength = messageHashes.length;
@@ -636,8 +636,7 @@ export default class binance extends binanceRest {
             'type': type,
             'params': params,
         };
-        const message = this.extend(request, params);
-        const orderbook = await this.watchMultiple(url, messageHashes, message, messageHashes, subscription);
+        const orderbook = await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes, subscription);
         return orderbook.limit();
     }
     async fetchOrderBookWs(symbol, limit = undefined, params = {}) {
@@ -816,8 +815,7 @@ export default class binance extends binanceRest {
         const marketId = this.safeString(message, 's');
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const symbol = market['symbol'];
-        const name = 'depth';
-        const messageHash = market['lowercaseId'] + '@' + name;
+        const messageHash = 'orderbook::' + symbol;
         if (!(symbol in this.orderbooks)) {
             //
             // https://github.com/ccxt/ccxt/issues/6672
@@ -960,12 +958,14 @@ export default class binance extends binanceRest {
         if (firstMarket['contract']) {
             type = firstMarket['linear'] ? 'future' : 'delivery';
         }
+        const messageHashes = [];
         const subParams = [];
         for (let i = 0; i < symbols.length; i++) {
             const symbol = symbols[i];
             const market = this.market(symbol);
-            const currentMessageHash = market['lowercaseId'] + '@' + name;
-            subParams.push(currentMessageHash);
+            messageHashes.push('trade::' + symbol);
+            const rawHash = market['lowercaseId'] + '@' + name;
+            subParams.push(rawHash);
         }
         const query = this.omit(params, 'type');
         const subParamsLength = subParams.length;
@@ -979,7 +979,7 @@ export default class binance extends binanceRest {
         const subscribe = {
             'id': requestId,
         };
-        const trades = await this.watchMultiple(url, subParams, this.extend(request, query), subParams, subscribe);
+        const trades = await this.watchMultiple(url, messageHashes, this.extend(request, query), messageHashes, subscribe);
         if (this.newUpdates) {
             const first = this.safeValue(trades, 0);
             const tradeSymbol = this.safeString(first, 'symbol');
@@ -1170,9 +1170,7 @@ export default class binance extends binanceRest {
         const marketId = this.safeString(message, 's');
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const symbol = market['symbol'];
-        const lowerCaseId = this.safeStringLower(message, 's');
-        const event = this.safeString(message, 'e');
-        const messageHash = lowerCaseId + '@' + event;
+        const messageHash = 'trade::' + symbol;
         const trade = this.parseWsTrade(message, market);
         let tradesArray = this.safeValue(this.trades, symbol);
         if (tradesArray === undefined) {

package/js/src/pro/bingx.js

@@ -97,10 +97,10 @@ export default class bingx extends bingxRest {
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        const [marketType, query] = this.handleMarketTypeAndParams('watchTrades', market, params);
+        const [marketType, query] = this.handleMarketTypeAndParams('watchTicker', market, params);
         const url = this.safeValue(this.urls['api']['ws'], marketType);
         if (url === undefined) {
-            throw new BadRequest(this.id + ' watchTrades is not supported for ' + marketType + ' markets.');
+            throw new BadRequest(this.id + ' watchTicker is not supported for ' + marketType + ' markets.');
         }
         const subscriptionHash = market['id'] + '@ticker';
         const messageHash = this.getMessageHash('ticker', market['symbol']);
@@ -448,21 +448,23 @@ export default class bingx extends bingxRest {
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        const [marketType, query] = this.handleMarketTypeAndParams('watchTrades', market, params);
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('watchTrades', market, params);
         const url = this.safeValue(this.urls['api']['ws'], marketType);
         if (url === undefined) {
             throw new BadRequest(this.id + ' watchTrades is not supported for ' + marketType + ' markets.');
         }
-        const messageHash = market['id'] + '@trade';
+        const rawHash = market['id'] + '@trade';
+        const messageHash = 'trade::' + symbol;
         const uuid = this.uuid();
         const request = {
             'id': uuid,
-            'dataType': messageHash,
+            'dataType': rawHash,
         };
         if (marketType === 'swap') {
             request['reqType'] = 'sub';
         }
-        const trades = await this.watch(url, messageHash, this.extend(request, query), messageHash);
+        const trades = await this.watch(url, messageHash, this.extend(request, params), messageHash);
         if (this.newUpdates) {
             limit = trades.getLimit(symbol, limit);
         }
@@ -529,12 +531,13 @@ export default class bingx extends bingxRest {
         //    }
         //
         const data = this.safeValue(message, 'data', []);
-        const messageHash = this.safeString(message, 'dataType');
-        const marketId = messageHash.split('@')[0];
+        const rawHash = this.safeString(message, 'dataType');
+        const marketId = rawHash.split('@')[0];
         const isSwap = client.url.indexOf('swap') >= 0;
         const marketType = isSwap ? 'swap' : 'spot';
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const symbol = market['symbol'];
+        const messageHash = 'trade::' + symbol;
         let trades = undefined;
         if (Array.isArray(data)) {
             trades = this.parseTrades(data, market);

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

@@ -1,5 +1,5 @@
 import bitmartRest from '../bitmart.js';
-import type { Int, Market, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Position, Balances } from '../base/types.js';
+import type { Int, Market, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Position, Balances, Dict } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class bitmart extends bitmartRest {
     describe(): any;
@@ -16,7 +16,7 @@ export default class bitmart extends bitmartRest {
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: Market): Order;
+    parseWsOrder(order: Dict, market?: Market): Order;
     parseWsOrderStatus(statusId: any): string;
     parseWsOrderSide(sideId: any): string;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
@@ -24,7 +24,7 @@ export default class bitmart extends bitmartRest {
     parseWsPosition(position: any, market?: Market): Position;
     handleTrade(client: Client, message: any): void;
     handleTradeLoop(entry: any): string;
-    parseWsTrade(trade: any, market?: Market): Trade;
+    parseWsTrade(trade: Dict, market?: Market): Trade;
     handleTicker(client: Client, message: any): void;
     parseWsSwapTicker(ticker: any, market?: Market): Ticker;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;

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

@@ -1,5 +1,5 @@
 import bitoproRest from '../bitopro.js';
-import type { Int, OrderBook, Trade, Ticker, Balances, Market, Str } from '../base/types.js';
+import type { Int, OrderBook, Trade, Ticker, Balances, Market, Str, Dict } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class bitopro extends bitoproRest {
     describe(): any;
@@ -10,7 +10,7 @@ export default class bitopro extends bitoproRest {
     handleTrade(client: Client, message: any): void;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrade(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: Market): Trade;
+    parseWsTrade(trade: Dict, market?: Market): Trade;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
     authenticate(url: any): void;

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

@@ -1,5 +1,5 @@
 import coincheckRest from '../coincheck.js';
-import type { Int, Market, OrderBook, Trade } from '../base/types.js';
+import type { Int, Market, OrderBook, Trade, Dict } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class coincheck extends coincheckRest {
     describe(): any;
@@ -7,6 +7,6 @@ export default class coincheck extends coincheckRest {
     handleOrderBook(client: any, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: Market): Trade;
+    parseWsTrade(trade: Dict, market?: Market): Trade;
     handleMessage(client: Client, message: any): void;
 }

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

@@ -1,5 +1,5 @@
 import coinoneRest from '../coinone.js';
-import type { Int, Market, OrderBook, Ticker, Trade } from '../base/types.js';
+import type { Int, Market, OrderBook, Ticker, Trade, Dict } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class coinone extends coinoneRest {
     describe(): any;
@@ -11,7 +11,7 @@ export default class coinone extends coinoneRest {
     parseWsTicker(ticker: any, market?: Market): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: Market): Trade;
+    parseWsTrade(trade: Dict, market?: Market): Trade;
     handleErrorMessage(client: Client, message: any): boolean;
     handleMessage(client: Client, message: any): void;
     ping(client: any): {

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

@@ -1,6 +1,6 @@
 import hyperliquidRest from '../hyperliquid.js';
 import Client from '../base/ws/Client.js';
-import { Int, Str, Market, OrderBook, Trade, OHLCV, Order } from '../base/types.js';
+import { Int, Str, Market, OrderBook, Trade, OHLCV, Order, Dict } from '../base/types.js';
 export default class hyperliquid extends hyperliquidRest {
     describe(): any;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
@@ -9,7 +9,7 @@ export default class hyperliquid extends hyperliquidRest {
     handleMyTrades(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: Market): Trade;
+    parseWsTrade(trade: Dict, market?: Market): Trade;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/pro/okx.js

@@ -1685,7 +1685,7 @@ export default class okx extends okxRest {
         if (this.isEmpty(args)) {
             const method = this.safeString(message, 'op');
             const stringMsg = this.json(message);
-            this.handleErrors(undefined, undefined, client.url, method, undefined, stringMsg, stringMsg, undefined, undefined);
+            this.handleErrors(undefined, undefined, client.url, method, undefined, stringMsg, message, undefined, undefined);
         }
         const orders = this.parseOrders(args, undefined, undefined, undefined);
         const first = this.safeDict(orders, 0, {});
@@ -1860,8 +1860,8 @@ export default class okx extends okxRest {
         future.resolve(true);
     }
     ping(client) {
-        // okex does not support built-in ws protocol-level ping-pong
-        // instead it requires custom text-based ping-pong
+        // OKX does not support the built-in WebSocket protocol-level ping-pong.
+        // Instead, it requires a custom text-based ping-pong mechanism.
         return 'ping';
     }
     handlePong(client, message) {

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

@@ -0,0 +1,31 @@
+import xtRest from '../xt.js';
+import { Balances, Dict, Int, Market, OHLCV, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade } from '../base/types.js';
+import Client from '../base/ws/Client.js';
+export default class xt extends xtRest {
+    describe(): any;
+    getListenKey(isContract: boolean): Promise<any>;
+    getCacheIndex(orderbook: any, cache: any): any;
+    handleDelta(orderbook: any, delta: any): void;
+    subscribe(name: string, access: string, methodName: string, market?: Market, symbols?: string[], params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    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[]>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchBalance(params?: {}): Promise<Balances>;
+    handleTicker(client: Client, message: Dict): Dict;
+    handleTickers(client: Client, message: Dict): Dict;
+    handleOHLCV(client: Client, message: Dict): Dict;
+    handleTrade(client: Client, message: Dict): Dict;
+    handleOrderBook(client: Client, message: Dict): void;
+    parseWsOrderTrade(trade: Dict, market?: Market): Trade;
+    parseWsOrder(order: Dict, market?: Market): Order;
+    handleOrder(client: Client, message: Dict): Dict;
+    handleBalance(client: Client, message: Dict): void;
+    handleMyTrades(client: Client, message: Dict): void;
+    handleMessage(client: Client, message: any): void;
+    ping(client: Client): string;
+    handleErrorMessage(client: Client, message: Dict): void;
+}