ccxt 4.5.82 → 4.5.83

package/js/src/pro/hitbtc.js

@@ -223,7 +223,7 @@ export default class hitbtc extends hitbtcRest {
      * @returns {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
      */
     async watchOrderBook(symbol, limit = undefined, params = {}) {
-        const options = this.safeValue(this.options, 'watchOrderBook');
+        const options = this.safeDict(this.options, 'watchOrderBook');
         const defaultMethod = this.safeString(options, 'method', 'orderbook/full');
         let name = this.safeString2(params, 'method', 'defaultMethod', defaultMethod);
         const depth = this.safeString(params, 'depth', '20');
@@ -346,7 +346,7 @@ export default class hitbtc extends hitbtcRest {
             await this.loadMarkets();
         }
         symbols = this.marketSymbols(symbols);
-        const options = this.safeValue(this.options, 'watchTicker');
+        const options = this.safeDict(this.options, 'watchTicker');
         const defaultMethod = this.safeString(options, 'method', 'ticker/{speed}/batch');
         const method = this.safeString2(params, 'method', 'defaultMethod', defaultMethod);
         const speed = this.safeString(params, 'speed', '1s');
@@ -505,7 +505,7 @@ export default class hitbtc extends hitbtcRest {
             await this.loadMarkets();
         }
         symbols = this.marketSymbols(symbols, undefined, false);
-        const options = this.safeValue(this.options, 'watchBidsAsks');
+        const options = this.safeDict(this.options, 'watchBidsAsks');
         const defaultMethod = this.safeString(options, 'method', 'orderbook/top/{speed}/batch');
         const method = this.safeString2(params, 'method', 'defaultMethod', defaultMethod);
         const speed = this.safeString(params, 'speed', '100ms');
@@ -779,7 +779,7 @@ export default class hitbtc extends hitbtcRest {
             const marketId = marketIds[i];
             const market = this.safeMarket(marketId);
             const symbol = market['symbol'];
-            this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});
+            this.ohlcvs[symbol] = this.safeDict(this.ohlcvs, symbol, {});
             let stored = this.safeValue(this.safeValue(this.ohlcvs, symbol), timeframe);
             if (stored === undefined) {
                 const limit = this.safeInteger(this.options, 'OHLCVLimit', 1000);
@@ -1379,7 +1379,7 @@ export default class hitbtc extends hitbtcRest {
         //        "result": true
         //    }
         //
-        const success = this.safeValue(message, 'result');
+        const success = this.safeBool(message, 'result');
         const messageHash = 'authenticated';
         if (success === true) {
             const future = this.safeValue(client.futures, messageHash);
@@ -1406,7 +1406,7 @@ export default class hitbtc extends hitbtcRest {
         //        id: 1700228604325
         //    }
         //
-        const error = this.safeValue(message, 'error');
+        const error = this.safeDict(message, 'error');
         if (error !== undefined) {
             try {
                 const code = this.safeValue(error, 'code');

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

@@ -13,8 +13,8 @@ export default class hollaex extends hollaexRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
      */
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    handleOrderBook(client: Client, message: any): void;
+    watchOrderBook(symbol: string, limit?: Int, params?: Dict): Promise<OrderBook>;
+    handleOrderBook(client: Client, message: Dict): void;
     /**
      * @method
      * @name hollaex#watchTrades
@@ -26,8 +26,8 @@ export default class hollaex extends hollaexRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
      */
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    handleTrades(client: Client, message: any): void;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    handleTrades(client: Client, message: Dict): void;
     /**
      * @method
      * @name hollaex#watchMyTrades
@@ -39,8 +39,8 @@ export default class hollaex extends hollaexRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
      */
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    handleMyTrades(client: Client, message: any, subscription?: Dict | undefined): void;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    handleMyTrades(client: Client, message: Dict, subscription?: Dict | undefined): void;
     /**
      * @method
      * @name hollaex#watchOrders
@@ -52,8 +52,8 @@ export default class hollaex extends hollaexRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
      */
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    handleOrder(client: Client, message: any, subscription?: Dict | undefined): void;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    handleOrder(client: Client, message: Dict, subscription?: Dict | undefined): void;
     /**
      * @method
      * @name hollaex#watchBalance
@@ -62,16 +62,14 @@ export default class hollaex extends hollaexRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
      */
-    watchBalance(params?: {}): Promise<Balances>;
-    handleBalance(client: Client, message: any): void;
-    watchPublic(messageHash: any, params?: {}): Promise<any>;
-    watchPrivate(messageHash: any, params?: {}): Promise<any>;
+    watchBalance(params?: Dict): Promise<Balances>;
+    handleBalance(client: Client, message: Dict): void;
+    watchPublic(messageHash: string, params?: Dict): Promise<any>;
+    watchPrivate(messageHash: string, params?: Dict): Promise<any>;
     handleErrorMessage(client: Client, message: any): Bool;
-    handleMessage(client: Client, message: any): void;
-    ping(client: Client): {
-        op: string;
-    };
-    handlePong(client: Client, message: any): any;
+    handleMessage(client: Client, message: Dict): void;
+    ping(client: Client): Dict;
+    handlePong(client: Client, message: Dict): Dict;
     onError(client: Client, error: any): void;
     onClose(client: Client, error: any): void;
 }

package/js/src/pro/hollaex.js

@@ -102,7 +102,7 @@ export default class hollaex extends hollaexRest {
         if (symbol === undefined) {
             return;
         }
-        const data = this.safeValue(message, 'data');
+        const data = this.safeDict(message, 'data');
         const timestamp = this.safeString(data, 'timestamp');
         const timestampMs = this.parse8601(timestamp);
         const snapshot = this.parseOrderBook(data, symbol, timestampMs);
@@ -171,7 +171,7 @@ export default class hollaex extends hollaexRest {
             stored = new ArrayCache(limit);
             this.trades[symbol] = stored;
         }
-        const data = this.safeValue(message, 'data', []);
+        const data = this.safeList(message, 'data', []);
         const parsedTrades = this.parseTrades(data, market);
         for (let j = 0; j < parsedTrades.length; j++) {
             stored.append(parsedTrades[j]);
@@ -605,7 +605,7 @@ export default class hollaex extends hollaexRest {
             'wallet': this.handleBalance,
             'usertrade': this.handleMyTrades,
         };
-        const topic = this.safeValue(message, 'topic');
+        const topic = this.safeString(message, 'topic');
         const method = this.safeValue(methods, topic);
         if (method !== undefined) {
             method.call(this, client, message);

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

@@ -14,7 +14,7 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
      */
-    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTicker(symbol: string, params?: Dict): Promise<Ticker>;
     /**
      * @method
      * @name htx#unWatchTicker
@@ -26,7 +26,7 @@ export default class htx extends htxRest {
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
      */
     unWatchTicker(symbol: string, params?: {}): Promise<any>;
-    handleTicker(client: Client, message: any): any;
+    handleTicker(client: Client, message: Dict): Dict;
     /**
      * @method
      * @name htx#watchTrades
@@ -40,7 +40,7 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
      */
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
     /**
      * @method
      * @name htx#unWatchTrades
@@ -53,7 +53,7 @@ export default class htx extends htxRest {
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
      */
     unWatchTrades(symbol: string, params?: {}): Promise<any>;
-    handleTrades(client: Client, message: any): any;
+    handleTrades(client: Client, message: Dict): Dict;
     /**
      * @method
      * @name htx#watchOHLCV
@@ -68,7 +68,7 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
      */
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
     /**
      * @method
      * @name htx#unWatchOHLCV
@@ -83,7 +83,7 @@ export default class htx extends htxRest {
      * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
      */
     unWatchOHLCV(symbol: string, timeframe?: string, params?: Dict): Promise<any>;
-    handleOHLCV(client: Client, message: any): void;
+    handleOHLCV(client: Client, message: Dict): void;
     /**
      * @method
      * @name htx#watchOrderBook
@@ -110,13 +110,13 @@ export default class htx extends htxRest {
      * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure}
      */
     unWatchOrderBook(symbol: string, params?: Dict): Promise<any>;
-    handleOrderBookSnapshot(client: Client, message: any, subscription: any): void;
-    watchOrderBookSnapshot(client: any, message: any, subscription: any): Promise<any>;
+    handleOrderBookSnapshot(client: Client, message: Dict, subscription: Dict): void;
+    watchOrderBookSnapshot(client: Client, message: Dict, subscription: Dict): Promise<any>;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
-    handleOrderBookMessage(client: Client, message: any): void;
-    handleOrderBook(client: Client, message: any): void;
-    handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
+    handleOrderBookMessage(client: Client, message: Dict): void;
+    handleOrderBook(client: Client, message: Dict): void;
+    handleOrderBookSubscription(client: Client, message: Dict, subscription: Dict): void;
     /**
      * @method
      * @name htx#watchMyTrades
@@ -129,9 +129,9 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
      */
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    getOrderChannelAndMessageHash(type: any, subType: any, market?: Market, params?: {}): string[];
-    getV5LinearChannelAndMessageHash(topic: any, market?: Market, params?: {}): any[];
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    getOrderChannelAndMessageHash(type: Str, subType: Str, market?: Market, params?: Dict): Str[];
+    getV5LinearChannelAndMessageHash(topic: Str, market?: Market, params?: Dict): any[];
     /**
      * @method
      * @name htx#watchOrders
@@ -144,10 +144,10 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
      */
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    handleOrder(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: Market): Order;
-    parseOrderTrade(trade: any, market?: Market): Trade;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    handleOrder(client: Client, message: Dict): void;
+    parseWsOrder(order: Dict, market?: Market): Order;
+    parseOrderTrade(trade: Dict, market?: Market): Trade;
     /**
      * @method
      * @name htx#watchPositions
@@ -161,8 +161,8 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    handlePositions(client: any, message: any): void;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: Dict): Promise<Position[]>;
+    handlePositions(client: Client, message: Dict): void;
     /**
      * @method
      * @name htx#watchBalance
@@ -173,22 +173,22 @@ export default class htx extends htxRest {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
      */
-    watchBalance(params?: {}): Promise<Balances>;
-    handleBalance(client: Client, message: any): void;
-    handleSubscriptionStatus(client: Client, message: any): void;
+    watchBalance(params?: Dict): Promise<Balances>;
+    handleBalance(client: Client, message: Dict): void;
+    handleSubscriptionStatus(client: Client, message: Dict): void;
     handleUnSubscription(client: Client, subscription: Dict | undefined): void;
-    handleSystemStatus(client: Client, message: any): any;
-    handleSubject(client: Client, message: any): void;
-    pong(client: Client, message: any): Promise<void>;
-    handlePing(client: Client, message: any): void;
-    handleAuthenticate(client: Client, message: any): void;
-    handleErrorMessage(client: Client, message: any): Bool;
-    handleMessage(client: Client, message: any): void;
-    handleMyTrade(client: Client, message: any, extendParams?: {}): void;
-    parseWsTrade(trade: any, market?: Market): Trade;
+    handleSystemStatus(client: Client, message: Dict): Dict;
+    handleSubject(client: Client, message: Dict): void;
+    pong(client: Client, message: Dict): Promise<void>;
+    handlePing(client: Client, message: Dict): void;
+    handleAuthenticate(client: Client, message: Dict): void;
+    handleErrorMessage(client: Client, message: Dict): Bool;
+    handleMessage(client: Client, message: Dict): void;
+    handleMyTrade(client: Client, message: Dict, extendParams?: Dict): void;
+    parseWsTrade(trade: Dict, market?: Market): Trade;
     getUrlByMarketType(type: any, isLinear?: boolean, isPrivate?: boolean, isFeed?: boolean, isV5?: boolean): Str;
-    subscribePublic(url: any, symbol: any, messageHash: any, method?: any, params?: {}): Promise<any>;
-    unsubscribePublic(market: Market, subMessageHash: string, topic: string, params?: {}): Promise<any>;
-    subscribePrivate(channel: any, messageHash: any, type: any, subtype: any, params?: any, subscriptionParams?: {}): Promise<any>;
-    authenticate(params?: {}): Promise<any>;
+    subscribePublic(url: Str, symbol: Str, messageHash: Str, method?: any, params?: Dict): Promise<any>;
+    unsubscribePublic(market: Market, subMessageHash: string, topic: string, params?: Dict): Promise<any>;
+    subscribePrivate(channel: Str, messageHash: Str, type: Str, subtype: Str, params?: Dict, subscriptionParams?: Dict): Promise<any>;
+    authenticate(params?: Dict): Promise<any>;
 }

package/js/src/pro/htx.js

@@ -223,7 +223,7 @@ export default class htx extends htxRest {
         //         }
         //     }
         //
-        const tick = this.safeValue(message, 'tick', {});
+        const tick = this.safeDict(message, 'tick', {});
         const ch = this.safeString(message, 'ch');
         if (ch === undefined) {
             return message;
@@ -232,7 +232,7 @@ export default class htx extends htxRest {
         const marketId = this.safeString(parts, 1);
         const market = this.safeMarket(marketId);
         const ticker = this.parseTicker(tick, market);
-        const timestamp = this.safeValue(message, 'ts');
+        const timestamp = this.safeInteger(message, 'ts');
         ticker['timestamp'] = timestamp;
         ticker['datetime'] = this.iso8601(timestamp);
         const symbol = ticker['symbol'];
@@ -312,8 +312,8 @@ export default class htx extends htxRest {
         //         }
         //     }
         //
-        const tick = this.safeValue(message, 'tick', {});
-        const data = this.safeValue(tick, 'data', {});
+        const tick = this.safeDict(message, 'tick', {});
+        const data = this.safeList(tick, 'data', []);
         const ch = this.safeString(message, 'ch');
         if (ch === undefined) {
             return message;
@@ -415,7 +415,7 @@ export default class htx extends htxRest {
         const symbol = market['symbol'];
         const interval = this.safeString(parts, 3);
         const timeframe = this.findTimeframe(interval);
-        this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});
+        this.ohlcvs[symbol] = this.safeDict(this.ohlcvs, symbol, {});
         let stored = this.safeValue(this.safeValue(this.ohlcvs, symbol), timeframe);
         if (stored === undefined) {
             const limit = this.safeInteger(this.options, 'OHLCVLimit', 1000);
@@ -539,11 +539,11 @@ export default class htx extends htxRest {
         const lastTimestamp = this.safeInteger(subscription, 'lastTimestamp');
         try {
             const orderbook = this.safeValue(this.orderbooks, symbol);
-            const data = this.safeValue(message, 'data');
+            const data = this.safeDict(message, 'data');
             const messages = orderbook.cache;
-            const firstMessage = this.safeValue(messages, 0, {});
+            const firstMessage = this.safeDict(messages, 0, {});
             const snapshot = this.parseOrderBook(data, symbol);
-            const tick = this.safeValue(firstMessage, 'tick');
+            const tick = this.safeDict(firstMessage, 'tick');
             const sequence = this.safeInteger(tick, 'prevSeqNum');
             const nonce = this.safeInteger(data, 'seqNum');
             if (nonce === undefined) {
@@ -721,7 +721,7 @@ export default class htx extends htxRest {
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
         const orderbook = this.orderbooks[symbol];
-        const tick = this.safeValue(message, 'tick', {});
+        const tick = this.safeDict(message, 'tick', {});
         const seqNum = this.safeInteger(tick, 'seqNum');
         const prevSeqNum = this.safeInteger(tick, 'prevSeqNum');
         const event = this.safeString(tick, 'event');
@@ -741,8 +741,8 @@ export default class htx extends htxRest {
         const spotConditon = (market['spot'] === true) && (prevSeqNum === orderbook['nonce']);
         const nonSpotCondition = (market['contract'] === true) && (version !== undefined) && (version - 1 === orderbook['nonce']);
         if ((spotConditon === true) || (nonSpotCondition === true)) {
-            const asks = this.safeValue(tick, 'asks', []);
-            const bids = this.safeValue(tick, 'bids', []);
+            const asks = this.safeList(tick, 'asks', []);
+            const bids = this.safeList(tick, 'bids', []);
             this.handleDeltas(orderbook['asks'], asks);
             this.handleDeltas(orderbook['bids'], bids);
             orderbook['nonce'] = (spotConditon === true) ? seqNum : version;
@@ -891,7 +891,7 @@ export default class htx extends htxRest {
             const channelAndMessageHashAndParams = this.getV5LinearChannelAndMessageHash('trade', market, params);
             channel = this.safeString(channelAndMessageHashAndParams, 0);
             messageHash = this.safeString(channelAndMessageHashAndParams, 1);
-            params = this.safeValue(channelAndMessageHashAndParams, 2, {});
+            params = this.safeDict(channelAndMessageHashAndParams, 2, {});
         }
         else {
             const channelAndMessageHash = this.getOrderChannelAndMessageHash(type, subType, market, params);
@@ -1022,7 +1022,7 @@ export default class htx extends htxRest {
             const channelAndMessageHashAndParams = this.getV5LinearChannelAndMessageHash('orders', market, params);
             channel = this.safeString(channelAndMessageHashAndParams, 0);
             messageHash = this.safeString(channelAndMessageHashAndParams, 1);
-            params = this.safeValue(channelAndMessageHashAndParams, 2, {});
+            params = this.safeDict(channelAndMessageHashAndParams, 2, {});
         }
         else {
             const channelAndMessageHash = this.getOrderChannelAndMessageHash(type, subType, market, params);
@@ -1209,7 +1209,7 @@ export default class htx extends htxRest {
         //     }
         //
         const messageHash = this.safeString2(message, 'ch', 'topic');
-        const data = this.safeValue(message, 'data');
+        const data = this.safeDict(message, 'data');
         let marketId = this.safeString(message, 'contract_code');
         if (marketId === undefined) {
             marketId = this.safeString2(data, 'contract_code', 'symbol');
@@ -1553,7 +1553,7 @@ export default class htx extends htxRest {
             side = typeParts[0];
             type = typeParts[1];
         }
-        const aggressor = this.safeValue(trade, 'aggressor');
+        const aggressor = this.safeBool(trade, 'aggressor');
         let takerOrMaker = undefined;
         if (aggressor !== undefined) {
             takerOrMaker = (aggressor === true) ? 'taker' : 'maker';
@@ -1628,7 +1628,7 @@ export default class htx extends htxRest {
             }
             const channelAndMessageHashAndParams = this.getV5LinearChannelAndMessageHash('positions', v5Market, params);
             channel = this.safeString(channelAndMessageHashAndParams, 0);
-            params = this.safeValue(channelAndMessageHashAndParams, 2, {});
+            params = this.safeDict(channelAndMessageHashAndParams, 2, {});
         }
         const subscriptionParams = {
             'isV5': isV5Linear,
@@ -1726,7 +1726,7 @@ export default class htx extends htxRest {
         if (this.positions === undefined) {
             this.positions = {};
         }
-        const clientPositions = this.safeValue(this.positions, url);
+        const clientPositions = this.safeDict(this.positions, url);
         if (clientPositions === undefined) {
             this.positions[url] = {};
         }
@@ -1759,14 +1759,14 @@ export default class htx extends htxRest {
                 this.positions[url][marginMode] = cache;
             }
             newPositions.push(position);
-            positionsByMarginMode[marginMode] = this.safeValue(positionsByMarginMode, marginMode, []);
+            positionsByMarginMode[marginMode] = this.safeList(positionsByMarginMode, marginMode, []);
             positionsByMarginMode[marginMode].push(position);
             cache.append(position);
         }
         const marginModes = Object.keys(positionsByMarginMode);
         for (let i = 0; i < marginModes.length; i++) {
             const marginMode = marginModes[i];
-            const marginModePositions = this.safeValue(positionsByMarginMode, marginMode, []);
+            const marginModePositions = this.safeList(positionsByMarginMode, marginMode, []);
             const messageHashes = this.findMessageHashes(client, marginMode + ':positions::');
             for (let j = 0; j < messageHashes.length; j++) {
                 const messageHash = messageHashes[j];
@@ -1796,7 +1796,7 @@ export default class htx extends htxRest {
         [type, params] = this.handleMarketTypeAndParams('watchBalance', undefined, params);
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('watchBalance', undefined, params, 'linear');
-        const isUnifiedAccount = this.safeValue2(params, 'isUnifiedAccount', 'unified', false);
+        const isUnifiedAccount = this.safeBool2(params, 'isUnifiedAccount', 'unified', false);
         params = this.omit(params, ['isUnifiedAccount', 'unified']);
         if (this.markets === undefined) {
             await this.loadMarkets();
@@ -2063,10 +2063,10 @@ export default class htx extends htxRest {
             if (dataLength === 0) {
                 return;
             }
-            const first = this.safeValue(data, 0, {});
+            const first = this.safeDict(data, 0, {});
             const splitTopic = topic.split('.');
             let messageHash = this.safeString(splitTopic, 0);
-            let subscription = this.safeValue2(client.subscriptions, messageHash, messageHash + '.*');
+            let subscription = this.safeDict2(client.subscriptions, messageHash, messageHash + '.*');
             if (subscription === undefined) {
                 // if subscription not found means that we subscribed to a specific currency/symbol
                 // and we use the first data entry to find it
@@ -2078,7 +2078,7 @@ export default class htx extends htxRest {
                     return;
                 }
                 messageHash += '.' + currencyId.toLowerCase();
-                subscription = this.safeValue(client.subscriptions, messageHash);
+                subscription = this.safeDict(client.subscriptions, messageHash);
             }
             const subType = this.safeString(subscription, 'subType');
             if (topic === 'accounts_unify') {
@@ -2298,7 +2298,7 @@ export default class htx extends htxRest {
         //         // ?
         //     }
         //
-        const ch = this.safeValue(message, 'ch', '');
+        const ch = this.safeString(message, 'ch', '');
         const parts = ch.split('.');
         const type = this.safeString(parts, 0);
         if (type === 'market') {
@@ -2365,7 +2365,7 @@ export default class htx extends htxRest {
             }
             const action = this.safeString(message, 'action');
             if (action === 'ping') {
-                const data = this.safeValue(message, 'data');
+                const data = this.safeDict(message, 'data');
                 const pingTs = this.safeInteger(data, 'ts');
                 await client.send({ 'action': 'pong', 'data': { 'ts': pingTs } });
                 return;
@@ -2447,7 +2447,7 @@ export default class htx extends htxRest {
                 return false;
             }
             const subscriptionsById = this.indexBy(client.subscriptions, 'id');
-            const subscription = this.safeValue(subscriptionsById, id);
+            const subscription = this.safeDict(subscriptionsById, id);
             if (subscription !== undefined) {
                 const errorCode = this.safeString(message, 'err-code');
                 try {
@@ -2710,7 +2710,7 @@ export default class htx extends htxRest {
                 // this trades object is artificially created
                 // in handleOrder
                 const rawTrades = this.safeList(message, 'trades', []);
-                const marketId = this.safeValue(message, 'symbol');
+                const marketId = this.safeString(message, 'symbol');
                 const market = this.market(marketId);
                 for (let i = 0; i < rawTrades.length; i++) {
                     const trade = rawTrades[i];
@@ -2790,7 +2790,7 @@ export default class htx extends htxRest {
         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');
+        const aggressor = this.safeBool(trade, 'aggressor');
         let takerOrMaker = undefined;
         if (aggressor !== undefined) {
             takerOrMaker = (aggressor === true) ? 'taker' : 'maker';