ccxt-ir 4.3.46.0.2__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/pro/kraken.py

@@ -5,13 +5,14 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-from ccxt.base.types import Int, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Balances, Bool, Int, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, 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 PermissionDenied
 from ccxt.base.errors import AccountSuspended
+from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import InsufficientFunds
@@ -20,17 +21,17 @@ from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 from ccxt.base.precise import Precise
 
 
 class kraken(ccxt.async_support.kraken):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(kraken, self).describe(), {
             'has': {
                 'ws': True,
-                'watchBalance': False,  # no such type of subscription 2021-01-05
+                'watchBalance': True,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOrderBook': True,
@@ -38,6 +39,7 @@ class kraken(ccxt.async_support.kraken):
                 'watchOrders': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
                 'createOrderWs': True,
@@ -53,6 +55,8 @@ class kraken(ccxt.async_support.kraken):
                     'ws': {
                         'public': 'wss://ws.kraken.com',
                         'private': 'wss://ws-auth.kraken.com',
+                        'privateV2': 'wss://ws-auth.kraken.com/v2',
+                        'publicV2': 'wss://ws.kraken.com/v2',
                         'beta': 'wss://beta-ws.kraken.com',
                         'beta-private': 'wss://beta-ws-auth.kraken.com',
                     },
@@ -66,7 +70,13 @@ class kraken(ccxt.async_support.kraken):
                 'OHLCVLimit': 1000,
                 'ordersLimit': 1000,
                 'symbolsByOrderId': {},
-                'checksum': True,
+                'watchOrderBook': {
+                    'checksum': False,
+                },
+            },
+            'streaming': {
+                'ping': self.ping,
+                'keepAlive': 6000,
             },
             'exceptions': {
                 'ws': {
@@ -76,6 +86,7 @@ class kraken(ccxt.async_support.kraken):
                     'broad': {
                         'Already subscribed': BadRequest,
                         'Currency pair not in ISO 4217-A3 format': BadSymbol,
+                        'Currency pair not supported': BadSymbol,
                         'Malformed request': BadRequest,
                         'Pair field must be an array': BadRequest,
                         'Pair field unsupported for self subscription type': BadRequest,
@@ -118,159 +129,310 @@ class kraken(ccxt.async_support.kraken):
                         'EService:Market in post_only mode': NotSupported,
                         'EService:Unavailable': ExchangeNotAvailable,
                         'ETrade:Invalid request': BadRequest,
+                        'ESession:Invalid session': AuthenticationError,
                     },
                 },
             },
         })
 
