ccxt 4.5.61 → 4.5.62

package/js/src/pro/htx.js

@@ -51,6 +51,7 @@ export default class htx extends htxRest {
                                 'linear': {
                                     'public': 'wss://api.hbdm.vn/linear-swap-ws',
                                     'private': 'wss://api.hbdm.vn/linear-swap-notification',
+                                    'privateV5': 'wss://api.hbdm.vn/ws/v5/notification',
                                 },
                                 'inverse': {
                                     'public': 'wss://api.hbdm.vn/ws',
@@ -65,6 +66,7 @@ export default class htx extends htxRest {
                                 'linear': {
                                     'public': 'wss://api.hbdm.vn/linear-swap-ws',
                                     'private': 'wss://api.hbdm.vn/linear-swap-notification',
+                                    'privateV5': 'wss://api.hbdm.vn/ws/v5/notification',
                                 },
                             },
                         },
@@ -79,6 +81,7 @@ export default class htx extends htxRest {
                                 'linear': {
                                     'public': 'wss://api.hbdm.vn/linear-swap-ws',
                                     'private': 'wss://api.hbdm.vn/linear-swap-notification',
+                                    'privateV5': 'wss://api.hbdm.vn/ws/v5/notification',
                                 },
                                 'inverse': {
                                     'public': 'wss://api.hbdm.vn/ws',
@@ -89,6 +92,7 @@ export default class htx extends htxRest {
                                 'linear': {
                                     'public': 'wss://api.hbdm.vn/linear-swap-ws',
                                     'private': 'wss://api.hbdm.vn/linear-swap-notification',
+                                    'privateV5': 'wss://api.hbdm.vn/ws/v5/notification',
                                 },
                                 'inverse': {
                                     'public': 'wss://api.hbdm.vn/swap-ws',
@@ -782,6 +786,7 @@ export default class htx extends htxRest {
      * @name htx#watchMyTrades
      * @description watches information on multiple trades made by the user
      * @see https://www.htx.com/en-us/opend/newApiPages/?id=7ec53dd5-7773-11ed-9966-0242ac110003
+     * @see https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-195a35275ff
      * @param {string} symbol unified market symbol of the market trades were made in
      * @param {int} [since] the earliest time in ms to fetch trades for
      * @param {int} [limit] the maximum number of trade structures to retrieve
@@ -812,6 +817,10 @@ export default class htx extends htxRest {
             subType = this.safeString(params, 'subType', subType);
             params = this.omit(params, ['type', 'subType']);
         }
+        const linear = (subType === 'linear');
+        const swap = (type === 'swap');
+        const future = (type === 'future');
+        const isV5Linear = (linear && (swap || future));
         if (type === 'spot') {
             let mode = undefined;
             if (mode === undefined) {
@@ -822,6 +831,12 @@ export default class htx extends htxRest {
             messageHash = 'trade.clearing' + '#' + marketId + '#' + mode;
             channel = messageHash;
         }
+        else if (isV5Linear) {
+            const channelAndMessageHashAndParams = this.getV5LinearChannelAndMessageHash('trade', market, params);
+            channel = this.safeString(channelAndMessageHashAndParams, 0);
+            messageHash = this.safeString(channelAndMessageHashAndParams, 1);
+            params = this.safeValue(channelAndMessageHashAndParams, 2, {});
+        }
         else {
             const channelAndMessageHash = this.getOrderChannelAndMessageHash(type, subType, market, params);
             channel = this.safeString(channelAndMessageHash, 0);
@@ -830,7 +845,10 @@ export default class htx extends htxRest {
             // like symbol/margin/subtype/type variations
             messageHash = orderMessageHash + ':' + 'trade';
         }
-        trades = await this.subscribePrivate(channel, messageHash, type, subType, params);
+        const subscriptionParams = {
+            'isV5': isV5Linear,
+        };
+        trades = await this.subscribePrivate(channel, messageHash, type, subType, params, subscriptionParams);
         if (this.newUpdates) {
             limit = trades.getLimit(symbol, limit);
         }
@@ -881,11 +899,22 @@ export default class htx extends htxRest {
         }
         return [channel, messageHash];
     }
+    getV5LinearChannelAndMessageHash(topic, market = undefined, params = {}) {
+        const contractCode = (market !== undefined) ? market['id'] : this.safeString(params, 'contract_code', '*');
+        const channel = topic;
+        const messageHash = (contractCode === '*') ? topic : (topic + '.' + contractCode.toLowerCase());
+        params = this.omit(params, 'contract_code');
+        const requestParams = this.extend({
+            'contract_code': contractCode,
+        }, params);
+        return [channel, messageHash, requestParams];
+    }
     /**
      * @method
      * @name htx#watchOrders
      * @description watches information on multiple orders made by the user
      * @see https://www.htx.com/en-us/opend/newApiPages/?id=7ec53c8f-7773-11ed-9966-0242ac110003
+     * @see https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-195a208afe7
      * @param {string} symbol unified market symbol of the market orders were made in
      * @param {int} [since] the earliest time in ms to fetch orders for
      * @param {int} [limit] the maximum number of order structures to retrieve
@@ -912,18 +941,31 @@ export default class htx extends htxRest {
             subType = this.safeString(params, 'subType', subType);
             params = this.omit(params, ['type', 'subType']);
         }
+        const linear = (subType === 'linear');
+        const swap = (type === 'swap');
+        const future = (type === 'future');
+        const isV5Linear = (linear && (swap || future));
         let messageHash = undefined;
         let channel = undefined;
         if (type === 'spot') {
             messageHash = 'orders' + '#' + suffix;
             channel = messageHash;
         }
+        else if (isV5Linear) {
+            const channelAndMessageHashAndParams = this.getV5LinearChannelAndMessageHash('orders', market, params);
+            channel = this.safeString(channelAndMessageHashAndParams, 0);
+            messageHash = this.safeString(channelAndMessageHashAndParams, 1);
+            params = this.safeValue(channelAndMessageHashAndParams, 2, {});
+        }
         else {
             const channelAndMessageHash = this.getOrderChannelAndMessageHash(type, subType, market, params);
             channel = this.safeString(channelAndMessageHash, 0);
             messageHash = this.safeString(channelAndMessageHash, 1);
         }
-        const orders = await this.subscribePrivate(channel, messageHash, type, subType, params);
+        const subscriptionParams = {
+            'isV5': isV5Linear,
+        };
+        const orders = await this.subscribePrivate(channel, messageHash, type, subType, params, subscriptionParams);
         if (this.newUpdates) {
             limit = orders.getLimit(symbol, limit);
         }
@@ -1050,11 +1092,60 @@ export default class htx extends htxRest {
         //   }
         //
         //
+        // linear v5 watchOrders
+        //
+        //     {
+        //         "op": "notify",
+        //         "topic": "orders",
+        //         "contract_code": "BTC-USDT",
+        //         "ts": 1782367563267,
+        //         "uid": "359305390",
+        //         "data": {
+        //             "side": "buy",
+        //             "type": "limit",
+        //             "price": "40000",
+        //             "volume": "1",
+        //             "state": "new",
+        //             "profit": "0",
+        //             "contract_code": "BTC-USDT",
+        //             "position_side": "both",
+        //             "price_match": null,
+        //             "order_id": "1519705236917489664",
+        //             "client_order_id": "1519705236917489664",
+        //             "margin_mode": "cross",
+        //             "lever_rate": 10,
+        //             "order_source": "api",
+        //             "reduce_only": false,
+        //             "time_in_force": "gtc",
+        //             "trade_avg_price": "0",
+        //             "trade_volume": "0",
+        //             "trade_turnover": "0",
+        //             "fee_currency": null,
+        //             "fee": "0",
+        //             "tp_trigger_price": "",
+        //             "tp_order_price": "",
+        //             "tp_type": "",
+        //             "tp_trigger_price_type": "",
+        //             "sl_trigger_price": "",
+        //             "sl_order_price": "",
+        //             "sl_type": "",
+        //             "sl_trigger_price_type": "",
+        //             "contract_type": "swap",
+        //             "cancel_reason": "",
+        //             "created_time": "1782367563239",
+        //             "updated_time": "1782367563239",
+        //             "self_match_prevent": "cancel_taker",
+        //             "amend_origin_volume": "",
+        //             "amend_source": "",
+        //             "amend_result": ""
+        //         }
+        //     }
+        //
         const messageHash = this.safeString2(message, 'ch', 'topic');
         const data = this.safeValue(message, 'data');
         let marketId = this.safeString(message, 'contract_code');
         if (marketId === undefined) {
-            marketId = this.safeString(data, 'symbol');
+            marketId = this.safeString2(data, 'contract_code', 'symbol');
         }
         const market = this.safeMarket(marketId);
         let parsedOrder = undefined;
@@ -1118,6 +1209,10 @@ export default class htx extends htxRest {
         const cachedOrders = this.orders;
         cachedOrders.append(parsedOrder);
         client.resolve(this.orders, messageHash);
+        if ((messageHash === 'orders') && (marketId !== undefined)) {
+            const specificMessageHash = messageHash + '.' + marketId.toLowerCase();
+            client.resolve(this.orders, specificMessageHash);
+        }
         // when we make a global subscription (for contracts only) our message hash can't have a symbol/currency attached
         // so we're removing it here
         let genericMessageHash = messageHash.replace('.' + market['lowercaseId'], '');
@@ -1239,22 +1334,64 @@ export default class htx extends htxRest {
         //         "real_profit": 0
         //     }
         //
-        const lastTradeTimestamp = this.safeInteger2(order, 'lastActTime', 'ts');
-        const created = this.safeInteger(order, 'orderCreateTime');
+        // linear v5 watchOrders
+        //
+        //     {
+        //         "side": "buy",
+        //         "type": "limit",
+        //         "price": "40000",
+        //         "volume": "1",
+        //         "state": "new",
+        //         "profit": "0",
+        //         "contract_code": "BTC-USDT",
+        //         "position_side": "both",
+        //         "price_match": null,
+        //         "order_id": "1519705236917489664",
+        //         "client_order_id": "1519705236917489664",
+        //         "margin_mode": "cross",
+        //         "lever_rate": 10,
+        //         "order_source": "api",
+        //         "reduce_only": false,
+        //         "time_in_force": "gtc",
+        //         "trade_avg_price": "0",
+        //         "trade_volume": "0",
+        //         "trade_turnover": "0",
+        //         "fee_currency": null,
+        //         "fee": "0",
+        //         "tp_trigger_price": "",
+        //         "tp_order_price": "",
+        //         "tp_type": "",
+        //         "tp_trigger_price_type": "",
+        //         "sl_trigger_price": "",
+        //         "sl_order_price": "",
+        //         "sl_type": "",
+        //         "sl_trigger_price_type": "",
+        //         "contract_type": "swap",
+        //         "cancel_reason": "",
+        //         "created_time": "1782367563239",
+        //         "updated_time": "1782367563239",
+        //         "self_match_prevent": "cancel_taker",
+        //         "amend_origin_volume": "",
+        //         "amend_source": "",
+        //         "amend_result": ""
+        //     }
+        //
+        const lastTradeTimestamp = this.safeIntegerN(order, ['lastActTime', 'updated_time', 'ts']);
+        const created = this.safeInteger2(order, 'orderCreateTime', 'created_time');
         const marketId = this.safeString2(order, 'contract_code', 'symbol');
         market = this.safeMarket(marketId, market);
         const symbol = this.safeSymbol(marketId, market);
         const amount = this.safeString2(order, 'orderSize', 'volume');
-        const status = this.parseOrderStatus(this.safeString2(order, 'orderStatus', 'status'));
+        const status = this.parseOrderStatus(this.safeStringN(order, ['orderStatus', 'state', 'status']));
         const id = this.safeString2(order, 'orderId', 'order_id');
         const clientOrderId = this.safeString2(order, 'clientOrderId', 'client_order_id');
         const price = this.safeString2(order, 'orderPrice', 'price');
-        const filled = this.safeString(order, 'execAmt');
+        const filled = this.safeString2(order, 'execAmt', 'trade_volume');
         const typeSide = this.safeString(order, 'type');
         const feeCost = this.safeString(order, 'fee');
         let fee = undefined;
         if (feeCost !== undefined) {
-            const feeCurrencyId = this.safeString(order, 'fee_asset');
+            const feeCurrencyId = this.safeString2(order, 'fee_asset', 'fee_currency');
             fee = {
                 'cost': feeCost,
                 'currency': this.safeCurrencyCode(feeCurrencyId),
@@ -1263,18 +1400,24 @@ export default class htx extends htxRest {
         const avgPrice = this.safeString(order, 'trade_avg_price');
         const rawTrades = this.safeValue(order, 'trade');
         let typeSideParts = [];
+        let type = undefined;
         if (typeSide !== undefined) {
-            typeSideParts = typeSide.split('-');
+            if (typeSide.indexOf('-') >= 0) {
+                typeSideParts = typeSide.split('-');
+                type = this.safeStringLower(typeSideParts, 1);
+            }
+            else {
+                type = typeSide;
+            }
         }
-        let type = this.safeStringLower(typeSideParts, 1);
         if (type === undefined) {
             type = this.safeString(order, 'order_price_type');
         }
         let side = this.safeStringLower(typeSideParts, 0);
         if (side === undefined) {
-            side = this.safeString(order, 'direction');
+            side = this.safeString2(order, 'direction', 'side');
         }
-        const cost = this.safeString(order, 'orderValue');
+        const cost = this.safeString2(order, 'orderValue', 'trade_turnover');
         return this.safeOrder({
             'info': order,
             'id': id,
@@ -1285,7 +1428,7 @@ export default class htx extends htxRest {
             'status': status,
             'symbol': symbol,
             'type': type,
-            'timeInForce': undefined,
+            'timeInForce': this.safeStringUpper(order, 'time_in_force'),
             'postOnly': undefined,
             'side': side,
             'price': price,
@@ -1296,6 +1439,11 @@ export default class htx extends htxRest {
             'fee': fee,
             'average': avgPrice,
             'trades': rawTrades,
+            'reduceOnly': this.safeBool(order, 'reduce_only'),
+            'stopPrice': undefined,
+            'triggerPrice': undefined,
+            'takeProfitPrice': this.safeString2(order, 'tp_trigger_price', 'tp_order_price'),
+            'stopLossPrice': this.safeString2(order, 'sl_trigger_price', 'sl_order_price'),
         }, market);
     }
     parseOrderTrade(trade, market = undefined) {
@@ -1357,11 +1505,10 @@ export default class htx extends htxRest {
     /**
      * @method
      * @name htx#watchPositions
-     * @see https://www.huobi.com/en-in/opend/newApiPages/?id=8cb7de1c-77b5-11ed-9966-0242ac110003
-     * @see https://www.huobi.com/en-in/opend/newApiPages/?id=8cb7df0f-77b5-11ed-9966-0242ac110003
+     * @description watch all open positions. Note: huobi has one channel for each marginMode and type
      * @see https://www.huobi.com/en-in/opend/newApiPages/?id=28c34a7d-77ae-11ed-9966-0242ac110003
      * @see https://www.huobi.com/en-in/opend/newApiPages/?id=5d5156b5-77b6-11ed-9966-0242ac110003
-     * @description watch all open positions. Note: huobi has one channel for each marginMode and type
+     * @see https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-195a35d6034
      * @param {string[]} [symbols] list of unified market symbols
      * @param {int} [since] timestamp in ms of the earliest position to fetch
      * @param {int} [limit] the maximum number of positions to fetch
@@ -1392,11 +1539,26 @@ export default class htx extends htxRest {
         symbols = this.marketSymbols(symbols);
         let marginMode = undefined;
         [marginMode, params] = this.handleMarginModeAndParams('watchPositions', params, 'cross');
+        const linear = (subType === 'linear');
+        const swap = (type === 'swap');
+        const future = (type === 'future');
+        const isV5Linear = (linear && (swap || future));
         const isLinear = (subType === 'linear');
-        const url = this.getUrlByMarketType(type, isLinear, true);
+        const url = this.getUrlByMarketType(type, isLinear, true, false, isV5Linear);
         messageHash = marginMode + ':positions' + messageHash;
-        const channel = (marginMode === 'cross') ? 'positions_cross.*' : 'positions.*';
-        const newPositions = await this.subscribePrivate(channel, messageHash, type, subType, params);
+        let channel = (marginMode === 'cross') ? 'positions_cross.*' : 'positions.*';
+        if (isV5Linear) {
+            const isOneMarket = (!this.isEmpty(symbols) && (symbols.length === 1));
+            const v5Market = isOneMarket ? market : undefined;
+            const channelAndMessageHashAndParams = this.getV5LinearChannelAndMessageHash('positions', v5Market, params);
+            channel = this.safeString(channelAndMessageHashAndParams, 0);
+            params = this.safeValue(channelAndMessageHashAndParams, 2, {});
+        }
+        const subscriptionParams = {
+            'isV5': isV5Linear,
+            'margin': marginMode,
+        };
+        const newPositions = await this.subscribePrivate(channel, messageHash, type, subType, params, subscriptionParams);
         if (this.newUpdates) {
             return newPositions;
         }
@@ -1438,9 +1600,53 @@ export default class htx extends htxRest {
         //        ]
         //    }
         //
+        // watchPositions linear v5
+        //
+        //     {
+        //         "op": "notify",
+        //         "topic": "positions",
+        //         "contract_code": "BTC-USDT",
+        //         "ts": 1782460576073,
+        //         "uid": "359305390",
+        //         "event": "snapshot",
+        //         "data": [
+        //             {
+        //                 "contract_code": "BTC-USDT",
+        //                 "symbol": "BTC",
+        //                 "position_mode": "single_side",
+        //                 "position_side": "both",
+        //                 "direction": "buy",
+        //                 "margin_mode": "cross",
+        //                 "open_avg_price": "60547.9",
+        //                 "volume": "1",
+        //                 "available": "1",
+        //                 "fee": "0.03632874",
+        //                 "break_even_price": "60620.55748",
+        //                 "total_trade_fee": "0.03632874",
+        //                 "lever_rate": 10,
+        //                 "adl_risk_percent": 4,
+        //                 "liquidation_price": "-102094.847680676304309652",
+        //                 "initial_margin": "6.05807",
+        //                 "maintenance_margin": "0.20597438",
+        //                 "profit_unreal": "0.0328",
+        //                 "profit": "0",
+        //                 "profit_rate": "0.0054",
+        //                 "margin_rate": "0.0012",
+        //                 "state": "normal",
+        //                 "funding_fee": "0",
+        //                 "mark_price": "60580.7",
+        //                 "last_price": "60591.4",
+        //                 "contract_type": "swap",
+        //                 "version": 7,
+        //                 "created_time": "1782460515119",
+        //                 "updated_time": "1782460515119"
+        //             }
+        //         ]
+        //     }
+        //
         const url = client.url;
         const topic = this.safeString(message, 'topic', '');
-        const marginMode = (topic === 'positions_cross') ? 'cross' : 'isolated';
+        const defaultMarginMode = (topic === 'positions_cross') ? 'cross' : 'isolated';
         if (this.positions === undefined) {
             this.positions = {};
         }
@@ -1448,43 +1654,64 @@ export default class htx extends htxRest {
         if (clientPositions === undefined) {
             this.positions[url] = {};
         }
-        const clientMarginModePositions = this.safeValue(clientPositions, marginMode);
-        if (clientMarginModePositions === undefined) {
-            this.positions[url][marginMode] = new ArrayCacheBySymbolBySide();
-        }
-        const cache = this.positions[url][marginMode];
         const rawPositions = this.safeValue(message, 'data', []);
+        if (this.isEmpty(rawPositions)) {
+            const prefixes = ['cross:positions', 'isolated:positions'];
+            for (let i = 0; i < prefixes.length; i++) {
+                const messageHashes = this.findMessageHashes(client, prefixes[i]);
+                for (let j = 0; j < messageHashes.length; j++) {
+                    client.resolve([], messageHashes[j]);
+                }
+            }
+            return;
+        }
         const newPositions = [];
+        const positionsByMarginMode = {};
         const timestamp = this.safeInteger(message, 'ts');
         for (let i = 0; i < rawPositions.length; i++) {
             const rawPosition = rawPositions[i];
             const position = this.parsePosition(rawPosition);
             position['timestamp'] = timestamp;
             position['datetime'] = this.iso8601(timestamp);
+            let marginMode = this.safeStringLower(position, 'marginMode', defaultMarginMode);
+            if ((marginMode !== 'cross') && (marginMode !== 'isolated')) {
+                marginMode = defaultMarginMode;
+            }
+            let cache = this.safeValue(this.positions[url], marginMode);
+            if (cache === undefined) {
+                cache = new ArrayCacheBySymbolBySide();
+                this.positions[url][marginMode] = cache;
+            }
             newPositions.push(position);
+            positionsByMarginMode[marginMode] = this.safeValue(positionsByMarginMode, marginMode, []);
+            positionsByMarginMode[marginMode].push(position);
             cache.append(position);
         }
-        const messageHashes = this.findMessageHashes(client, marginMode + ':positions::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
-            if (!this.isEmpty(positions)) {
-                client.resolve(positions, messageHash);
+        const marginModes = Object.keys(positionsByMarginMode);
+        for (let i = 0; i < marginModes.length; i++) {
+            const marginMode = marginModes[i];
+            const marginModePositions = this.safeValue(positionsByMarginMode, marginMode, []);
+            const messageHashes = this.findMessageHashes(client, marginMode + ':positions::');
+            for (let j = 0; j < messageHashes.length; j++) {
+                const messageHash = messageHashes[j];
+                const parts = messageHash.split('::');
+                const symbolsString = parts[1];
+                const symbols = symbolsString.split(',');
+                const positions = this.filterByArray(marginModePositions, 'symbol', symbols, false);
+                if (!this.isEmpty(positions)) {
+                    client.resolve(positions, messageHash);
+                }
             }
+            client.resolve(marginModePositions, marginMode + ':positions');
         }
-        client.resolve(newPositions, marginMode + ':positions');
     }
     /**
      * @method
      * @name htx#watchBalance
      * @description watch balance and get the amount of funds available for trading or funds locked in orders
      * @see https://www.htx.com/en-us/opend/newApiPages/?id=7ec52e28-7773-11ed-9966-0242ac110003
-     * @see https://www.htx.com/en-us/opend/newApiPages/?id=10000084-77b7-11ed-9966-0242ac110003
-     * @see https://www.htx.com/en-us/opend/newApiPages/?id=8cb7dcca-77b5-11ed-9966-0242ac110003
      * @see https://www.htx.com/en-us/opend/newApiPages/?id=28c34995-77ae-11ed-9966-0242ac110003
+     * @see https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-195a6c94551
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
      */
@@ -1499,12 +1726,22 @@ export default class htx extends htxRest {
         let messageHash = undefined;
         let channel = undefined;
         let marginMode = undefined;
+        const linear = (subType === 'linear');
+        const swap = (type === 'swap');
+        const future = (type === 'future');
+        const isV5Linear = (linear && (swap || future));
         if (type === 'spot') {
             let mode = this.safeString2(this.options, 'watchBalance', 'mode', '2');
             mode = this.safeString(params, 'mode', mode);
             messageHash = 'accounts.update' + '#' + mode;
             channel = messageHash;
         }
+        else if (isV5Linear) {
+            marginMode = this.safeString(params, 'margin', 'cross');
+            params = this.omit(params, ['currency', 'symbol', 'margin']);
+            channel = 'account';
+            messageHash = 'account';
+        }
         else {
             const symbol = this.safeString(params, 'symbol');
             const currency = this.safeString(params, 'currency');
@@ -1576,6 +1813,7 @@ export default class htx extends htxRest {
             'type': type,
             'subType': subType,
             'margin': marginMode,
+            'isV5': isV5Linear,
         };
         // we are differentiating the channel from the messageHash for global subscriptions (*)
         // because huobi returns a different topic than the topic sent. Example: we send
@@ -1628,47 +1866,47 @@ export default class htx extends htxRest {
         //         "uid":"123456789"
         //     }
         //
-        // usdt / linear future, swap
+        // watchBalance linear v5
         //
         //     {
-        //         "op":"notify",
-        //         "topic":"accounts.btc-usdt", // or "accounts" for global subscriptions
-        //         "ts":1603711370689,
-        //         "event":"order.open",
-        //         "data":[
-        //             {
-        //                 "margin_mode":"cross",
-        //                 "margin_account":"USDT",
-        //                 "margin_asset":"USDT",
-        //                 "margin_balance":30.959342395,
-        //                 "margin_static":30.959342395,
-        //                 "margin_position":0,
-        //                 "margin_frozen":10,
-        //                 "profit_real":0,
-        //                 "profit_unreal":0,
-        //                 "withdraw_available":20.959342395,
-        //                 "risk_rate":153.796711975,
-        //                 "position_mode":"dual_side",
-        //                 "contract_detail":[
-        //                     {
-        //                         "symbol":"LTC",
-        //                         "contract_code":"LTC-USDT",
-        //                         "margin_position":0,
-        //                         "margin_frozen":0,
-        //                         "margin_available":20.959342395,
-        //                         "profit_unreal":0,
-        //                         "liquidation_price":null,
-        //                         "lever_rate":1,
-        //                         "adjust_factor":0.01,
-        //                         "contract_type":"swap",
-        //                         "pair":"LTC-USDT",
-        //                         "business_type":"swap",
-        //                         "trade_partition":"USDT"
-        //                     },
-        //                 ],
-        //                 "futures_contract_detail":[],
-        //             }
-        //         ]
+        //         "op": "notify",
+        //         "topic": "account",
+        //         "contract_code": "",
+        //         "ts": 1782459963509,
+        //         "uid": "359305390",
+        //         "event": "snapshot",
+        //         "data": {
+        //             "equity": "0",
+        //             "state": "normal",
+        //             "details": [
+        //                 {
+        //                     "currency": "USDT",
+        //                     "equity": "162.331953938562004875",
+        //                     "available": "162.331953938562004875",
+        //                     "profit_unreal": "0",
+        //                     "initial_margin": "0",
+        //                     "maintenance_margin": "0",
+        //                     "maintenance_margin_rate": "0",
+        //                     "initial_margin_rate": "0",
+        //                     "voucher": "0",
+        //                     "voucher_value": "0",
+        //                     "created_time": "1770293270932",
+        //                     "updated_time": "1780329743956",
+        //                     "isolated_equity": "0",
+        //                     "isolated_profit_unreal": "0",
+        //                     "withdraw_available": "162.331953938562004875"
+        //                 }
+        //             ],
+        //             "initial_margin": "0",
+        //             "maintenance_margin": "0",
+        //             "maintenance_margin_rate": "0",
+        //             "profit_unreal": "0",
+        //             "available_margin": "0",
+        //             "created_time": "1770293268881",
+        //             "updated_time": "1780329743956",
+        //             "version": 5659,
+        //             "voucher_value": "0"
+        //         }
         //     }
         //
         // inverse future
@@ -1717,12 +1955,32 @@ export default class htx extends htxRest {
         }
         else {
             // contract balance
+            const topic = this.safeString(message, 'topic');
+            if (topic === 'account') {
+                const accountData = this.safeDict(message, 'data', {});
+                const details = this.safeList(accountData, 'details', []);
+                const detailsLength = details.length;
+                for (let i = 0; i < detailsLength; i++) {
+                    const detail = details[i];
+                    const currencyId = this.safeString(detail, 'currency');
+                    const code = this.safeCurrencyCode(currencyId);
+                    if (code === undefined) {
+                        continue;
+                    }
+                    const account = this.account();
+                    account['free'] = this.safeString(detail, 'withdraw_available');
+                    account['total'] = this.safeString(detail, 'equity');
+                    this.balance[code] = account;
+                }
+                this.balance = this.safeBalance(this.balance);
+                client.resolve(this.balance, 'account');
+                return;
+            }
             const dataLength = data.length;
             if (dataLength === 0) {
                 return;
             }
             const first = this.safeValue(data, 0, {});
-            const topic = this.safeString(message, 'topic');
             const splitTopic = topic.split('.');
             let messageHash = this.safeString(splitTopic, 0);
             let subscription = this.safeValue2(client.subscriptions, messageHash, messageHash + '.*');
@@ -2000,6 +2258,9 @@ export default class htx extends htxRest {
             if (topic.indexOf('orders') >= 0) {
                 this.handleOrder(client, message);
             }
+            if (topic.indexOf('trade') >= 0) {
+                this.handleMyTrade(client, message);
+            }
             if (topic.indexOf('account') >= 0) {
                 this.handleBalance(client, message);
             }
@@ -2290,20 +2551,65 @@ export default class htx extends htxRest {
         //         ],
         //     }
         //
+        // linear v5 watchMyTrades
+        //
+        //     {
+        //         "op": "notify",
+        //         "topic": "trade",
+        //         "contract_code": "BTC-USDT",
+        //         "ts": 1782367694387,
+        //         "uid": "359305390",
+        //         "data": [
+        //             {
+        //                 "direction": "buy",
+        //                 "id": "100121555172810-1519705786942156810-1",
+        //                 "contract_code": "BTC-USDT",
+        //                 "contract_type": "swap",
+        //                 "order_id": "1519705786942156810",
+        //                 "trade_id": "155233460",
+        //                 "position_side": "both",
+        //                 "trade_volume": "1",
+        //                 "trade_price": "61629",
+        //                 "trade_turnover": "61.629",
+        //                 "role": "taker",
+        //                 "client_order_id": "1519705786942156810",
+        //                 "created_time": "1782367694375",
+        //                 "updated_time": "1782367694385"
+        //             }
+        //         ]
+        //     }
+        //
         if (this.myTrades === undefined) {
             const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
             this.myTrades = new ArrayCacheBySymbolById(limit);
         }
         const cachedTrades = this.myTrades;
-        const messageHash = this.safeString(message, 'ch');
+        const messageHash = this.safeString2(message, 'ch', 'topic');
         if (messageHash !== undefined) {
             const data = this.safeValue(message, 'data');
             if (data !== undefined) {
-                const parsed = this.parseWsTrade(data);
-                const symbol = this.safeString(parsed, 'symbol');
-                if (symbol !== undefined) {
-                    cachedTrades.append(parsed);
-                    client.resolve(this.myTrades, messageHash);
+                const contractCode = this.safeString(message, 'contract_code');
+                const market = (contractCode !== undefined) ? this.safeMarket(contractCode) : undefined;
+                if (Array.isArray(data)) {
+                    for (let i = 0; i < data.length; i++) {
+                        const parsed = this.parseWsTrade(data[i], market);
+                        const symbol = this.safeString(parsed, 'symbol');
+                        if (symbol !== undefined) {
+                            cachedTrades.append(parsed);
+                        }
+                    }
+                }
+                else {
+                    const parsed = this.parseWsTrade(data, market);
+                    const symbol = this.safeString(parsed, 'symbol');
+                    if (symbol !== undefined) {
+                        cachedTrades.append(parsed);
+                    }
+                }
+                client.resolve(this.myTrades, messageHash);
+                if ((messageHash === 'trade') && (contractCode !== undefined)) {
+                    const specificMessageHash = messageHash + '.' + contractCode.toLowerCase();
+                    client.resolve(this.myTrades, specificMessageHash);
                 }
             }
             else {
@@ -2361,31 +2667,54 @@ export default class htx extends htxRest {
         //         "feeDeductType":""
         //     }
         //
-        const symbol = this.safeSymbol(this.safeString(trade, 'symbol'));
-        const side = this.safeString2(trade, 'side', 'orderSide');
-        const tradeId = this.safeString(trade, 'tradeId');
-        const price = this.safeString(trade, 'tradePrice');
-        const amount = this.safeString(trade, 'tradeVolume');
-        const order = this.safeString(trade, 'orderId');
-        const timestamp = this.safeInteger(trade, 'tradeTime');
-        market = this.market(symbol);
-        const orderType = this.safeString(trade, 'orderType');
+        // linear v5 watchMyTrades
+        //
+        //     {
+        //         "direction": "buy",
+        //         "id": "100121555172810-1519705786942156810-1",
+        //         "contract_code": "BTC-USDT",
+        //         "contract_type": "swap",
+        //         "order_id": "1519705786942156810",
+        //         "trade_id": "155233460",
+        //         "position_side": "both",
+        //         "trade_volume": "1",
+        //         "trade_price": "61629",
+        //         "trade_turnover": "61.629",
+        //         "role": "taker",
+        //         "client_order_id": "1519705786942156810",
+        //         "created_time": "1782367694375",
+        //         "updated_time": "1782367694385"
+        //     }
+        //
+        const marketId = this.safeString2(trade, 'symbol', 'contract_code');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const side = this.safeStringN(trade, ['side', 'orderSide', 'direction']);
+        const tradeId = this.safeStringN(trade, ['tradeId', 'trade_id', 'id']);
+        const price = this.safeString2(trade, 'tradePrice', 'trade_price');
+        const amount = this.safeString2(trade, 'tradeVolume', 'trade_volume');
+        const order = this.safeString2(trade, 'orderId', 'order_id');
+        const timestamp = this.safeIntegerN(trade, ['tradeTime', 'updated_time', 'created_time']);
+        const orderType = this.safeString2(trade, 'orderType', 'type');
         const aggressor = this.safeValue(trade, 'aggressor');
         let takerOrMaker = undefined;
         if (aggressor !== undefined) {
             takerOrMaker = aggressor ? 'taker' : 'maker';
         }
+        else {
+            takerOrMaker = this.safeStringLower(trade, 'role');
+        }
         let type = undefined;
         let orderTypeParts = [];
         if (orderType !== undefined) {
             orderTypeParts = orderType.split('-');
-            type = this.safeString(orderTypeParts, 1);
+            type = this.safeString(orderTypeParts, 1, orderType);
         }
         let fee = undefined;
-        const feeCurrency = this.safeCurrencyCode(this.safeString(trade, 'feeCurrency'));
+        const feeCurrency = this.safeCurrencyCode(this.safeStringN(trade, ['feeCurrency', 'fee_currency', 'fee_asset']));
         if (feeCurrency !== undefined) {
             fee = {
-                'cost': this.safeString(trade, 'transactFee'),
+                'cost': this.safeStringN(trade, ['transactFee', 'fee', 'trade_fee']),
                 'currency': feeCurrency,
             };
         }
@@ -2405,7 +2734,7 @@ export default class htx extends htxRest {
             'fee': fee,
         }, market);
     }
-    getUrlByMarketType(type, isLinear = true, isPrivate = false, isFeed = false) {
+    getUrlByMarketType(type, isLinear = true, isPrivate = false, isFeed = false, isV5 = false) {
         const api = this.safeString(this.options, 'api', 'api');
         const hostname = { 'hostname': this.hostname };
         let hostnameURL = undefined;
@@ -2427,7 +2756,17 @@ export default class htx extends htxRest {
         else {
             const baseUrl = this.urls['api']['ws'][api][type];
             const subTypeUrl = isLinear ? baseUrl['linear'] : baseUrl['inverse'];
-            url = isPrivate ? subTypeUrl['private'] : subTypeUrl['public'];
+            if (isPrivate) {
+                if (isV5 && isLinear) {
+                    url = this.safeString(subTypeUrl, 'privateV5', subTypeUrl['private']);
+                }
+                else {
+                    url = subTypeUrl['private'];
+                }
+            }
+            else {
+                url = subTypeUrl['public'];
+            }
         }
         return url;
     }
@@ -2495,7 +2834,8 @@ export default class htx extends htxRest {
             };
         }
         const isLinear = subtype === 'linear';
-        const url = this.getUrlByMarketType(type, isLinear, true);
+        const isV5 = this.safeBool(subscriptionParams, 'isV5', false);
+        const url = this.getUrlByMarketType(type, isLinear, true, false, isV5);
         const hostname = (type === 'spot') ? this.urls['hostnames']['spot'] : this.urls['hostnames']['contract'];
         const authParams = {
             'type': type,