# -*- coding: utf-8 -*-

# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

import ccxt.async_support
from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
import hashlib
from ccxt.base.types import Any, Balances, Int, Order, OrderBook, Str, Ticker, Trade
from ccxt.async_support.base.ws.client import Client
from typing import List
from ccxt.base.errors import ExchangeError
from ccxt.base.errors import AuthenticationError
from ccxt.base.errors import ChecksumError
from ccxt.base.precise import Precise


class bitfinex(ccxt.async_support.bitfinex):

    def describe(self) -> Any:
        return self.deep_extend(super(bitfinex, self).describe(), {
            'has': {
                'ws': True,
                'watchTicker': True,
                'watchTickers': False,
                'watchOrderBook': True,
                'watchTrades': True,
                'watchTradesForSymbols': False,
                'watchMyTrades': True,
                'watchBalance': True,
                'watchOHLCV': True,
                'watchOrders': True,
                'unWatchTicker': True,
                'unWatchTrades': True,
                'unWatchOHLCV': True,
                'unWatchOrderBook': True,
            },
            'urls': {
                'api': {
                    'ws': {
                        'public': 'wss://api-pub.bitfinex.com/ws/2',
                        'private': 'wss://api.bitfinex.com/ws/2',
                    },
                },
            },
            'options': {
                'watchOrderBook': {
                    'prec': 'P0',
                    'freq': 'F0',
                    'checksum': True,
                },
                'ordersLimit': 1000,
            },
        })

    async def subscribe(self, channel, symbol, params={}):
        await self.load_markets()
        market = self.market(symbol)
        marketId = market['id']
        url = self.urls['api']['ws']['public']
        client = self.client(url)
        messageHash = channel + ':' + marketId
        request: dict = {
            'event': 'subscribe',
            'channel': channel,
            'symbol': marketId,
        }
        result = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash, {'checksum': False})
        checksum = self.safe_bool(self.options, 'checksum', True)
        if checksum and (channel == 'book'):
            sub = client.subscriptions[messageHash]
            if sub and not sub['checksum']:
                client.subscriptions[messageHash]['checksum'] = True
                await client.send({
                    'event': 'conf',
                    'flags': 131072,
                })
        return result

    async def un_subscribe(self, channel, topic, symbol, params={}):
        await self.load_markets()
        market = self.market(symbol)
        marketId = market['id']
        url = self.urls['api']['ws']['public']
        client = self.client(url)
        subMessageHash = channel + ':' + marketId
        messageHash = 'unsubscribe:' + channel + ':' + marketId
        unSubTopic = 'unsubscribe' + ':' + topic + ':' + symbol
        channelId = self.safe_string(client.subscriptions, unSubTopic)
        request: dict = {
            'event': 'unsubscribe',
            'chanId': channelId,
        }
        unSubChanMsg = 'unsubscribe:' + channelId
        client.subscriptions[unSubChanMsg] = subMessageHash
        subscription = {
            'messageHashes': [messageHash],
            'subMessageHashes': [subMessageHash],
            'topic': topic,
            'unsubscribe': True,
            'symbols': [symbol],
        }
        return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash, subscription)

    async def subscribe_private(self, messageHash):
        await self.load_markets()
        await self.authenticate()
        url = self.urls['api']['ws']['private']
        return await self.watch(url, messageHash, None, 1)

    async def watch_ohlcv(self, symbol: str, timeframe: str = '1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
        """
        watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
        :param str symbol: unified symbol of the market to fetch OHLCV data for
        :param str timeframe: the length of time each candle represents
        :param int [since]: timestamp in ms of the earliest candle to fetch
        :param int [limit]: the maximum amount of candles to fetch
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns int[][]: A list of candles ordered, open, high, low, close, volume
        """
        await self.load_markets()
        market = self.market(symbol)
        symbol = market['symbol']
        interval = self.safe_string(self.timeframes, timeframe, timeframe)
        channel = 'candles'
        key = 'trade:' + interval + ':' + market['id']
        messageHash = channel + ':' + interval + ':' + market['id']
        request: dict = {
            'event': 'subscribe',
            'channel': channel,
            'key': key,
        }
        url = self.urls['api']['ws']['public']
        # not using subscribe here because self message has a different format
        ohlcv = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
        if self.newUpdates:
            limit = ohlcv.getLimit(symbol, limit)
        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)

    async def un_watch_ohlcv(self, symbol: str, timeframe: str = '1m', params={}):
        """
        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
        :param str symbol: unified symbol of the market to fetch OHLCV data for
        :param str timeframe: the length of time each candle represents
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns bool: True if successfully unsubscribed, False otherwise
        """
        await self.load_markets()
        market = self.market(symbol)
        symbol = market['symbol']
        interval = self.safe_string(self.timeframes, timeframe, timeframe)
        channel = 'candles'
        subMessageHash = channel + ':' + interval + ':' + market['id']
        messageHash = 'unsubscribe:' + subMessageHash
        url = self.urls['api']['ws']['public']
        client = self.client(url)
        subId = 'unsubscribe:trade:' + interval + ':' + market['id']  # trade here because we use the key
        channelId = self.safe_string(client.subscriptions, subId)
        request: dict = {
            'event': 'unsubscribe',
            'chanId': channelId,
        }
        unSubChanMsg = 'unsubscribe:' + channelId
        client.subscriptions[unSubChanMsg] = subMessageHash
        subscription = {
            'messageHashes': [messageHash],
            'subMessageHashes': [subMessageHash],
            'topic': 'ohlcv',
            'unsubscribe': True,
            'symbols': [symbol],
        }
        return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash, subscription)

    def handle_ohlcv(self, client: Client, message, subscription):
        #
        # initial snapshot
        #   [
        #       341527,  # channel id
        #       [
        #          [
        #             1654705860000,  # timestamp
        #             1802.6,  # open
        #             1800.3,  # close
        #             1802.8,  # high
        #             1800.3,  # low
        #             86.49588236  # volume
        #          ],
        #          [
        #             1654705800000,
        #             1803.6,
        #             1802.6,
        #             1804.9,
        #             1802.3,
        #             74.6348086
        #          ],
        #          [
        #             1654705740000,
        #             1802.5,
        #             1803.2,
        #             1804.4,
        #             1802.4,
        #             23.61801085
        #          ]
        #       ]
        #   ]
        #
        # update
        #   [
        #       211171,
        #       [
        #          1654705680000,
        #          1801,
        #          1802.4,
        #          1802.9,
        #          1800.4,
        #          23.91911091
        #       ]
        #   ]
        #
        data = self.safe_value(message, 1, [])
        ohlcvs = None
        first = self.safe_value(data, 0)
        if isinstance(first, list):
            # snapshot
            ohlcvs = data
        else:
            # update
            ohlcvs = [data]
        channel = self.safe_value(subscription, 'channel')
        key = self.safe_string(subscription, 'key')
        keyParts = key.split(':')
        interval = self.safe_string(keyParts, 1)
        marketId = key
        marketId = marketId.replace('trade:', '')
        marketId = marketId.replace(interval + ':', '')
        market = self.safe_market(marketId)
        timeframe = self.find_timeframe(interval)
        symbol = market['symbol']
        messageHash = channel + ':' + interval + ':' + marketId
        self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
        stored = self.safe_value(self.ohlcvs[symbol], timeframe)
        if stored is None:
            limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
            stored = ArrayCacheByTimestamp(limit)
            self.ohlcvs[symbol][timeframe] = stored
        ohlcvsLength = len(ohlcvs)
        for i in range(0, ohlcvsLength):
            ohlcv = ohlcvs[ohlcvsLength - i - 1]
            parsed = self.parse_ohlcv(ohlcv, market)
            stored.append(parsed)
        client.resolve(stored, messageHash)

    async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
        """
        get the list of most recent trades for a particular symbol
        :param str symbol: unified symbol of the market to fetch trades for
        :param int [since]: timestamp in ms of the earliest trade to fetch
        :param int [limit]: the maximum amount of trades to fetch
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/?id=public-trades>`
        """
        trades = await self.subscribe('trades', symbol, params)
        if self.newUpdates:
            limit = trades.getLimit(symbol, limit)
        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)

    async def un_watch_trades(self, symbol: str, params={}):
        """
        unWatches the list of most recent trades for a particular symbol
        :param str symbol: unified symbol of the market to fetch trades for
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/?id=public-trades>`
        """
        return await self.un_subscribe('trades', 'trades', symbol, params)

    async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
        """
        watches information on multiple trades made by the user
        :param str 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
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/?id=trade-structure>`
        """
        await self.load_markets()
        messageHash = 'myTrade'
        if symbol is not None:
            market = self.market(symbol)
            messageHash += ':' + market['id']
        trades = await self.subscribe_private(messageHash)
        if self.newUpdates:
            limit = trades.getLimit(symbol, limit)
        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)

    async def watch_ticker(self, symbol: str, params={}) -> Ticker:
        """
        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
        :param str symbol: unified symbol of the market to fetch the ticker for
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `ticker structure <https://docs.ccxt.com/?id=ticker-structure>`
        """
        return await self.subscribe('ticker', symbol, params)

    async def un_watch_ticker(self, symbol: str, params={}):
        """
        unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
        :param str symbol: unified symbol of the market to fetch the ticker for
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `ticker structure <https://docs.ccxt.com/?id=ticker-structure>`
        """
        return await self.un_subscribe('ticker', 'ticker', symbol, params)

    def handle_my_trade(self, client: Client, message, subscription={}):
        #
        # trade execution
        # [
        #     0,
        #     "te",  # or tu
        #     [
        #        1133411090,
        #        "tLTCUST",
        #        1655110144598,
        #        97084883506,
        #        0.1,
        #        42.821,
        #        "EXCHANGE MARKET",
        #        42.799,
        #        -1,
        #        null,
        #        null,
        #        1655110144596
        #     ]
        # ]
        #
        name = 'myTrade'
        data = self.safe_value(message, 2)
        trade = self.parse_ws_trade(data)
        symbol = trade['symbol']
        market = self.market(symbol)
        messageHash = name + ':' + market['id']
        if self.myTrades is None:
            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
            self.myTrades = ArrayCacheBySymbolById(limit)
        tradesArray = self.myTrades
        tradesArray.append(trade)
        self.myTrades = tradesArray
        # generic subscription
        client.resolve(tradesArray, name)
        # specific subscription
        client.resolve(tradesArray, messageHash)

    def handle_trades(self, client: Client, message, subscription):
        #
        # initial snapshot
        #
        #    [
        #        188687,  # channel id
        #        [
        #          [1128060675, 1654701572690, 0.00217533, 1815.3],  # id, mts, amount, price
        #          [1128060665, 1654701551231, -0.00280472, 1814.1],
        #          [1128060664, 1654701550996, -0.00364444, 1814.1],
        #          [1128060656, 1654701527730, -0.00265203, 1814.2],
        #          [1128060647, 1654701505193, 0.00262395, 1815.2],
        #          [1128060642, 1654701484656, -0.13411443, 1816],
        #          [1128060641, 1654701484656, -0.00088557, 1816],
        #          [1128060639, 1654701478326, -0.002, 1816],
        #        ]
        #    ]
        # update
        #
        #    [
        #        360141,
        #        "te",
        #        [
        #            1128060969,  # id
        #            1654702500098,  # mts
        #            0.00325131,  # amount positive buy, negative sell
        #            1818.5,  # price
        #        ],
        #    ]
        #
        #
        channel = self.safe_value(subscription, 'channel')
        marketId = self.safe_string(subscription, 'symbol')
        market = self.safe_market(marketId)
        messageHash = channel + ':' + marketId
        tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
        symbol = market['symbol']
        stored = self.safe_value(self.trades, symbol)
        if stored is None:
            stored = ArrayCache(tradesLimit)
            self.trades[symbol] = stored
        messageLength = len(message)
        if messageLength == 2:
            # initial snapshot
            trades = self.safe_list(message, 1, [])
            # needs to be reversed to make chronological order
            length = len(trades)
            for i in range(0, length):
                index = length - i - 1
                parsed = self.parse_ws_trade(trades[index], market)
                stored.append(parsed)
        else:
            # update
            type = self.safe_string(message, 1)
            if type == 'tu':
                # don't resolve for a duplicate update
                # since te and tu updates are duplicated on the public stream
                return
            trade = self.safe_value(message, 2, [])
            parsed = self.parse_ws_trade(trade, market)
            stored.append(parsed)
        client.resolve(stored, messageHash)

    def parse_ws_trade(self, trade, market=None):
        #
        #    [
        #        1128060969,  # id
        #        1654702500098,  # mts
        #        0.00325131,  # amount positive buy, negative sell
        #        1818.5,  # price
        #    ]
        #
        # trade execution
        #
        #    [
        #        1133411090,  # id
        #        "tLTCUST",  # symbol
        #        1655110144598,  # create ms
        #        97084883506,  # order id
        #        0.1,  # amount
        #        42.821,  # price
        #        "EXCHANGE MARKET",  # order type
        #        42.799,  # order price
        #        -1,  # maker
        #        null,  # fee
        #        null,  # fee currency
        #        1655110144596  # cid
        #    ]
        #
        # trade update
        #
        #    [
        #       1133411090,
        #       "tLTCUST",
        #       1655110144598,
        #       97084883506,
        #       0.1,
        #       42.821,
        #       "EXCHANGE MARKET",
        #       42.799,
        #       -1,
        #       -0.0002,
        #       "LTC",
        #       1655110144596
        #    ]
        #
        numFields = len(trade)
        isPublic = numFields <= 8
        marketId = self.safe_string(trade, 1) if (not isPublic) else None
        market = self.safe_market(marketId, market)
        createdKey = 1 if isPublic else 2
        priceKey = 3 if isPublic else 5
        amountKey = 2 if isPublic else 4
        marketId = market['id']
        type = self.safe_string(trade, 6)
        if type is not None:
            if type.find('LIMIT') > -1:
                type = 'limit'
            elif type.find('MARKET') > -1:
                type = 'market'
        orderId = self.safe_string(trade, 3) if (not isPublic) else None
        id = self.safe_string(trade, 0)
        timestamp = self.safe_integer(trade, createdKey)
        price = self.safe_string(trade, priceKey)
        amountString = self.safe_string(trade, amountKey)
        amount = self.parse_number(Precise.string_abs(amountString))
        side = None
        if amount is not None:
            side = 'buy' if Precise.string_gt(amountString, '0') else 'sell'
        symbol = self.safe_symbol(marketId, market)
        feeValue = self.safe_string(trade, 9)
        fee = None
        if feeValue is not None:
            currencyId = self.safe_string(trade, 10)
            code = self.safe_currency_code(currencyId)
            fee = {
                'cost': feeValue,
                'currency': code,
            }
        maker = self.safe_integer(trade, 8)
        takerOrMaker = None
        if maker is not None:
            takerOrMaker = 'taker' if (maker == -1) else 'maker'
        return self.safe_trade({
            'info': trade,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'symbol': symbol,
            'id': id,
            'order': orderId,
            'type': type,
            'takerOrMaker': takerOrMaker,
            'side': side,
            'price': price,
            'amount': amount,
            'cost': None,
            'fee': fee,
        }, market)

    def handle_ticker(self, client: Client, message, subscription):
        #
        # [
        #    340432,  # channel ID
        #     [
        #         236.62,        # 1 BID float Price of last highest bid
        #         9.0029,        # 2 BID_SIZE float Size of the last highest bid
        #         236.88,        # 3 ASK float Price of last lowest ask
        #         7.1138,        # 4 ASK_SIZE float Size of the last lowest ask
        #         -1.02,         # 5 DAILY_CHANGE float Amount that the last price has changed since yesterday
        #         0,             # 6 DAILY_CHANGE_PERC float Amount that the price has changed expressed in percentage terms
        #         236.52,        # 7 LAST_PRICE float Price of the last trade.
        #         5191.36754297,  # 8 VOLUME float Daily volume
        #         250.01,        # 9 HIGH float Daily high
        #         220.05,        # 10 LOW float Daily low
        #     ]
        #  ]
        #
        ticker = self.safe_value(message, 1)
        marketId = self.safe_string(subscription, 'symbol')
        market = self.safe_market(marketId)
        symbol = self.safe_symbol(marketId)
        parsed = self.parse_ws_ticker(ticker, market)
        channel = 'ticker'
        messageHash = channel + ':' + marketId
        self.tickers[symbol] = parsed
        client.resolve(parsed, messageHash)

    def parse_ws_ticker(self, ticker, market=None):
        #
        #     [
        #         236.62,        # 1 BID float Price of last highest bid
        #         9.0029,        # 2 BID_SIZE float Size of the last highest bid
        #         236.88,        # 3 ASK float Price of last lowest ask
        #         7.1138,        # 4 ASK_SIZE float Size of the last lowest ask
        #         -1.02,         # 5 DAILY_CHANGE float Amount that the last price has changed since yesterday
        #         0,             # 6 DAILY_CHANGE_PERC float Amount that the price has changed expressed in percentage terms
        #         236.52,        # 7 LAST_PRICE float Price of the last trade.
        #         5191.36754297,  # 8 VOLUME float Daily volume
        #         250.01,        # 9 HIGH float Daily high
        #         220.05,        # 10 LOW float Daily low
        #     ]
        #
        market = self.safe_market(None, market)
        symbol = market['symbol']
        last = self.safe_string(ticker, 6)
        change = self.safe_string(ticker, 4)
        return self.safe_ticker({
            'symbol': symbol,
            'timestamp': None,
            'datetime': None,
            'high': self.safe_string(ticker, 8),
            'low': self.safe_string(ticker, 9),
            'bid': self.safe_string(ticker, 0),
            'bidVolume': self.safe_string(ticker, 1),
            'ask': self.safe_string(ticker, 2),
            'askVolume': self.safe_string(ticker, 3),
            'vwap': None,
            'open': None,
            'close': last,
            'last': last,
            'previousClose': None,
            'change': change,
            'percentage': self.safe_string(ticker, 5),
            'average': None,
            'baseVolume': self.safe_string(ticker, 7),
            'quoteVolume': None,
            'info': ticker,
        }, market)

    async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
        """
        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
        :param str symbol: unified symbol of the market to fetch the order book for
        :param int [limit]: the maximum amount of order book entries to return
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/?id=order-book-structure>` indexed by market symbols
        """
        if limit is not None:
            if (limit != 25) and (limit != 100):
                raise ExchangeError(self.id + ' watchOrderBook limit argument must be None, 25 or 100')
        options = self.safe_value(self.options, 'watchOrderBook', {})
        prec = self.safe_string(options, 'prec', 'P0')
        freq = self.safe_string(options, 'freq', 'F0')
        request: dict = {
            'prec': prec,  # string, level of price aggregation, 'P0', 'P1', 'P2', 'P3', 'P4', default P0
            'freq': freq,  # string, frequency of updates 'F0' = realtime, 'F1' = 2 seconds, default is 'F0'
        }
        if limit is not None:
            request['len'] = limit  # string, number of price points, '25', '100', default = '25'
        orderbook = await self.subscribe('book', symbol, self.deep_extend(request, params))
        return orderbook.limit()

    def handle_order_book(self, client: Client, message, subscription):
        #
        # first message(snapshot)
        #
        #     [
        #         18691,  # channel id
        #         [
        #             [7364.8, 10, 4.354802],  # price, count, size > 0 = bid
        #             [7364.7, 1, 0.00288831],
        #             [7364.3, 12, 0.048],
        #             [7364.9, 3, -0.42028976],  # price, count, size < 0 = ask
        #             [7365, 1, -0.25],
        #             [7365.5, 1, -0.00371937],
        #         ]
        #     ]
        #
        # subsequent updates
        #
        #     [
        #         358169,  # channel id
        #         [
        #            1807.1,  # price
        #            0,  # cound
        #            1  # size
        #         ]
        #     ]
        #
        marketId = self.safe_string(subscription, 'symbol')
        symbol = self.safe_symbol(marketId)
        channel = 'book'
        messageHash = channel + ':' + marketId
        prec = self.safe_string(subscription, 'prec', 'P0')
        isRaw = (prec == 'R0')
        # if it is an initial snapshot
        if not (symbol in self.orderbooks):
            limit = self.safe_integer(subscription, 'len')
            if isRaw:
                # raw order books
                self.orderbooks[symbol] = self.indexed_order_book({}, limit)
            else:
                # P0, P1, P2, P3, P4
                self.orderbooks[symbol] = self.counted_order_book({}, limit)
            orderbook = self.orderbooks[symbol]
            if isRaw:
                deltas = message[1]
                for i in range(0, len(deltas)):
                    delta = deltas[i]
                    delta2 = delta[2]
                    size = -delta2 if (delta2 < 0) else delta2
                    side = 'asks' if (delta2 < 0) else 'bids'
                    bookside = orderbook[side]
                    idString = self.safe_string(delta, 0)
                    price = self.safe_float(delta, 1)
                    bookside.storeArray([price, size, idString])
            else:
                deltas = message[1]
                for i in range(0, len(deltas)):
                    delta = deltas[i]
                    amount = self.safe_number(delta, 2)
                    counter = self.safe_number(delta, 1)
                    price = self.safe_number(delta, 0)
                    size = -amount if (amount < 0) else amount
                    side = 'asks' if (amount < 0) else 'bids'
                    bookside = orderbook[side]
                    bookside.storeArray([price, size, counter])
            orderbook['symbol'] = symbol
            client.resolve(orderbook, messageHash)
        else:
            orderbook = self.orderbooks[symbol]
            deltas = message[1]
            orderbookItem = self.orderbooks[symbol]
            if isRaw:
                price = self.safe_string(deltas, 1)
                deltas2 = deltas[2]
                size = -deltas2 if (deltas2 < 0) else deltas2
                side = 'asks' if (deltas2 < 0) else 'bids'
                bookside = orderbookItem[side]
                # price = 0 means that you have to remove the order from your book
                amount = size if Precise.string_gt(price, '0') else '0'
                idString = self.safe_string(deltas, 0)
                bookside.storeArray([self.parse_number(price), self.parse_number(amount), idString])
            else:
                amount = self.safe_string(deltas, 2)
                counter = self.safe_string(deltas, 1)
                price = self.safe_string(deltas, 0)
                size = Precise.string_neg(amount) if Precise.string_lt(amount, '0') else amount
                side = 'asks' if Precise.string_lt(amount, '0') else 'bids'
                bookside = orderbookItem[side]
                bookside.storeArray([self.parse_number(price), self.parse_number(size), self.parse_number(counter)])
            client.resolve(orderbook, messageHash)

    def handle_checksum(self, client: Client, message, subscription):
        #
        # [173904, "cs", -890884919]
        #
        marketId = self.safe_string(subscription, 'symbol')
        symbol = self.safe_symbol(marketId)
        channel = 'book'
        messageHash = channel + ':' + marketId
        book = self.safe_value(self.orderbooks, symbol)
        if book is None:
            return
        depth = 25  # covers the first 25 bids and asks
        stringArray = []
        bids = book['bids']
        asks = book['asks']
        prec = self.safe_string(subscription, 'prec', 'P0')
        isRaw = (prec == 'R0')
        idToCheck = 2 if isRaw else 0
        # pepperoni pizza from bitfinex
        for i in range(0, depth):
            bid = self.safe_value(bids, i)
            ask = self.safe_value(asks, i)
            if bid is not None:
                stringArray.append(self.number_to_string(bids[i][idToCheck]))
                stringArray.append(self.number_to_string(bids[i][1]))
            if ask is not None:
                stringArray.append(self.number_to_string(asks[i][idToCheck]))
                aski1 = asks[i][1]
                stringArray.append(self.number_to_string(-aski1))
        payload = ':'.join(stringArray)
        localChecksum = self.crc32(payload, True)
        responseChecksum = self.safe_integer(message, 2)
        if responseChecksum != localChecksum:
            del client.subscriptions[messageHash]
            del self.orderbooks[symbol]
            checksum = self.handle_option('watchOrderBook', 'checksum', True)
            if checksum:
                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
                client.reject(error, messageHash)

    async def watch_balance(self, params={}) -> Balances:
        """
        watch balance and get the amount of funds available for trading or funds locked in orders
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param str [params.type]: spot or contract if not provided self.options['defaultType'] is used
        :returns dict: a `balance structure <https://docs.ccxt.com/?id=balance-structure>`
        """
        await self.load_markets()
        balanceType = self.safe_string(params, 'wallet', 'exchange')  # exchange, margin
        params = self.omit(params, 'wallet')
        messageHash = 'balance:' + balanceType
        return await self.subscribe_private(messageHash)

    def handle_balance(self, client: Client, message, subscription):
        #
        # snapshot(exchange + margin together)
        #   [
        #       0,
        #       "ws",
        #       [
        #           [
        #               "exchange",
        #               "LTC",
        #               0.05479727,
        #               0,
        #               null,
        #               "Trading fees for 0.05 LTC(LTCUST) @ 51.872 on BFX(0.2%)",
        #               null,
        #           ]
        #           [
        #               "margin",
        #               "USTF0",
        #               11.960650700086292,
        #               0,
        #               null,
        #               "Trading fees for 0.1 LTCF0(LTCF0:USTF0) @ 51.844 on BFX(0.065%)",
        #               null,
        #           ],
        #       ],
        #   ]
        #
        # spot
        #   [
        #       0,
        #       "wu",
        #       [
        #         "exchange",
        #         "LTC",  # currency
        #         0.06729727,  # wallet balance
        #         0,  # unsettled balance
        #         0.06729727,  # available balance might be null
        #         "Exchange 0.4 LTC for UST @ 65.075",
        #         {
        #           "reason": "TRADE",
        #           "order_id": 96596397973,
        #           "order_id_oppo": 96596632735,
        #           "trade_price": "65.075",
        #           "trade_amount": "-0.4",
        #           "order_cid": 1654636218766,
        #           "order_gid": null
        #         }
        #       ]
        #   ]
        #
        # margin
        #
        #   [
        #       "margin",
        #       "USTF0",
        #       11.960650700086292,  # total
        #       0,
        #       6.776250700086292,  # available
        #       "Trading fees for 0.1 LTCF0(LTCF0:USTF0) @ 51.844 on BFX(0.065%)",
        #       null
        #   ]
        #
        updateType = self.safe_value(message, 1)
        data = None
        if updateType == 'ws':
            data = self.safe_value(message, 2)
        else:
            data = [self.safe_value(message, 2)]
        updatedTypes: dict = {}
        for i in range(0, len(data)):
            rawBalance = data[i]
            currencyId = self.safe_string(rawBalance, 1)
            code = self.safe_currency_code(currencyId)
            balance = self.parse_ws_balance(rawBalance)
            balanceType = self.safe_string(rawBalance, 0)
            oldBalance = self.safe_value(self.balance, balanceType, {})
            oldBalance[code] = balance
            oldBalance['info'] = message
            self.balance[balanceType] = self.safe_balance(oldBalance)
            updatedTypes[balanceType] = True
        updatesKeys = list(updatedTypes.keys())
        for i in range(0, len(updatesKeys)):
            type = updatesKeys[i]
            messageHash = 'balance:' + type
            client.resolve(self.balance[type], messageHash)

    def parse_ws_balance(self, balance):
        #
        #     [
        #         "exchange",
        #         "LTC",
        #         0.05479727,  # balance
        #         0,
        #         null,  # available null if not calculated yet
        #         "Trading fees for 0.05 LTC(LTCUST) @ 51.872 on BFX(0.2%)",
        #         null,
        #     ]
        #
        totalBalance = self.safe_string(balance, 2)
        availableBalance = self.safe_string(balance, 4)
        account = self.account()
        if availableBalance is not None:
            account['free'] = availableBalance
        account['total'] = totalBalance
        return account

    def handle_system_status(self, client: Client, message):
        #
        #     {
        #         "event": "info",
        #         "version": 2,
        #         "serverId": "e293377e-7bb7-427e-b28c-5db045b2c1d1",
        #         "platform": {status: 1},  # 1 for operative, 0 for maintenance
        #     }
        #
        return message

    def handle_unsubscription_status(self, client: Client, message):
        #
        # {
        #     "event": "unsubscribed",
        #     "status": "OK",
        #     "chanId": CHANNEL_ID
        # }
        #
        channelId = self.safe_string(message, 'chanId')
        unSubChannel = 'unsubscribe:' + channelId
        subMessageHash = self.safe_string(client.subscriptions, unSubChannel)
        subscription = self.safe_dict(client.subscriptions, 'unsubscribe:' + subMessageHash)
        del client.subscriptions[unSubChannel]
        messageHashes = self.safe_list(subscription, 'messageHashes', [])
        subMessageHashes = self.safe_list(subscription, 'subMessageHashes', [])
        for i in range(0, len(messageHashes)):
            messageHash = messageHashes[i]
            subHash = subMessageHashes[i]
            self.clean_unsubscription(client, subHash, messageHash)
        self.clean_cache(subscription)
        return True

    def handle_subscription_status(self, client: Client, message):
        #
        #     {
        #         "event": "subscribed",
        #         "channel": "book",
        #         "chanId": 67473,
        #         "symbol": "tBTCUSD",
        #         "prec": "P0",
        #         "freq": "F0",
        #         "len": "25",
        #         "pair": "BTCUSD"
        #     }
        #
        #   {
        #       event: 'subscribed',
        #       channel: 'candles',
        #       chanId: 128306,
        #       key: 'trade:1m:tBTCUST'
        #  }
        #
        channelId = self.safe_string(message, 'chanId')
        client.subscriptions[channelId] = message
        # store the opposite direction too for unWatch
        mappings: dict = {
            'book': 'orderbook',
            'candles': 'ohlcv',
            'ticker': 'ticker',
            'trades': 'trades',
        }
        unifiedChannel = self.safe_string(mappings, self.safe_string(message, 'channel'))
        if 'key' in message:
            # handle ohlcv differently because the message is different
            key = self.safe_string(message, 'key')
            subKeyId = 'unsubscribe:' + key
            client.subscriptions[subKeyId] = channelId
        else:
            marketId = self.safe_string(message, 'symbol')
            symbol = self.safe_symbol(marketId)
            if unifiedChannel is not None:
                subId = 'unsubscribe:' + unifiedChannel + ':' + symbol
                client.subscriptions[subId] = channelId
        return message

    async def authenticate(self, params={}):
        url = self.urls['api']['ws']['private']
        client = self.client(url)
        messageHash = 'authenticated'
        future = client.reusableFuture(messageHash)
        authenticated = self.safe_value(client.subscriptions, messageHash)
        if authenticated is None:
            nonce = self.milliseconds()
            payload = 'AUTH' + str(nonce)
            signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha384, 'hex')
            event = 'auth'
            request: dict = {
                'apiKey': self.apiKey,
                'authSig': signature,
                'authNonce': nonce,
                'authPayload': payload,
                'event': event,
            }
            message = self.extend(request, params)
            self.watch(url, messageHash, message, messageHash)
        return await future

    def handle_authentication_message(self, client: Client, message):
        messageHash = 'authenticated'
        status = self.safe_string(message, 'status')
        if status == 'OK':
            # we resolve the future here permanently so authentication only happens once
            future = self.safe_value(client.futures, messageHash)
            future.resolve(True)
        else:
            error = AuthenticationError(self.json(message))
            client.reject(error, messageHash)
            # allows further authentication attempts
            if messageHash in client.subscriptions:
                del client.subscriptions[messageHash]

    async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
        """
        watches information on multiple orders made by the user
        :param str 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
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `order structures <https://docs.ccxt.com/?id=order-structure>`
        """
        await self.load_markets()
        messageHash = 'orders'
        if symbol is not None:
            market = self.market(symbol)
            messageHash += ':' + market['id']
        orders = await self.subscribe_private(messageHash)
        if self.newUpdates:
            limit = orders.getLimit(symbol, limit)
        return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)

    def handle_orders(self, client: Client, message, subscription):
        #
        # limit order
        #    [
        #        0,
        #        "on",  # ou or oc
        #        [
        #           96923856256,  # order id
        #           null,  # gid
        #           1655029337026,  # cid
        #           "tLTCUST",  # symbol
        #           1655029337027,  # created timestamp
        #           1655029337029,  # updated timestamp
        #           0.1,  # amount
        #           0.1,  # amount_orig
        #           "EXCHANGE LIMIT",  # order type
        #           null,  # type_prev
        #           null,  # mts_tif
        #           null,  # placeholder
        #           0,  # flags
        #           "ACTIVE",  # status
        #           null,
        #           null,
        #           30,  # price
        #           0,  # price average
        #           0,  # price_trailling
        #           0,  # price_aux_limit
        #           null,
        #           null,
        #           null,
        #           0,  # notify
        #           0,
        #           null,
        #           null,
        #           null,
        #           "BFX",
        #           null,
        #           null,
        #        ]
        #    ]
        #
        data = self.safe_value(message, 2, [])
        messageType = self.safe_string(message, 1)
        if self.orders is None:
            limit = self.safe_integer(self.options, 'ordersLimit', 1000)
            self.orders = ArrayCacheBySymbolById(limit)
        orders = self.orders
        symbolIds: dict = {}
        if messageType == 'os':
            snapshotLength = len(data)
            if snapshotLength == 0:
                return
            for i in range(0, len(data)):
                value = data[i]
                parsed = self.parse_ws_order(value)
                symbol = parsed['symbol']
                symbolIds[symbol] = True
                orders.append(parsed)
        else:
            parsed = self.parse_ws_order(data)
            orders.append(parsed)
            symbol = parsed['symbol']
            symbolIds[symbol] = True
        name = 'orders'
        client.resolve(self.orders, name)
        keys = list(symbolIds.keys())
        for i in range(0, len(keys)):
            symbol = keys[i]
            market = self.market(symbol)
            messageHash = name + ':' + market['id']
            client.resolve(self.orders, messageHash)

    def parse_ws_order_status(self, status):
        statuses: dict = {
            'ACTIVE': 'open',
            'CANCELED': 'canceled',
            'EXECUTED': 'closed',
            'PARTIALLY': 'open',
        }
        return self.safe_string(statuses, status, status)

    def parse_ws_order(self, order, market=None):
        #
        #   [
        #       97084883506,  # order id
        #       null,
        #       1655110144596,  # clientOrderId
        #       "tLTCUST",  # symbol
        #       1655110144596,  # created timestamp
        #       1655110144598,  # updated timestamp
        #       0,  # amount
        #       0.1,  # amount_orig negative if sell order
        #       "EXCHANGE MARKET",  # type
        #       null,
        #       null,
        #       null,
        #       0,
        #       "EXECUTED @ 42.821(0.1)",  # status
        #       null,
        #       null,
        #       42.799,  # price
        #       42.821,  # price average
        #       0,  # price trailling
        #       0,  # price_aux_limit
        #       null,
        #       null,
        #       null,
        #       0,
        #       0,
        #       null,
        #       null,
        #       null,
        #       "BFX",
        #       null,
        #       null,
        #       {}
        #   ]
        #
        id = self.safe_string(order, 0)
        clientOrderId = self.safe_string(order, 1)
        marketId = self.safe_string(order, 3)
        symbol = self.safe_symbol(marketId)
        market = self.safe_market(symbol)
        amount = self.safe_string(order, 7)
        side = 'buy'
        if Precise.string_lt(amount, '0'):
            amount = Precise.string_abs(amount)
            side = 'sell'
        remaining = Precise.string_abs(self.safe_string(order, 6))
        type = self.safe_string(order, 8)
        if type.find('LIMIT') > -1:
            type = 'limit'
        elif type.find('MARKET') > -1:
            type = 'market'
        rawState = self.safe_string(order, 13)
        stateParts = rawState.split(' ')
        trimmedStatus = self.safe_string(stateParts, 0)
        status = self.parse_ws_order_status(trimmedStatus)
        price = self.safe_string(order, 16)
        timestamp = self.safe_integer_2(order, 5, 4)
        average = self.safe_string(order, 17)
        stopPrice = self.omit_zero(self.safe_string(order, 18))
        return self.safe_order({
            'info': order,
            'id': id,
            'clientOrderId': clientOrderId,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'lastTradeTimestamp': None,
            'symbol': symbol,
            'type': type,
            'side': side,
            'price': price,
            'stopPrice': stopPrice,
            'triggerPrice': stopPrice,
            'average': average,
            'amount': amount,
            'remaining': remaining,
            'filled': None,
            'status': status,
            'fee': None,
            'cost': None,
            'trades': None,
        }, market)

    def handle_message(self, client: Client, message):
        channelId = self.safe_string(message, 0)
        #
        #     [
        #         1231,
        #         "hb",
        #     ]
        #
        # auth message
        #    {
        #        "event": "auth",
        #        "status": "OK",
        #        "chanId": 0,
        #        "userId": 3159883,
        #        "auth_id": "ac7108e7-2f26-424d-9982-c24700dc02ca",
        #        "caps": {
        #          "orders": {read: 1, write: 1},
        #          "account": {read: 1, write: 1},
        #          "funding": {read: 1, write: 1},
        #          "history": {read: 1, write: 0},
        #          "wallets": {read: 1, write: 1},
        #          "withdraw": {read: 0, write: 1},
        #          "positions": {read: 1, write: 1},
        #          "ui_withdraw": {read: 0, write: 0}
        #        }
        #    }
        #
        if isinstance(message, list):
            if message[1] == 'hb':
                return  # skip heartbeats within subscription channels for now
            subscription = self.safe_value(client.subscriptions, channelId, {})
            channel = self.safe_string(subscription, 'channel')
            name = self.safe_string(message, 1)
            publicMethods: dict = {
                'book': self.handle_order_book,
                'cs': self.handle_checksum,
                'candles': self.handle_ohlcv,
                'ticker': self.handle_ticker,
                'trades': self.handle_trades,
            }
            privateMethods: dict = {
                'os': self.handle_orders,
                'ou': self.handle_orders,
                'on': self.handle_orders,
                'oc': self.handle_orders,
                'wu': self.handle_balance,
                'ws': self.handle_balance,
                'tu': self.handle_my_trade,
            }
            method = None
            if channelId == '0':
                method = self.safe_value(privateMethods, name)
            else:
                method = self.safe_value_2(publicMethods, name, channel)
            if method is not None:
                method(client, message, subscription)
        else:
            event = self.safe_string(message, 'event')
            if event is not None:
                methods: dict = {
                    'info': self.handle_system_status,
                    'subscribed': self.handle_subscription_status,
                    'unsubscribed': self.handle_unsubscription_status,
                    'auth': self.handle_authentication_message,
                }
                method = self.safe_value(methods, event)
                if method is not None:
                    method(client, message)