+    def order_request_ws(self, method: str, symbol: str, type: str, request: dict, amount: Num, price: Num = None, params={}):
+        isLimitOrder = type.endswith('limit')  # supporting limit, stop-loss-limit, take-profit-limit, etc
+        if isLimitOrder:
+            if price is None:
+                raise ArgumentsRequired(self.id + ' limit orders require a price argument')
+            request['params']['limit_price'] = self.parse_to_numeric(self.price_to_precision(symbol, price))
+        isMarket = (type == 'market')
+        postOnly = None
+        postOnly, params = self.handle_post_only(isMarket, False, params)
+        if postOnly:
+            request['params']['post_only'] = True
+        clientOrderId = self.safe_string(params, 'clientOrderId')
+        if clientOrderId is not None:
+            request['params']['cl_ord_id'] = clientOrderId
+        cost = self.safe_string(params, 'cost')
+        if cost is not None:
+            request['params']['order_qty'] = self.parse_to_numeric(self.cost_to_precision(symbol, cost))
+        stopLoss = self.safe_dict(params, 'stopLoss', {})
+        takeProfit = self.safe_dict(params, 'takeProfit', {})
+        presetStopLoss = self.safe_string(stopLoss, 'triggerPrice')
+        presetTakeProfit = self.safe_string(takeProfit, 'triggerPrice')
+        presetStopLossLimit = self.safe_string(stopLoss, 'price')
+        presetTakeProfitLimit = self.safe_string(takeProfit, 'price')
+        isPresetStopLoss = presetStopLoss is not None
+        isPresetTakeProfit = presetTakeProfit is not None
+        stopLossPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
+        isStopLossPriceOrder = stopLossPrice is not None
+        isTakeProfitPriceOrder = takeProfitPrice is not None
+        trailingAmount = self.safe_string(params, 'trailingAmount')
+        trailingPercent = self.safe_string(params, 'trailingPercent')
+        trailingLimitAmount = self.safe_string(params, 'trailingLimitAmount')
+        trailingLimitPercent = self.safe_string(params, 'trailingLimitPercent')
+        isTrailingAmountOrder = trailingAmount is not None
+        isTrailingPercentOrder = trailingPercent is not None
+        isTrailingLimitAmountOrder = trailingLimitAmount is not None
+        isTrailingLimitPercentOrder = trailingLimitPercent is not None
+        offset = self.safe_string(params, 'offset', '')  # can set self to - for minus
+        trailingAmountString = offset + self.number_to_string(trailingAmount) if (trailingAmount is not None) else None
+        trailingPercentString = offset + self.number_to_string(trailingPercent) if (trailingPercent is not None) else None
+        trailingLimitAmountString = offset + self.number_to_string(trailingLimitAmount) if (trailingLimitAmount is not None) else None
+        trailingLimitPercentString = offset + self.number_to_string(trailingLimitPercent) if (trailingLimitPercent is not None) else None
+        priceType = 'pct' if (isTrailingPercentOrder or isTrailingLimitPercentOrder) else 'quote'
+        if method == 'createOrderWs':
+            reduceOnly = self.safe_bool(params, 'reduceOnly')
+            if reduceOnly:
+                request['params']['reduce_only'] = True
+            timeInForce = self.safe_string_lower(params, 'timeInForce')
+            if timeInForce is not None:
+                request['params']['time_in_force'] = timeInForce
+            params = self.omit(params, ['reduceOnly', 'timeInForce'])
+            if isStopLossPriceOrder or isTakeProfitPriceOrder or isTrailingAmountOrder or isTrailingPercentOrder or isTrailingLimitAmountOrder or isTrailingLimitPercentOrder:
+                request['params']['triggers'] = {}
+            if isPresetStopLoss or isPresetTakeProfit:
+                request['params']['conditional'] = {}
+                if isPresetStopLoss:
+                    request['params']['conditional']['order_type'] = 'stop-loss'
+                    request['params']['conditional']['trigger_price'] = self.parse_to_numeric(self.price_to_precision(symbol, presetStopLoss))
+                elif isPresetTakeProfit:
+                    request['params']['conditional']['order_type'] = 'take-profit'
+                    request['params']['conditional']['trigger_price'] = self.parse_to_numeric(self.price_to_precision(symbol, presetTakeProfit))
+                if presetStopLossLimit is not None:
+                    request['params']['conditional']['order_type'] = 'stop-loss-limit'
+                    request['params']['conditional']['limit_price'] = self.parse_to_numeric(self.price_to_precision(symbol, presetStopLossLimit))
+                elif presetTakeProfitLimit is not None:
+                    request['params']['conditional']['order_type'] = 'take-profit-limit'
+                    request['params']['conditional']['limit_price'] = self.parse_to_numeric(self.price_to_precision(symbol, presetTakeProfitLimit))
+                params = self.omit(params, ['stopLoss', 'takeProfit'])
+            elif isStopLossPriceOrder or isTakeProfitPriceOrder:
+                if isStopLossPriceOrder:
+                    request['params']['triggers']['price'] = self.parse_to_numeric(self.price_to_precision(symbol, stopLossPrice))
+                    if isLimitOrder:
+                        request['params']['order_type'] = 'stop-loss-limit'
+                    else:
+                        request['params']['order_type'] = 'stop-loss'
+                else:
+                    request['params']['triggers']['price'] = self.parse_to_numeric(self.price_to_precision(symbol, takeProfitPrice))
+                    if isLimitOrder:
+                        request['params']['order_type'] = 'take-profit-limit'
+                    else:
+                        request['params']['order_type'] = 'take-profit'
+            elif isTrailingAmountOrder or isTrailingPercentOrder or isTrailingLimitAmountOrder or isTrailingLimitPercentOrder:
+                request['params']['triggers']['price_type'] = priceType
+                if not isLimitOrder and (isTrailingAmountOrder or isTrailingPercentOrder):
+                    request['params']['order_type'] = 'trailing-stop'
+                    if isTrailingAmountOrder:
+                        request['params']['triggers']['price'] = self.parse_to_numeric(trailingAmountString)
+                    else:
+                        request['params']['triggers']['price'] = self.parse_to_numeric(trailingPercentString)
+                else:
+                    # trailing limit orders are not conventionally supported because the static limit_price_type param is not available for trailing-stop-limit orders
+                    request['params']['limit_price_type'] = priceType
+                    request['params']['order_type'] = 'trailing-stop-limit'
+                    if isTrailingLimitAmountOrder:
+                        request['params']['triggers']['price'] = self.parse_to_numeric(trailingLimitAmountString)
+                    else:
+                        request['params']['triggers']['price'] = self.parse_to_numeric(trailingLimitPercentString)
+        elif method == 'editOrderWs':
+            if isPresetStopLoss or isPresetTakeProfit:
+                raise NotSupported(self.id + ' editing the stopLoss and takeProfit on existing orders is currently not supported')
+            if isStopLossPriceOrder or isTakeProfitPriceOrder:
+                if isStopLossPriceOrder:
+                    request['params']['trigger_price'] = self.parse_to_numeric(self.price_to_precision(symbol, stopLossPrice))
+                else:
+                    request['params']['trigger_price'] = self.parse_to_numeric(self.price_to_precision(symbol, takeProfitPrice))
+            elif isTrailingAmountOrder or isTrailingPercentOrder or isTrailingLimitAmountOrder or isTrailingLimitPercentOrder:
+                request['params']['trigger_price_type'] = priceType
+                if not isLimitOrder and (isTrailingAmountOrder or isTrailingPercentOrder):
+                    if isTrailingAmountOrder:
+                        request['params']['trigger_price'] = self.parse_to_numeric(trailingAmountString)
+                    else:
+                        request['params']['trigger_price'] = self.parse_to_numeric(trailingPercentString)
+                else:
+                    request['params']['limit_price_type'] = priceType
+                    if isTrailingLimitAmountOrder:
+                        request['params']['trigger_price'] = self.parse_to_numeric(trailingLimitAmountString)
+                    else:
+                        request['params']['trigger_price'] = self.parse_to_numeric(trailingLimitPercentString)
+        params = self.omit(params, ['clientOrderId', 'cost', 'offset', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingLimitAmount', 'trailingLimitPercent'])
+        return [request, params]
+
     async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
         """
-        :see: https://docs.kraken.com/websockets/#message-addOrder
         create a trade order
+
+        https://docs.kraken.com/api/docs/websocket-v2/add_order
+
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
-        :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
         token = await self.authenticate()
         market = self.market(symbol)
-        url = self.urls['api']['ws']['private']
+        url = self.urls['api']['ws']['privateV2']
         requestId = self.request_id()
         messageHash = requestId
         request: dict = {
-            'event': 'addOrder',
-            'token': token,
-            'reqid': requestId,
-            'ordertype': type,
-            'type': side,
-            'pair': market['wsId'],
-            'volume': self.amount_to_precision(symbol, amount),
+            'method': 'add_order',
+            'params': {
+                'order_type': type,
+                'side': side,
+                'order_qty': self.parse_to_numeric(self.amount_to_precision(symbol, amount)),
+                'symbol': market['symbol'],
+                'token': token,
+            },
+            'req_id': requestId,
         }
-        request, params = self.orderRequest('createOrderWs', symbol, type, request, amount, price, params)
+        request, params = self.order_request_ws('createOrderWs', symbol, type, request, amount, price, params)
         return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
     def handle_create_edit_order(self, client, message):
         #
         #  createOrder
-        #    {
-        #        "descr": "sell 0.00010000 XBTUSDT @ market",
-        #        "event": "addOrderStatus",
-        #        "reqid": 1,
-        #        "status": "ok",
-        #        "txid": "OAVXZH-XIE54-JCYYDG"
-        #    }
+        #     {
+        #         "method": "add_order",
+        #         "req_id": 1,
+        #         "result": {
+        #             "order_id": "OXM2QD-EALR2-YBAVEU"
+        #         },
+        #         "success": True,
+        #         "time_in": "2025-05-13T10:12:13.876173Z",
+        #         "time_out": "2025-05-13T10:12:13.890137Z"
+        #     }
+        #
         #  editOrder
-        #    {
-        #        "descr": "order edited price = 9000.00000000",
-        #        "event": "editOrderStatus",
-        #        "originaltxid": "O65KZW-J4AW3-VFS74A",
-        #        "reqid": 3,
-        #        "status": "ok",
-        #        "txid": "OTI672-HJFAO-XOIPPK"
-        #    }
+        #     {
+        #         "method": "amend_order",
+        #         "req_id": 1,
+        #         "result": {
+        #             "amend_id": "TYDLSQ-OYNYU-3MNRER",
+        #             "order_id": "OGL7HR-SWFO4-NRQTHO"
+        #         },
+        #         "success": True,
+        #         "time_in": "2025-05-14T13:54:10.840342Z",
+        #         "time_out": "2025-05-14T13:54:10.855046Z"
+        #     }
         #
-        order = self.parse_order(message)
-        messageHash = self.safe_value(message, 'reqid')
+        result = self.safe_dict(message, 'result', {})
+        order = self.parse_order(result)
+        messageHash = self.safe_value_2(message, 'reqid', 'req_id')
         client.resolve(order, messageHash)
 
     async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}) -> Order:
         """
         edit a trade order
-        :see: https://docs.kraken.com/websockets/#message-editOrder
+
+        https://docs.kraken.com/api/docs/websocket-v2/amend_order
+
         :param str id: order id
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
         token = await self.authenticate()
-        market = self.market(symbol)
-        url = self.urls['api']['ws']['private']
+        url = self.urls['api']['ws']['privateV2']
         requestId = self.request_id()
         messageHash = requestId
         request: dict = {
-            'event': 'editOrder',
-            'token': token,
-            'reqid': requestId,
-            'orderid': id,
-            'pair': market['wsId'],
+            'method': 'amend_order',
+            'params': {
+                'order_id': id,
+                'order_qty': self.parse_to_numeric(self.amount_to_precision(symbol, amount)),
+                'token': token,
+            },
+            'req_id': requestId,
         }
-        if amount is not None:
-            request['volume'] = self.amount_to_precision(symbol, amount)
-        request, params = self.orderRequest('editOrderWs', symbol, type, request, amount, price, params)
+        request, params = self.order_request_ws('editOrderWs', symbol, type, request, amount, price, params)
         return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
     async def cancel_orders_ws(self, ids: List[str], symbol: Str = None, params={}):
         """
-        :see: https://docs.kraken.com/websockets/#message-cancelOrder
         cancel multiple orders
+
+        https://docs.kraken.com/api/docs/websocket-v2/cancel_order
+
         :param str[] ids: order ids
-        :param str symbol: unified market symbol, default is None
+        :param str [symbol]: unified market symbol, default is None
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
+        if symbol is not None:
+            raise NotSupported(self.id + ' cancelOrdersWs() does not support cancelling orders for a specific symbol.')
         await self.load_markets()
         token = await self.authenticate()
-        url = self.urls['api']['ws']['private']
+        url = self.urls['api']['ws']['privateV2']
         requestId = self.request_id()
         messageHash = requestId
         request: dict = {
-            'event': 'cancelOrder',
-            'token': token,
-            'reqid': requestId,
-            'txid': ids,
+            'method': 'cancel_order',
+            'params': {
+                'order_id': ids,
+                'token': token,
+            },
+            'req_id': requestId,
         }
         return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
     async def cancel_order_ws(self, id: str, symbol: Str = None, params={}) -> Order:
         """
-        :see: https://docs.kraken.com/websockets/#message-cancelOrder
         cancels an open order
+
+        https://docs.kraken.com/api/docs/websocket-v2/cancel_order
+
         :param str id: order id
-        :param str symbol: unified symbol of the market the order was made in
+        :param str [symbol]: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
+        if symbol is not None:
+            raise NotSupported(self.id + ' cancelOrderWs() does not support cancelling orders for a specific symbol.')
         await self.load_markets()
         token = await self.authenticate()
-        url = self.urls['api']['ws']['private']
+        url = self.urls['api']['ws']['privateV2']
         requestId = self.request_id()
         messageHash = requestId
-        clientOrderId = self.safe_value_2(params, 'userref', 'clientOrderId', id)
-        params = self.omit(params, ['userref', 'clientOrderId'])
         request: dict = {
-            'event': 'cancelOrder',
-            'token': token,
-            'reqid': requestId,
-            'txid': [clientOrderId],
+            'method': 'cancel_order',
+            'params': {
+                'order_id': [id],
+                'token': token,
+            },
+            'req_id': requestId,
         }
         return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
     def handle_cancel_order(self, client, message):
         #
-        #  success
-        #    {
-        #        "event": "cancelOrderStatus",
-        #        "status": "ok"
-        #        "reqid": 1,
-        #    }
+        #     {
+        #         "method": "cancel_order",
+        #         "req_id": 123456789,
+        #         "result": {
+        #             "order_id": "OKAGJC-YHIWK-WIOZWG"
+        #         },
+        #         "success": True,
+        #         "time_in": "2023-09-21T14:36:57.428972Z",
+        #         "time_out": "2023-09-21T14:36:57.437952Z"
+        #     }
         #
-        reqId = self.safe_value(message, 'reqid')
+        reqId = self.safe_value(message, 'req_id')
         client.resolve(message, reqId)
 
     async def cancel_all_orders_ws(self, symbol: Str = None, params={}):
         """
-        :see: https://docs.kraken.com/websockets/#message-cancelAll
         cancel all open orders
-        :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
+
+        https://docs.kraken.com/api/docs/websocket-v2/cancel_all
+
+        :param str [symbol]: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
         :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>`
         """
@@ -278,75 +440,84 @@ class kraken(ccxt.async_support.kraken):
             raise NotSupported(self.id + ' cancelAllOrdersWs() does not support cancelling orders in a specific market.')
         await self.load_markets()
         token = await self.authenticate()
-        url = self.urls['api']['ws']['private']
+        url = self.urls['api']['ws']['privateV2']
         requestId = self.request_id()
         messageHash = requestId
         request: dict = {
-            'event': 'cancelAll',
-            'token': token,
-            'reqid': requestId,
+            'method': 'cancel_all',
+            'params': {
+                'token': token,
+            },
+            'req_id': requestId,
         }
         return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
     def handle_cancel_all_orders(self, client, message):
         #
-        #    {
-        #        "count": 2,
-        #        "event": "cancelAllStatus",
-        #        "status": "ok",
-        #        "reqId": 1
-        #    }
+        #     {
+        #         "method": "cancel_all",
+        #         "req_id": 123456789,
+        #         "result": {
+        #             "count": 1
+        #         },
+        #         "success": True,
+        #         "time_in": "2023-09-21T14:36:57.428972Z",
+        #         "time_out": "2023-09-21T14:36:57.437952Z"
+        #     }
         #
-        reqId = self.safe_value(message, 'reqid')
+        reqId = self.safe_value(message, 'req_id')
         client.resolve(message, reqId)
 
-    def handle_ticker(self, client, message, subscription):
+    def handle_ticker(self, client, message):
         #
-        #     [
-        #         0,  # channelID
-        #         {
-        #             "a": ["5525.40000", 1, "1.000"],  # ask, wholeAskVolume, askVolume
-        #             "b": ["5525.10000", 1, "1.000"],  # bid, wholeBidVolume, bidVolume
-        #             "c": ["5525.10000", "0.00398963"],  # closing price, volume
-        #             "h": ["5783.00000", "5783.00000"],  # high price today, high price 24h ago
-        #             "l": ["5505.00000", "5505.00000"],  # low price today, low price 24h ago
-        #             "o": ["5760.70000", "5763.40000"],  # open price today, open price 24h ago
-        #             "p": ["5631.44067", "5653.78939"],  # vwap today, vwap 24h ago
-        #             "t": [11493, 16267],  # number of trades today, 24 hours ago
-        #             "v": ["2634.11501494", "3591.17907851"],  # volume today, volume 24 hours ago
-        #         },
-        #         "ticker",
-        #         "XBT/USD"
-        #     ]
+        #     {
+        #         "channel": "ticker",
+        #         "type": "snapshot",
+        #         "data": [
+        #             {
+        #                 "symbol": "BTC/USD",
+        #                 "bid": 108359.8,
+        #                 "bid_qty": 0.01362603,
+        #                 "ask": 108359.9,
+        #                 "ask_qty": 17.17988863,
+        #                 "last": 108359.8,
+        #                 "volume": 2158.32346723,
+        #                 "vwap": 108894.5,
+        #                 "low": 106824,
+        #                 "high": 111300,
+        #                 "change": -2679.9,
+        #                 "change_pct": -2.41
+        #             }
+        #         ]
+        #     }
         #
-        wsName = message[3]
-        market = self.safe_value(self.options['marketsByWsName'], wsName)
-        symbol = market['symbol']
+        data = self.safe_list(message, 'data', [])
+        ticker = data[0]
+        symbol = self.safe_string(ticker, 'symbol')
         messageHash = self.get_message_hash('ticker', None, symbol)
-        ticker = message[1]
-        vwap = self.safe_string(ticker['p'], 0)
+        vwap = self.safe_string(ticker, 'vwap')
         quoteVolume = None
-        baseVolume = self.safe_string(ticker['v'], 0)
+        baseVolume = self.safe_string(ticker, 'volume')
         if baseVolume is not None and vwap is not None:
             quoteVolume = Precise.string_mul(baseVolume, vwap)
-        last = self.safe_string(ticker['c'], 0)
+        last = self.safe_string(ticker, 'last')
         result = self.safe_ticker({
             'symbol': symbol,
             'timestamp': None,
             'datetime': None,
-            'high': self.safe_string(ticker['h'], 0),
-            'low': self.safe_string(ticker['l'], 0),
-            'bid': self.safe_string(ticker['b'], 0),
-            'bidVolume': self.safe_string(ticker['b'], 2),
-            'ask': self.safe_string(ticker['a'], 0),
-            'askVolume': self.safe_string(ticker['a'], 2),
+            'high': self.safe_string(ticker, 'high'),
+            'low': self.safe_string(ticker, 'low'),
+            'bid': self.safe_string(ticker, 'bid'),
+            'bidVolume': self.safe_string(ticker, 'bid_qty'),
+            'ask': self.safe_string(ticker, 'ask'),
+            'askVolume': self.safe_string(ticker, 'ask_qty'),
             'vwap': vwap,
-            'open': self.safe_string(ticker['o'], 0),
+            'open': None,
             'close': last,
             'last': last,
             'previousClose': None,
-            'change': None,
-            'percentage': None,
+            'change': self.safe_string(ticker, 'change'),
+            'percentage': self.safe_string(ticker, 'change_pct'),
             'average': None,
             'baseVolume': baseVolume,
             'quoteVolume': quoteVolume,
@@ -355,30 +526,35 @@ class kraken(ccxt.async_support.kraken):
         self.tickers[symbol] = result
         client.resolve(result, messageHash)
 
-    def handle_trades(self, client: Client, message, subscription):
+    def handle_trades(self, client: Client, message):
         #
-        #     [
-        #         0,  # channelID
-        #         [ #     price        volume         time             side type misc
-        #             ["5541.20000", "0.15850568", "1534614057.321596", "s", "l", ""],
-        #             ["6060.00000", "0.02455000", "1534614057.324998", "b", "l", ""],
-        #         ],
-        #         "trade",
-        #         "XBT/USD"
-        #     ]
+        #     {
+        #         "channel": "trade",
+        #         "type": "update",
+        #         "data": [
+        #             {
+        #                 "symbol": "MATIC/USD",
+        #                 "side": "sell",
+        #                 "price": 0.5117,
+        #                 "qty": 40.0,
+        #                 "ord_type": "market",
+        #                 "trade_id": 4665906,
+        #                 "timestamp": "2023-09-25T07:49:37.708706Z"
+        #             }
+        #         ]
+        #     }
         #
-        wsName = self.safe_string(message, 3)
-        name = self.safe_string(message, 2)
-        market = self.safe_value(self.options['marketsByWsName'], wsName)
-        symbol = market['symbol']
-        messageHash = self.get_message_hash(name, None, symbol)
+        data = self.safe_list(message, 'data', [])
+        trade = data[0]
+        symbol = self.safe_string(trade, 'symbol')
+        messageHash = self.get_message_hash('trade', None, symbol)
         stored = self.safe_value(self.trades, symbol)
         if stored is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCache(limit)
             self.trades[symbol] = stored
-        trades = self.safe_value(message, 1, [])
-        parsed = self.parse_trades(trades, market)
+        market = self.market(symbol)
+        parsed = self.parse_trades(data, market)
         for i in range(0, len(parsed)):
             stored.append(parsed[i])
         client.resolve(stored, messageHash)
@@ -462,6 +638,9 @@ class kraken(ccxt.async_support.kraken):
     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
+
+        https://docs.kraken.com/api/docs/websocket-v2/ticker
+
         :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>`
@@ -474,7 +653,10 @@ class kraken(ccxt.async_support.kraken):
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         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
+
+        https://docs.kraken.com/api/docs/websocket-v2/ticker
+
+        :param str[] symbols:
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
@@ -487,10 +669,32 @@ class kraken(ccxt.async_support.kraken):
             return result
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches best bid & ask for symbols
+
+        https://docs.kraken.com/api/docs/websocket-v2/ticker
+
+        :param str[] symbols: 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>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        params['event_trigger'] = 'bbo'
+        ticker = await self.watch_multi_helper('bidask', 'ticker', symbols, None, params)
+        if self.newUpdates:
+            result: dict = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
     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
-        :see: https://docs.kraken.com/websockets/#message-trade
+
+        https://docs.kraken.com/api/docs/websocket-v2/trade
+
         :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
@@ -501,8 +705,10 @@ class kraken(ccxt.async_support.kraken):
 
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://docs.kraken.com/websockets/#message-trade
         get the list of most recent trades for a list of symbols
+
+        https://docs.kraken.com/api/docs/websocket-v2/trade
+
         :param str[] symbols: 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
@@ -519,7 +725,9 @@ class kraken(ccxt.async_support.kraken):
     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
-        :see: https://docs.kraken.com/websockets/#message-book
+
+        https://docs.kraken.com/api/docs/websocket-v2/book
+
         :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
@@ -530,26 +738,29 @@ class kraken(ccxt.async_support.kraken):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://docs.kraken.com/websockets/#message-book
+
+        https://docs.kraken.com/api/docs/websocket-v2/book
+
         :param str[] symbols: unified array of symbols
         :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
         """
-        request: dict = {}
+        requiredParams: dict = {}
         if limit is not None:
             if self.in_array(limit, [10, 25, 100, 500, 1000]):
-                request['subscription'] = {
-                    'depth': limit,  # default 10, valid options 10, 25, 100, 500, 1000
-                }
+                requiredParams['depth'] = limit  # default 10, valid options 10, 25, 100, 500, 1000
             else:
                 raise NotSupported(self.id + ' watchOrderBook accepts limit values of 10, 25, 100, 500 and 1000 only')
-        orderbook = await self.watch_multi_helper('orderbook', 'book', symbols, {'limit': limit}, self.extend(request, params))
+        orderbook = await self.watch_multi_helper('orderbook', 'book', symbols, {'limit': limit}, self.extend(requiredParams, params))
         return orderbook.limit()
 
     async def watch_ohlcv(self, symbol: str, timeframe='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
+
+        https://docs.kraken.com/api/docs/websocket-v1/ohlc
+
         :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
@@ -590,18 +801,25 @@ class kraken(ccxt.async_support.kraken):
             for i in range(0, len(self.symbols)):
                 symbol = self.symbols[i]
                 market = self.markets[symbol]
-                if market['darkpool']:
-                    info = self.safe_value(market, 'info', {})
-                    altname = self.safe_string(info, 'altname')
-                    wsName = altname[0:3] + '/' + altname[3:]
-                    marketsByWsName[wsName] = market
-                else:
-                    info = self.safe_value(market, 'info', {})
-                    wsName = self.safe_string(info, 'wsname')
-                    marketsByWsName[wsName] = market
+                info = self.safe_value(market, 'info', {})
+                wsName = self.safe_string(info, 'wsname')
+                marketsByWsName[wsName] = market
             self.options['marketsByWsName'] = marketsByWsName
         return markets
 
+    def ping(self, client: Client):
+        url = client.url
+        request = {}
+        if url.find('v2') >= 0:
+            request['method'] = 'ping'
+        else:
+            request['event'] = 'ping'
+        return request
+
+    def handle_pong(self, client: Client, message):
+        client.lastPong = self.milliseconds()
+        return message
+
     async def watch_heartbeat(self, params={}):
         await self.load_markets()
         event = 'heartbeat'
@@ -617,157 +835,151 @@ class kraken(ccxt.async_support.kraken):
         event = self.safe_string(message, 'event')
         client.resolve(message, event)
 
-    def handle_order_book(self, client: Client, message, subscription):
+    def handle_order_book(self, client: Client, message):
         #
         # first message(snapshot)
         #
-        #     [
-        #         1234,  # channelID
-        #         {
-        #             "as": [
-        #                 ["5541.30000", "2.50700000", "1534614248.123678"],
-        #                 ["5541.80000", "0.33000000", "1534614098.345543"],
-        #                 ["5542.70000", "0.64700000", "1534614244.654432"]
-        #             ],
-        #             "bs": [
-        #                 ["5541.20000", "1.52900000", "1534614248.765567"],
-        #                 ["5539.90000", "0.30000000", "1534614241.769870"],
-        #                 ["5539.50000", "5.00000000", "1534613831.243486"]
-        #             ]
-        #         },
-        #         "book-10",
-        #         "XBT/USD"
-        #     ]
+        #     {
+        #         "channel": "book",
+        #         "type": "snapshot",
+        #         "data": [
+        #             {
+        #                 "symbol": "MATIC/USD",
+        #                 "bids": [
+        #                     {
+        #                         "price": 0.5666,
+        #                         "qty": 4831.75496356
+        #                     },
+        #                     {
+        #                         "price": 0.5665,
+        #                         "qty": 6658.22734739
+        #                     }
+        #                 ],
+        #                 "asks": [
+        #                     {
+        #                         "price": 0.5668,
+        #                         "qty": 4410.79769741
+        #                     },
+        #                     {
+        #                         "price": 0.5669,
+        #                         "qty": 4655.40412487
+        #                     }
+        #                 ],
+        #                 "checksum": 2439117997
+        #             }
+        #         ]
+        #     }
         #
         # subsequent updates
         #
-        #     [
-        #         1234,
-        #         { # optional
-        #             "a": [
-        #                 ["5541.30000", "2.50700000", "1534614248.456738"],
-        #                 ["5542.50000", "0.40100000", "1534614248.456738"]
-        #             ]
-        #         },
-        #         { # optional
-        #             "b": [
-        #                 ["5541.30000", "0.00000000", "1534614335.345903"]
-        #             ]
-        #         },
-        #         "book-10",
-        #         "XBT/USD"
-        #     ]
+        #     {
+        #         "channel": "book",
+        #         "type": "update",
+        #         "data": [
+        #             {
+        #                 "symbol": "MATIC/USD",
+        #                 "bids": [
+        #                     {
+        #                         "price": 0.5657,
+        #                         "qty": 1098.3947558
+        #                     }
+        #                 ],
+        #                 "asks": [],
+        #                 "checksum": 2114181697,
+        #                 "timestamp": "2023-10-06T17:35:55.440295Z"
+        #             }
+        #         ]
+        #     }
         #
-        messageLength = len(message)
-        wsName = message[messageLength - 1]
-        bookDepthString = message[messageLength - 2]
-        parts = bookDepthString.split('-')
-        depth = self.safe_integer(parts, 1, 10)
-        market = self.safe_value(self.options['marketsByWsName'], wsName)
-        symbol = market['symbol']
-        timestamp = None
+        type = self.safe_string(message, 'type')
+        data = self.safe_list(message, 'data', [])
+        first = self.safe_dict(data, 0, {})
+        symbol = self.safe_string(first, 'symbol')
+        a = self.safe_value(first, 'asks', [])
+        b = self.safe_value(first, 'bids', [])
+        c = self.safe_integer(first, 'checksum')
         messageHash = self.get_message_hash('orderbook', None, symbol)
-        # if self is a snapshot
-        if 'as' in message[1]:
-            # todo get depth from marketsByWsName
-            self.orderbooks[symbol] = self.order_book({}, depth)
+        orderbook = None
+        if type == 'update':
             orderbook = self.orderbooks[symbol]
-            sides: dict = {
-                'as': 'asks',
-                'bs': 'bids',
-            }
-            keys = list(sides.keys())
-            for i in range(0, len(keys)):
-                key = keys[i]
-                side = sides[key]
-                bookside = orderbook[side]
-                deltas = self.safe_value(message[1], key, [])
-                timestamp = self.custom_handle_deltas(bookside, deltas, timestamp)
-            orderbook['symbol'] = symbol
-            orderbook['timestamp'] = timestamp
-            orderbook['datetime'] = self.iso8601(timestamp)
-            client.resolve(orderbook, messageHash)
-        else:
-            orderbook = self.orderbooks[symbol]
-            # else, if self is an orderbook update
-            a = None
-            b = None
-            c = None
-            if messageLength == 5:
-                a = self.safe_value(message[1], 'a', [])
-                b = self.safe_value(message[2], 'b', [])
-                c = self.safe_integer(message[1], 'c')
-                c = self.safe_integer(message[2], 'c', c)
-            else:
-                c = self.safe_integer(message[1], 'c')
-                if 'a' in message[1]:
-                    a = self.safe_value(message[1], 'a', [])
-                else:
-                    b = self.safe_value(message[1], 'b', [])
             storedAsks = orderbook['asks']
             storedBids = orderbook['bids']
-            example = None
             if a is not None:
-                timestamp = self.custom_handle_deltas(storedAsks, a, timestamp)
-                example = self.safe_value(a, 0)
+                self.custom_handle_deltas(storedAsks, a)
             if b is not None:
-                timestamp = self.custom_handle_deltas(storedBids, b, timestamp)
-                example = self.safe_value(b, 0)
-            # don't remove self line or I will poop on your face
-            orderbook.limit()
-            checksum = self.safe_bool(self.options, 'checksum', True)
-            if checksum:
-                priceString = self.safe_string(example, 0)
-                amountString = self.safe_string(example, 1)
-                priceParts = priceString.split('.')
-                amountParts = amountString.split('.')
-                priceLength = len(priceParts[1]) - 0
-                amountLength = len(amountParts[1]) - 0
-                payloadArray = []
-                if c is not None:
-                    for i in range(0, 10):
-                        formatted = self.format_number(storedAsks[i][0], priceLength) + self.format_number(storedAsks[i][1], amountLength)
-                        payloadArray.append(formatted)
-                    for i in range(0, 10):
-                        formatted = self.format_number(storedBids[i][0], priceLength) + self.format_number(storedBids[i][1], amountLength)
-                        payloadArray.append(formatted)
-                payload = ''.join(payloadArray)
-                localChecksum = self.crc32(payload, False)
-                if localChecksum != c:
-                    error = InvalidNonce(self.id + ' invalid checksum')
-                    del client.subscriptions[messageHash]
-                    del self.orderbooks[symbol]
-                    client.reject(error, messageHash)
-                    return
+                self.custom_handle_deltas(storedBids, b)
+            datetime = self.safe_string(first, 'timestamp')
+            orderbook['symbol'] = symbol
+            orderbook['timestamp'] = self.parse8601(datetime)
+            orderbook['datetime'] = datetime
+        else:
+            # snapshot
+            depth = len(a)
+            self.orderbooks[symbol] = self.order_book({}, depth)
+            orderbook = self.orderbooks[symbol]
+            keys = ['asks', 'bids']
+            for i in range(0, len(keys)):
+                key = keys[i]
+                bookside = orderbook[key]
+                deltas = self.safe_value(first, key, [])
+                if len(deltas) > 0:
+                    self.custom_handle_deltas(bookside, deltas)
             orderbook['symbol'] = symbol
-            orderbook['timestamp'] = timestamp
-            orderbook['datetime'] = self.iso8601(timestamp)
-            client.resolve(orderbook, messageHash)
+        orderbook.limit()
+        # checksum temporarily disabled because the exchange checksum was not reliable
+        checksum = self.handle_option('watchOrderBook', 'checksum', False)
+        if checksum:
+            payloadArray = []
+            if c is not None:
+                checkAsks = orderbook['asks']
+                checkBids = orderbook['bids']
+                # checkAsks = asks.map((elem) => [elem['price'], elem['qty']])
+                # checkBids = bids.map((elem) => [elem['price'], elem['qty']])
+                for i in range(0, 10):
+                    currentAsk = self.safe_value(checkAsks, i, {})
+                    formattedAsk = self.format_number(currentAsk[0]) + self.format_number(currentAsk[1])
+                    payloadArray.append(formattedAsk)
+                for i in range(0, 10):
+                    currentBid = self.safe_value(checkBids, i, {})
+                    formattedBid = self.format_number(currentBid[0]) + self.format_number(currentBid[1])
+                    payloadArray.append(formattedBid)
+            payload = ''.join(payloadArray)
+            localChecksum = self.crc32(payload, False)
+            if localChecksum != c:
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+                del client.subscriptions[messageHash]
+                del self.orderbooks[symbol]
+                client.reject(error, messageHash)
+                return
+        client.resolve(orderbook, messageHash)
 
-    def format_number(self, n, length):
-        stringNumber = self.number_to_string(n)
-        parts = stringNumber.split('.')
+    def custom_handle_deltas(self, bookside, deltas):
+        # sortOrder = True if (key == 'bids') else False
+        for j in range(0, len(deltas)):
+            delta = deltas[j]
+            price = self.safe_number(delta, 'price')
+            amount = self.safe_number(delta, 'qty')
+            bookside.store(price, amount)
+            # if amount == 0:
+            #     index = bookside.findIndex((x: Int) => x[0] == price)
+            #     bookside.splice(index, 1)
+            # else:
+            #     bookside.store(price, amount)
+            # }
+            # bookside = self.sort_by(bookside, 0, sortOrder)
+            # bookside[0:9]
+
+    def format_number(self, data):
+        parts = data.split('.')
         integer = self.safe_string(parts, 0)
         decimals = self.safe_string(parts, 1, '')
-        paddedDecimals = decimals.ljust(length, '0')
-        joined = integer + paddedDecimals
+        joinedResult = integer + decimals
         i = 0
-        while(joined[i] == '0'):
+        while(joinedResult[i] == '0'):
             i += 1
         if i > 0:
-            return joined[i:]
-        else:
-            return joined
-
-    def custom_handle_deltas(self, bookside, deltas, timestamp=None):
-        for j in range(0, len(deltas)):
-            delta = deltas[j]
-            price = self.parse_number(delta[0])
-            amount = self.parse_number(delta[1])
-            oldTimestamp = timestamp if timestamp else 0
-            timestamp = max(oldTimestamp, self.parse_to_int(float(delta[2]) * 1000))
-            bookside.store(price, amount)
-        return timestamp
+            joinedResult = joinedResult[i:]
+        return joinedResult
 
     def handle_system_status(self, client: Client, message):
         #
@@ -782,6 +994,20 @@ class kraken(ccxt.async_support.kraken):
         #         "version": "0.2.0"
         #     }
         #
+        # v2
+        #     {
+        #         channel: 'status',
+        #         type: 'update',
+        #         data: [
+        #             {
+        #                 version: '2.0.10',
+        #                 system: 'online',
+        #                 api_version: 'v2',
+        #                 connection_id: 6447481662169813000
+        #             }
+        #         ]
+        #     }
+        #
         return message
 
     async def authenticate(self, params={}):
@@ -789,7 +1015,11 @@ class kraken(ccxt.async_support.kraken):
         client = self.client(url)
         authenticated = 'authenticated'
         subscription = self.safe_value(client.subscriptions, authenticated)
-        if subscription is None:
+        now = self.seconds()
+        start = self.safe_integer(subscription, 'start')
+        expires = self.safe_integer(subscription, 'expires')
+        if (subscription is None) or ((subscription is not None) and (start + expires) <= now):
+            # https://docs.kraken.com/api/docs/rest-api/get-websockets-token
             response = await self.privatePostGetWebSocketsToken(params)
             #
             #     {
@@ -800,7 +1030,8 @@ class kraken(ccxt.async_support.kraken):
             #         }
             #     }
             #
-            subscription = self.safe_value(response, 'result')
+            subscription = self.safe_dict(response, 'result')
+            subscription['start'] = now
             client.subscriptions[authenticated] = subscription
         return self.safe_string(subscription, 'token')
 
@@ -831,11 +1062,14 @@ class kraken(ccxt.async_support.kraken):
     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
+
+        https://docs.kraken.com/api/docs/websocket-v1/owntrades
+
         :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]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         return await self.watch_private('ownTrades', symbol, since, limit, params)
 
@@ -979,7 +1213,9 @@ class kraken(ccxt.async_support.kraken):
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://docs.kraken.com/websockets/#message-openOrders
+
+        https://docs.kraken.com/api/docs/websocket-v1/openorders
+
         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
@@ -1229,23 +1465,86 @@ class kraken(ccxt.async_support.kraken):
         symbols = self.market_symbols(symbols, None, False, True, False)
         messageHashes = []
         for i in range(0, len(symbols)):
-            messageHashes.append(self.get_message_hash(unifiedName, None, self.symbol(symbols[i])))
-        # for WS subscriptions, we can't use .marketIds(symbols), instead a custom is field needed
-        markets = self.markets_for_symbols(symbols)
-        wsMarketIds = []
-        for i in range(0, len(markets)):
-            wsMarketId = self.safe_string(markets[i]['info'], 'wsname')
-            wsMarketIds.append(wsMarketId)
+            eventTrigger = self.safe_string(params, 'event_trigger')
+            if eventTrigger is not None:
+                messageHashes.append(self.get_message_hash(channelName, None, self.symbol(symbols[i])))
+            else:
+                messageHashes.append(self.get_message_hash(unifiedName, None, self.symbol(symbols[i])))
         request: dict = {
-            'event': 'subscribe',
-            'reqid': self.request_id(),
-            'pair': wsMarketIds,
-            'subscription': {
-                'name': channelName,
+            'method': 'subscribe',
+            'params': {
+                'channel': channelName,
+                'symbol': symbols,
             },
+            'req_id': self.request_id(),
         }
-        url = self.urls['api']['ws']['public']
-        return await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes, subscriptionArgs)
+        request['params'] = self.deep_extend(request['params'], params)
+        url = self.urls['api']['ws']['publicV2']
+        return await self.watch_multiple(url, messageHashes, request, messageHashes, subscriptionArgs)
+
+    async def watch_balance(self, params={}) -> Balances:
+        """
+        watch balance and get the amount of funds available for trading or funds locked in orders
+
+        https://docs.kraken.com/api/docs/websocket-v2/balances
+
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
+        """
+        await self.load_markets()
+        token = await self.authenticate()
+        messageHash = 'balances'
+        url = self.urls['api']['ws']['privateV2']
+        requestId = self.request_id()
+        subscribe: dict = {
+            'method': 'subscribe',
+            'req_id': requestId,
+            'params': {
+                'channel': 'balances',
+                'token': token,
+            },
+        }
+        request = self.deep_extend(subscribe, params)
+        return await self.watch(url, messageHash, request, messageHash)
+
+    def handle_balance(self, client: Client, message):
+        #
+        #     {
+        #         "channel": "balances",
+        #         "data": [
+        #             {
+        #                 "asset": "BTC",
+        #                 "asset_class": "currency",
+        #                 "balance": 1.2,
+        #                 "wallets": [
+        #                     {
+        #                         "type": "spot",
+        #                         "id": "main",
+        #                         "balance": 1.2
+        #                     }
+        #                 ]
+        #             }
+        #         ],
+        #         "type": "snapshot",
+        #         "sequence": 1
+        #     }
+        #
+        data = self.safe_list(message, 'data', [])
+        result: dict = {'info': message}
+        for i in range(0, len(data)):
+            currencyId = self.safe_string(data[i], 'asset')
+            code = self.safe_currency_code(currencyId)
+            account = self.account()
+            eq = self.safe_string(data[i], 'balance')
+            account['total'] = eq
+            result[code] = account
+        type = 'spot'
+        balance = self.safe_balance(result)
+        oldBalance = self.safe_value(self.balance, type, {})
+        newBalance = self.deep_extend(oldBalance, balance)
+        self.balance[type] = self.safe_balance(newBalance)
+        channel = self.safe_string(message, 'channel')
+        client.resolve(self.balance[type], channel)
 
     def get_message_hash(self, unifiedElementName: str, subChannelName: Str = None, symbol: Str = None):
         # unifiedElementName can be : orderbook, trade, ticker, bidask ...
@@ -1292,7 +1591,7 @@ class kraken(ccxt.async_support.kraken):
         #     del client.futures[requestId]
         # }
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         #     {
         #         "errorMessage": "Currency pair not in ISO 4217-A3 format foobar",
@@ -1303,19 +1602,31 @@ class kraken(ccxt.async_support.kraken):
         #         "subscription": {name: "ticker"}
         #     }
         #
-        errorMessage = self.safe_string(message, 'errorMessage')
+        # v2
+        #     {
+        #         "error": "Unsupported field: 'price' for the given msg type: add order",
+        #         "method": "add_order",
+        #         "success": False,
+        #         "time_in": "2025-05-13T08:59:44.803511Z",
+        #         "time_out": "2025-05-13T08:59:44.803542Z'
+        #     }
+        #
+        errorMessage = self.safe_string_2(message, 'errorMessage', 'error')
         if errorMessage is not None:
-            requestId = self.safe_value(message, 'reqid')
-            if requestId is not None:
-                broad = self.exceptions['ws']['broad']
-                broadKey = self.find_broadly_matched_key(broad, errorMessage)
-                exception = None
-                if broadKey is None:
-                    exception = ExchangeError(errorMessage)  # c# requirement to convert the errorMessage to string
-                else:
-                    exception = broad[broadKey](errorMessage)
-                client.reject(exception, requestId)
-                return False
+            # requestId = self.safe_value_2(message, 'reqid', 'req_id')
+            broad = self.exceptions['ws']['broad']
+            broadKey = self.find_broadly_matched_key(broad, errorMessage)
+            exception = None
+            if broadKey is None:
+                exception = ExchangeError(errorMessage)  # c# requirement to convert the errorMessage to string
+            else:
+                exception = broad[broadKey](errorMessage)
+            # if requestId is not None:
+            #     client.reject(exception, requestId)
+            # else:
+            client.reject(exception)
+            # }
+            return False
         return True
 
     def handle_message(self, client: Client, message):
@@ -1328,10 +1639,7 @@ class kraken(ccxt.async_support.kraken):
             name = self.safe_string(info, 'name')
             methods: dict = {
                 # public
-                'book': self.handle_order_book,
                 'ohlc': self.handle_ohlcv,
-                'ticker': self.handle_ticker,
-                'trade': self.handle_trades,
                 # private
                 'openOrders': self.handle_orders,
                 'ownTrades': self.handle_my_trades,
@@ -1340,16 +1648,28 @@ class kraken(ccxt.async_support.kraken):
             if method is not None:
                 method(client, message, subscription)
         else:
+            channel = self.safe_string(message, 'channel')
+            if channel is not None:
+                methods: dict = {
+                    'balances': self.handle_balance,
+                    'book': self.handle_order_book,
+                    'ticker': self.handle_ticker,
+                    'trade': self.handle_trades,
+                }
+                method = self.safe_value(methods, channel)
+                if method is not None:
+                    method(client, message)
             if self.handle_error_message(client, message):
-                event = self.safe_string(message, 'event')
+                event = self.safe_string_2(message, 'event', 'method')
                 methods: dict = {
                     'heartbeat': self.handle_heartbeat,
                     'systemStatus': self.handle_system_status,
                     'subscriptionStatus': self.handle_subscription_status,
-                    'addOrderStatus': self.handle_create_edit_order,
-                    'editOrderStatus': self.handle_create_edit_order,
-                    'cancelOrderStatus': self.handle_cancel_order,
-                    'cancelAllStatus': self.handle_cancel_all_orders,
+                    'add_order': self.handle_create_edit_order,
+                    'amend_order': self.handle_create_edit_order,
+                    'cancel_order': self.handle_cancel_order,
+                    'cancel_all': self.handle_cancel_all_orders,
+                    'pong': self.handle_pong,
                 }
                 method = self.safe_value(methods, event)
                 if method is not None: