ccxt 4.4.77__py2.py3-none-any.whl → 4.4.80__py2.py3-none-any.whl

ccxt/pro/binance.py

@@ -71,12 +71,12 @@ class binance(ccxt.async_support.binance):
             'urls': {
                 'test': {
                     'ws': {
-                        'spot': 'wss://testnet.binance.vision/ws',
-                        'margin': 'wss://testnet.binance.vision/ws',
+                        'spot': 'wss://stream.testnet.binance.vision/ws',
+                        'margin': 'wss://stream.testnet.binance.vision/ws',
                         'future': 'wss://fstream.binancefuture.com/ws',
                         'delivery': 'wss://dstream.binancefuture.com/ws',
                         'ws-api': {
-                            'spot': 'wss://testnet.binance.vision/ws-api/v3',
+                            'spot': 'wss://ws-api.testnet.binance.vision/ws-api/v3',
                             'future': 'wss://testnet.binancefuture.com/ws-fapi/v1',
                             'delivery': 'wss://testnet.binancefuture.com/ws-dapi/v1',
                         },

ccxt/pro/coinbase.py

@@ -78,7 +78,7 @@ class coinbase(ccxt.async_support.coinbase):
             messageHash = messageHash + '::' + ','.join(symbol)
         elif symbol is not None:
             market = self.market(symbol)
-            messageHash = name + '::' + market['id']
+            messageHash = name + '::' + symbol
             productIds = [market['id']]
         url = self.urls['api']['ws']
         subscribe = {
@@ -115,7 +115,7 @@ class coinbase(ccxt.async_support.coinbase):
             market = self.market(symbol)
             marketId = market['id']
             productIds.append(marketId)
-            messageHashes.append(name + '::' + marketId)
+            messageHashes.append(name + '::' + symbol)
         url = self.urls['api']['ws']
         subscribe = {
             'type': 'subscribe',
@@ -176,8 +176,11 @@ class coinbase(ccxt.async_support.coinbase):
         if symbols is None:
             symbols = self.symbols
         name = 'ticker_batch'
-        tickers = await self.subscribe(name, False, symbols, params)
+        ticker = await self.subscribe_multiple(name, False, symbols, params)
         if self.newUpdates:
+            tickers = {}
+            symbol = ticker['symbol']
+            tickers[symbol] = ticker
             return tickers
         return self.tickers
 
@@ -272,7 +275,7 @@ class coinbase(ccxt.async_support.coinbase):
         #
         #
         channel = self.safe_string(message, 'channel')
-        events = self.safe_value(message, 'events', [])
+        events = self.safe_list(message, 'events', [])
         datetime = self.safe_string(message, 'timestamp')
         timestamp = self.parse8601(datetime)
         newTickers = []
@@ -281,31 +284,18 @@ class coinbase(ccxt.async_support.coinbase):
             tickers = self.safe_list(tickersObj, 'tickers', [])
             for j in range(0, len(tickers)):
                 ticker = tickers[j]
+                wsMarketId = self.safe_string(ticker, 'product_id')
+                if wsMarketId is None:
+                    continue
                 result = self.parse_ws_ticker(ticker)
                 result['timestamp'] = timestamp
                 result['datetime'] = datetime
                 symbol = result['symbol']
                 self.tickers[symbol] = result
-                wsMarketId = self.safe_string(ticker, 'product_id')
-                if wsMarketId is None:
-                    continue
-                messageHash = channel + '::' + wsMarketId
                 newTickers.append(result)
+                messageHash = channel + '::' + symbol
                 client.resolve(result, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(result, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        messageHashes = self.find_message_hashes(client, 'ticker_batch::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            if not self.is_empty(tickers):
-                client.resolve(tickers, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(tickers, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        return message
+                self.try_resolve_usdc(client, messageHash, result)
 
     def parse_ws_ticker(self, ticker, market=None):
         #
@@ -470,13 +460,13 @@ class coinbase(ccxt.async_support.coinbase):
         #        ]
         #    }
         #
-        events = self.safe_value(message, 'events')
+        events = self.safe_list(message, 'events')
         event = self.safe_value(events, 0)
-        trades = self.safe_value(event, 'trades')
-        trade = self.safe_value(trades, 0)
+        trades = self.safe_list(event, 'trades')
+        trade = self.safe_dict(trades, 0)
         marketId = self.safe_string(trade, 'product_id')
-        messageHash = 'market_trades::' + marketId
         symbol = self.safe_symbol(marketId)
+        messageHash = 'market_trades::' + symbol
         tradesArray = self.safe_value(self.trades, symbol)
         if tradesArray is None:
             tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
@@ -484,14 +474,12 @@ class coinbase(ccxt.async_support.coinbase):
             self.trades[symbol] = tradesArray
         for i in range(0, len(events)):
             currentEvent = events[i]
-            currentTrades = self.safe_value(currentEvent, 'trades')
+            currentTrades = self.safe_list(currentEvent, 'trades')
             for j in range(0, len(currentTrades)):
                 item = currentTrades[i]
                 tradesArray.append(self.parse_trade(item))
         client.resolve(tradesArray, messageHash)
-        if marketId.endswith('USD'):
-            client.resolve(tradesArray, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        return message
+        self.try_resolve_usdc(client, messageHash, tradesArray)
 
     def handle_order(self, client, message):
         #
@@ -522,14 +510,14 @@ class coinbase(ccxt.async_support.coinbase):
         #        ]
         #    }
         #
-        events = self.safe_value(message, 'events')
+        events = self.safe_list(message, 'events')
         marketIds = []
         if self.orders is None:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)
         for i in range(0, len(events)):
             event = events[i]
-            responseOrders = self.safe_value(event, 'orders')
+            responseOrders = self.safe_list(event, 'orders')
             for j in range(0, len(responseOrders)):
                 responseOrder = responseOrders[j]
                 parsed = self.parse_ws_order(responseOrder)
@@ -540,12 +528,11 @@ class coinbase(ccxt.async_support.coinbase):
                 cachedOrders.append(parsed)
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
-            messageHash = 'user::' + marketId
+            symbol = self.safe_symbol(marketId)
+            messageHash = 'user::' + symbol
             client.resolve(self.orders, messageHash)
-            if messageHash.endswith('USD'):
-                client.resolve(self.orders, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
+            self.try_resolve_usdc(client, messageHash, self.orders)
         client.resolve(self.orders, 'user')
-        return message
 
     def parse_ws_order(self, order, market=None):
         #
@@ -635,36 +622,35 @@ class coinbase(ccxt.async_support.coinbase):
         #        ]
         #    }
         #
-        events = self.safe_value(message, 'events')
+        events = self.safe_list(message, 'events')
         datetime = self.safe_string(message, 'timestamp')
         for i in range(0, len(events)):
             event = events[i]
-            updates = self.safe_value(event, 'updates', [])
+            updates = self.safe_list(event, 'updates', [])
             marketId = self.safe_string(event, 'product_id')
-            messageHash = 'level2::' + marketId
+            # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD, are aliases
+            market = self.safe_market(marketId)
+            symbol = market['symbol']
+            messageHash = 'level2::' + symbol
             subscription = self.safe_value(client.subscriptions, messageHash, {})
             limit = self.safe_integer(subscription, 'limit')
-            symbol = self.safe_symbol(marketId)
             type = self.safe_string(event, 'type')
             if type == 'snapshot':
                 self.orderbooks[symbol] = self.order_book({}, limit)
-                orderbook = self.orderbooks[symbol]
-                self.handle_order_book_helper(orderbook, updates)
-                orderbook['timestamp'] = self.parse8601(datetime)
-                orderbook['datetime'] = datetime
-                orderbook['symbol'] = symbol
-                client.resolve(orderbook, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-            elif type == 'update':
-                orderbook = self.orderbooks[symbol]
-                self.handle_order_book_helper(orderbook, updates)
-                orderbook['datetime'] = datetime
-                orderbook['timestamp'] = self.parse8601(datetime)
-                orderbook['symbol'] = symbol
-                client.resolve(orderbook, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
+            # unknown bug, can't reproduce, but sometimes orderbook is None
+            if not (symbol in self.orderbooks) and self.orderbooks[symbol] is None:
+                continue
+            orderbook = self.orderbooks[symbol]
+            self.handle_order_book_helper(orderbook, updates)
+            orderbook['timestamp'] = self.parse8601(datetime)
+            orderbook['datetime'] = datetime
+            orderbook['symbol'] = symbol
+            client.resolve(orderbook, messageHash)
+            self.try_resolve_usdc(client, messageHash, orderbook)
+
+    def try_resolve_usdc(self, client, messageHash, result):
+        if messageHash.endswith('/USD') or messageHash.endswith('-USD'):
+            client.resolve(result, messageHash + 'C')  # when subscribing to BTC/USDC and coinbase returns BTC/USD, so resolve USDC too
 
     def handle_subscription_status(self, client, message):
         #

ccxt/pro/gate.py

@@ -1175,8 +1175,28 @@ class gate(ccxt.async_support.gate):
         for i in range(0, len(data)):
             rawPosition = data[i]
             position = self.parse_position(rawPosition)
-            newPositions.append(position)
-            cache.append(position)
+            symbol = self.safe_string(position, 'symbol')
+            side = self.safe_string(position, 'side')
+            # Control when position is closed no side is returned
+            if side is None:
+                prevLongPosition = self.safe_dict(cache, symbol + 'long')
+                if prevLongPosition is not None:
+                    position['side'] = prevLongPosition['side']
+                    newPositions.append(position)
+                    cache.append(position)
+                prevShortPosition = self.safe_dict(cache, symbol + 'short')
+                if prevShortPosition is not None:
+                    position['side'] = prevShortPosition['side']
+                    newPositions.append(position)
+                    cache.append(position)
+                # if no prev position is found, default to long
+                if prevLongPosition is None and prevShortPosition is None:
+                    position['side'] = 'long'
+                    newPositions.append(position)
+                    cache.append(position)
+            else:
+                newPositions.append(position)
+                cache.append(position)
         messageHashes = self.find_message_hashes(client, type + ':positions::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]

ccxt/pro/hollaex.py

@@ -572,8 +572,8 @@ class hollaex(ccxt.async_support.hollaex):
 
     def on_error(self, client: Client, error):
         self.options['ws-expires'] = None
-        self.on_error(client, error)
+        super(hollaex, self).on_error(client, error)
 
     def on_close(self, client: Client, error):
         self.options['ws-expires'] = None
-        self.on_close(client, error)
+        super(hollaex, self).on_close(client, error)

ccxt/pro/p2b.py

@@ -478,8 +478,8 @@ class p2b(ccxt.async_support.p2b):
 
     def on_error(self, client: Client, error):
         self.options['tickerSubs'] = self.create_safe_dictionary()
-        self.on_error(client, error)
+        super(p2b, self).on_error(client, error)
 
     def on_close(self, client: Client, error):
         self.options['tickerSubs'] = self.create_safe_dictionary()
-        self.on_close(client, error)
+        super(p2b, self).on_close(client, error)

ccxt/pro/tradeogre.py

@@ -0,0 +1,272 @@
+# -*- 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
+from ccxt.base.types import Any, Int, OrderBook, Trade
+from ccxt.async_support.base.ws.client import Client
+from typing import List
+
+
+class tradeogre(ccxt.async_support.tradeogre):
+
+    def describe(self) -> Any:
+        return self.deep_extend(super(tradeogre, self).describe(), {
+            'has': {
+                'ws': True,
+                'watchTrades': True,
+                'watchTradesForSymbols': True,
+                'watchOrderBook': True,
+                'watchOrderBookForSymbols': False,
+                'watchOHLCV': False,
+                'watchOHLCVForSymbols': False,
+                'watchOrders': False,
+                'watchMyTrades': False,
+                'watchTicker': False,
+                'watchTickers': False,
+                'watchBidsAsks': False,
+                'watchBalance': False,
+                'createOrderWs': False,
+                'editOrderWs': False,
+                'cancelOrderWs': False,
+                'cancelOrdersWs': False,
+            },
+            'urls': {
+                'api': {
+                    'ws': 'wss://tradeogre.com:8443',
+                },
+            },
+            'options': {
+            },
+            'streaming': {
+            },
+        })
+
+    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
+
+        https://tradeogre.com/help/api
+
+        :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(not used by the exchange)
+        :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
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        url = self.urls['api']['ws']
+        messageHash = 'orderbook' + ':' + market['symbol']
+        request: dict = {
+            'a': 'subscribe',
+            'e': 'book',
+            't': market['id'],
+        }
+        orderbook = await self.watch(url, messageHash, self.extend(request, params), messageHash)
+        return orderbook.limit()
+
+    def handle_order_book(self, client: Client, message):
+        #
+        # initial snapshot is fetched with ccxt's fetchOrderBook
+        # the feed does not include a snapshot, just the deltas
+        #
+        #     {
+        #         "e": "book",
+        #         "t": "ETH-USDT",
+        #         "s": "10752324",
+        #         "d": {
+        #             "bids": {"1787.02497915": "0"},
+        #             "asks": {}
+        #         }
+        #     }
+        #
+        marketId = self.safe_string(message, 't')
+        symbol = self.safe_symbol(marketId)
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book({})
+        storedOrderBook = self.orderbooks[symbol]
+        nonce = self.safe_integer(storedOrderBook, 'nonce')
+        deltaNonce = self.safe_integer(message, 's')
+        messageHash = 'orderbook:' + symbol
+        if nonce is None:
+            cacheLength = len(storedOrderBook.cache)
+            snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 6)
+            if cacheLength == snapshotDelay:
+                self.spawn(self.load_order_book, client, messageHash, symbol, None, {})
+            storedOrderBook.cache.append(message)
+            return
+        elif nonce >= deltaNonce:
+            return
+        self.handle_delta(storedOrderBook, message)
+        client.resolve(storedOrderBook, messageHash)
+
+    def handle_delta(self, orderbook, delta):
+        # timestamp = self.milliseconds()  # todo check if self is correct
+        # orderbook['timestamp'] = timestamp
+        # orderbook['datetime'] = self.iso8601(timestamp)
+        orderbook['nonce'] = self.safe_integer(delta, 's')
+        data = self.safe_dict(delta, 'd', {})
+        bids = self.safe_dict(data, 'bids', {})
+        asks = self.safe_dict(data, 'asks', {})
+        storedBids = orderbook['bids']
+        storedAsks = orderbook['asks']
+        self.handle_bid_asks(storedBids, bids)
+        self.handle_bid_asks(storedAsks, asks)
+
+    def handle_bid_asks(self, bookSide, bidAsks):
+        keys = list(bidAsks.keys())
+        for i in range(0, len(keys)):
+            price = self.safe_string(keys, i)
+            amount = self.safe_number(bidAsks, price)
+            bidAsk = [self.parse_number(price), amount]
+            bookSide.storeArray(bidAsk)
+        # for i in range(0, len(bidAsks)):
+        #     bidAsk = self.parse_bid_ask(bidAsks[i])
+        #     bookSide.storeArray(bidAsk)
+        # }
+
+    def get_cache_index(self, orderbook, deltas):
+        firstElement = deltas[0]
+        firstElementNonce = self.safe_integer(firstElement, 's')
+        nonce = self.safe_integer(orderbook, 'nonce')
+        if nonce < firstElementNonce:
+            return -1
+        for i in range(0, len(deltas)):
+            delta = deltas[i]
+            deltaNonce = self.safe_integer(delta, 's')
+            if deltaNonce == nonce:
+                return i + 1
+        return len(deltas)
+
+    async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        watches information on multiple trades made in a market
+
+        https://tradeogre.com/help/api
+
+        :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()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        return await self.watch_trades_for_symbols([symbol], since, limit, params)
+
+    async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+
+        https://tradeogre.com/help/api
+
+        get the list of most recent trades for a list of symbols
+        :param str[] symbols: unified symbol of the market to fetch trades for(empty array means all markets)
+        :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>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True)
+        messageHashes = []
+        symbolsLength = 0
+        if symbols is not None:
+            symbolsLength = len(symbols)
+        if symbolsLength > 0:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHash = 'trades:' + symbol
+                messageHashes.append(messageHash)
+        else:
+            messageHash = 'trades'
+            messageHashes.append(messageHash)
+        request: dict = {
+            'a': 'subscribe',
+            'e': 'trade',
+            't': '*',
+        }
+        url = self.urls['api']['ws']
+        trades = await self.watch_multiple(url, messageHashes, self.extend(request, params), ['trades'])
+        if self.newUpdates:
+            first = self.safe_dict(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
+    def handle_trade(self, client: Client, message):
+        #
+        #     {
+        #         "e": "trade",
+        #         "t": "LTC-USDT",
+        #         "d": {
+        #             "t": 0,
+        #             "p": "84.50000000",
+        #             "q": "1.28471270",
+        #             "d": "1745392002"
+        #         }
+        #     }
+        #
+        marketId = self.safe_string(message, 't')
+        market = self.safe_market(marketId)
+        data = self.safe_dict(message, 'd', {})
+        symbol = market['symbol']
+        if not (symbol in self.trades):
+            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            stored = ArrayCache(limit)
+            self.trades[symbol] = stored
+        cache = self.trades[symbol]
+        trade = self.parse_ws_trade(data, market)
+        cache.append(trade)
+        messageHash = 'trades:' + symbol
+        client.resolve(cache, messageHash)
+        client.resolve(cache, 'trades')
+
+    def parse_ws_trade(self, trade, market=None):
+        #
+        #     {
+        #         "t": 0,
+        #         "p": "84.50000000",
+        #         "q": "1.28471270",
+        #         "d": "1745392002"
+        #     }
+        #
+        timestamp = self.safe_integer_product(trade, 'd', 1000)
+        sideEnum = self.safe_string(trade, 't')
+        return self.safe_trade({
+            'info': trade,
+            'id': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'symbol': self.safe_string(market, 'symbol'),
+            'order': None,
+            'type': None,
+            'side': self.parse_ws_trade_side(sideEnum),
+            'takerOrMaker': None,
+            'price': self.safe_string(trade, 'p'),
+            'amount': self.safe_string(trade, 'q'),
+            'cost': None,
+            'fee': {
+                'currency': None,
+                'cost': None,
+            },
+        }, market)
+
+    def parse_ws_trade_side(self, side):
+        sides = {
+            '0': 'buy',
+            '1': 'sell',
+        }
+        return self.safe_string(sides, side, side)
+
+    def handle_message(self, client: Client, message):
+        methods: dict = {
+            'book': self.handle_order_book,
+            'trade': self.handle_trade,
+        }
+        event = self.safe_string(message, 'e')
+        method = self.safe_value(methods, event)
+        if method is not None:
+            method(client, message)

ccxt/pro/upbit.py

@@ -8,6 +8,7 @@ from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
 from ccxt.base.types import Any, Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from ccxt.base.errors import NotSupported
 
 
 class upbit(ccxt.async_support.upbit):
@@ -21,6 +22,7 @@ class upbit(ccxt.async_support.upbit):
                 'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
+                'watchOHLCV': True,
                 'watchOrders': True,
                 'watchMyTrades': True,
                 'watchBalance': True,
@@ -190,6 +192,25 @@ class upbit(ccxt.async_support.upbit):
         orderbook = await self.watch_public(symbol, 'orderbook')
         return orderbook.limit()
 
+    async def watch_ohlcv(self, symbol: str, timeframe='1s', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        watches information an OHLCV with timestamp, openingPrice, highPrice, lowPrice, tradePrice, baseVolume in 1s.
+
+        https://docs.upbit.com/kr/reference/websocket-candle for Upbit KR
+        https://global-docs.upbit.com/reference/websocket-candle for Upbit Global
+
+        :param str symbol: unified market symbol of the market orders were made in
+        :param str timeframe: specifies the OHLCV candle interval to watch. As of now, Upbit only supports 1s candles.
+        :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 OHLCV[]: a list of `OHLCV structures <https://docs.ccxt.com/#/?id=ohlcv-structure>`
+        """
+        if timeframe != '1s':
+            raise NotSupported(self.id + ' watchOHLCV does not support' + timeframe + ' candle.')
+        timeFrameOHLCV = 'candle.' + timeframe
+        return await self.watch_public(symbol, timeFrameOHLCV)
+
     def handle_ticker(self, client: Client, message):
         # 2020-03-17T23:07:36.511Z "onMessage" <Buffer 7b 22 74 79 70 65 22 3a 22 74 69 63 6b 65 72 22 2c 22 63 6f 64 65 22 3a 22 42 54 43 2d 45 54 48 22 2c 22 6f 70 65 6e 69 6e 67 5f 70 72 69 63 65 22 3a ... >
         # {type: "ticker",
@@ -313,6 +334,26 @@ class upbit(ccxt.async_support.upbit):
         messageHash = 'trade:' + marketId
         client.resolve(stored, messageHash)
 
+    def handle_ohlcv(self, client: Client, message):
+        # {
+        #     type: 'candle.1s',
+        #     code: 'KRW-USDT',
+        #     candle_date_time_utc: '2025-04-22T09:50:34',
+        #     candle_date_time_kst: '2025-04-22T18:50:34',
+        #     opening_price: 1438,
+        #     high_price: 1438,
+        #     low_price: 1438,
+        #     trade_price: 1438,
+        #     candle_acc_trade_volume: 1145.8935,
+        #     candle_acc_trade_price: 1647794.853,
+        #     timestamp: 1745315434125,
+        #     stream_type: 'REALTIME'
+        #   }
+        marketId = self.safe_string(message, 'code')
+        messageHash = 'candle.1s:' + marketId
+        ohlcv = self.parse_ohlcv(message)
+        client.resolve(ohlcv, messageHash)
+
     async def authenticate(self, params={}):
         self.check_required_credentials()
         wsOptions: dict = self.safe_dict(self.options, 'ws', {})
@@ -611,6 +652,7 @@ class upbit(ccxt.async_support.upbit):
             'trade': self.handle_trades,
             'myOrder': self.handle_my_order,
             'myAsset': self.handle_balance,
+            'candle.1s': self.handle_ohlcv,
         }
         methodName = self.safe_string(message, 'type')
         method = self.safe_value(methods, methodName)

ccxt/probit.py

@@ -563,6 +563,7 @@ class probit(Exchange, ImplicitAPI):
                 'active': active,
                 'deposit': deposit,
                 'withdraw': withdraw,
+                'type': 'crypto',
                 'fee': fee,
                 'precision': self.parse_number(self.parse_precision(self.safe_string(platform, 'precision'))),
                 'limits': {

ccxt/test/tests_async.py

@@ -348,7 +348,6 @@ class testMainClass:
             'fetchOHLCV': [symbol],
             'fetchTrades': [symbol],
             'fetchOrderBook': [symbol],
-            'fetchL2OrderBook': [symbol],
             'fetchOrderBooks': [],
             'fetchBidsAsks': [],
             'fetchStatus': [],
@@ -896,6 +895,8 @@ class testMainClass:
     async def test_request_statically(self, exchange, method, data, type, skip_keys):
         output = None
         request_url = None
+        if self.info:
+            dump('[INFO] STATIC REQUEST TEST:', method, ':', data['description'])
         try:
             if not is_sync():
                 await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
@@ -918,6 +919,8 @@ class testMainClass:
     async def test_response_statically(self, exchange, method, skip_keys, data):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
+        if self.info:
+            dump('[INFO] STATIC RESPONSE TEST:', method, ':', data['description'])
         try:
             if not is_sync():
                 unified_result = await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))