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

ccxt/coinone.py

@@ -330,6 +330,7 @@ class coinone(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
+                'type': 'crypto',
             }
         return result
 

ccxt/delta.py

@@ -357,6 +357,8 @@ class delta(Exchange, ImplicitAPI):
             base = self.safe_string(optionParts, 1)
             expiry = self.safe_string(optionParts, 3)
             optionType = self.safe_string(optionParts, 0)
+        if expiry is not None:
+            expiry = expiry[4:] + expiry[2:4] + expiry[0:2]
         settle = quote
         strike = self.safe_string(optionParts, 2)
         datetime = self.convert_expire_date(expiry)
@@ -567,6 +569,7 @@ class delta(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
+                'type': 'crypto',
             }
         return result
 

ccxt/deribit.py

@@ -655,6 +655,7 @@ class deribit(Exchange, ImplicitAPI):
                 'active': None,
                 'deposit': None,
                 'withdraw': None,
+                'type': 'crypto',
                 'fee': self.safe_number(currency, 'withdrawal_fee'),
                 'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'fee_precision'))),
                 'limits': {

ccxt/hollaex.py

@@ -493,6 +493,7 @@ class hollaex(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
+                'type': 'crypto',
             }
         return result
 

ccxt/htx.py

@@ -962,6 +962,7 @@ class htx(Exchange, ImplicitAPI):
             },
             'precisionMode': TICK_SIZE,
             'options': {
+                'include_OS_certificates': False,  # temporarily leave self, remove in future
                 'fetchMarkets': {
                     'types': {
                         'spot': True,
@@ -2172,14 +2173,14 @@ class htx(Exchange, ImplicitAPI):
         ask = None
         askVolume = None
         if 'bid' in ticker:
-            if isinstance(ticker['bid'], list):
+            if ticker['bid'] is not None and isinstance(ticker['bid'], list):
                 bid = self.safe_string(ticker['bid'], 0)
                 bidVolume = self.safe_string(ticker['bid'], 1)
             else:
                 bid = self.safe_string(ticker, 'bid')
                 bidVolume = self.safe_string(ticker, 'bidSize')
         if 'ask' in ticker:
-            if isinstance(ticker['ask'], list):
+            if ticker['ask'] is not None and isinstance(ticker['ask'], list):
                 ask = self.safe_string(ticker['ask'], 0)
                 askVolume = self.safe_string(ticker['ask'], 1)
             else:
@@ -3270,7 +3271,7 @@ class htx(Exchange, ImplicitAPI):
         #                        "withdrawQuotaPerYear": null,
         #                        "withdrawQuotaTotal": null,
         #                        "withdrawFeeType": "fixed",
-        #                        "transactFeeWithdraw": "11.1653",
+        #                        "transactFeeWithdraw": "11.1654",
         #                        "addrWithTag": False,
         #                        "addrDepositTag": False
         #                    }
@@ -3293,6 +3294,8 @@ class htx(Exchange, ImplicitAPI):
             chains = self.safe_value(entry, 'chains', [])
             networks: dict = {}
             instStatus = self.safe_string(entry, 'instStatus')
+            assetType = self.safe_string(entry, 'assetType')
+            type = assetType == 'crypto' if '1' else 'fiat'
             currencyActive = instStatus == 'normal'
             minPrecision = None
             minDeposit = None
@@ -3350,6 +3353,7 @@ class htx(Exchange, ImplicitAPI):
                 'withdraw': withdraw,
                 'fee': None,
                 'name': None,
+                'type': type,
                 'limits': {
                     'amount': {
                         'min': None,

ccxt/huobijp.py

@@ -1110,6 +1110,7 @@ class huobijp(Exchange, ImplicitAPI):
                 'withdraw': withdrawEnabled,
                 'fee': None,  # todo need to fetch from fee endpoint
                 'precision': precision,
+                'networks': None,
                 'limits': {
                     'amount': {
                         'min': precision,

ccxt/hyperliquid.py

@@ -379,6 +379,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'withdraw': None,
                 'networks': None,
                 'fee': None,
+                'type': 'crypto',
                 'limits': {
                     'amount': {
                         'min': None,

ccxt/kraken.py

@@ -864,12 +864,14 @@ class kraken(Exchange, ImplicitAPI):
             precision = self.parse_number(self.parse_precision(self.safe_string(currency, 'decimals')))
             # assumes all currencies are active except those listed above
             active = self.safe_string(currency, 'status') == 'enabled'
+            isFiat = code.find('.HOLD') >= 0
             result[code] = {
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': self.safe_string(currency, 'altname'),
                 'active': active,
+                'type': 'fiat' if isFiat else 'crypto',
                 'deposit': None,
                 'withdraw': None,
                 'fee': None,

ccxt/okx.py

@@ -4831,7 +4831,7 @@ class okx(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         self.load_markets()
-        rawNetwork = self.safe_string_upper(params, 'network')
+        rawNetwork = self.safe_string(params, 'network')  # some networks are like "Dora Vota Mainnet"
         params = self.omit(params, 'network')
         code = self.safe_currency_code(code)
         network = self.network_id_to_code(rawNetwork, code)

ccxt/poloniex.py

@@ -1203,6 +1203,7 @@ class poloniex(Exchange, ImplicitAPI):
                     'withdraw': withdrawEnabled,
                     'fee': self.parse_number(feeString),
                     'precision': None,
+                    'type': 'crypto',
                     'limits': {
                         'amount': {
                             'min': None,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.78'
+__version__ = '4.4.80'
 
 # ----------------------------------------------------------------------------
 

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,34 +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')
             # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD, are aliases
             market = self.safe_market(marketId)
-            messageHash = 'level2::' + market['id']
             symbol = market['symbol']
+            messageHash = 'level2::' + symbol
             subscription = self.safe_value(client.subscriptions, messageHash, {})
             limit = self.safe_integer(subscription, 'limit')
             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)
-            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)
+            # 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/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/test/tests_async.py

@@ -348,7 +348,6 @@ class testMainClass:
             'fetchOHLCV': [symbol],
             'fetchTrades': [symbol],
             'fetchOrderBook': [symbol],
-            'fetchL2OrderBook': [symbol],
             'fetchOrderBooks': [],
             'fetchBidsAsks': [],
             'fetchStatus': [],

ccxt/test/tests_sync.py

@@ -345,7 +345,6 @@ class testMainClass:
             'fetchOHLCV': [symbol],
             'fetchTrades': [symbol],
             'fetchOrderBook': [symbol],
-            'fetchL2OrderBook': [symbol],
             'fetchOrderBooks': [],
             'fetchBidsAsks': [],
             'fetchStatus': [],

ccxt/timex.py

@@ -1526,7 +1526,7 @@ class timex(Exchange, ImplicitAPI):
                 'cost': feeCost,
                 'currency': feeCurrency,
             }
-        return {
+        return self.safe_trade({
             'info': trade,
             'id': id,
             'timestamp': timestamp,
@@ -1540,7 +1540,7 @@ class timex(Exchange, ImplicitAPI):
             'cost': cost,
             'takerOrMaker': takerOrMaker,
             'fee': fee,
-        }
+        })
 
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
         #