ccxt 4.3.20__py2.py3-none-any.whl → 4.3.21__py2.py3-none-any.whl

ccxt/exmo.py

@@ -270,7 +270,7 @@ class exmo(Exchange, ImplicitAPI):
             margin['amount'] = amount
         return margin
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #      {}
         #

ccxt/gate.py

@@ -5678,7 +5678,7 @@ class gate(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' modifyMarginHelper() not support self market type')
         return self.parse_margin_modification(response, market)
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "value": "11.9257",

ccxt/hitbtc.py

@@ -3057,7 +3057,7 @@ class hitbtc(Exchange, ImplicitAPI):
             'type': type,
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         # addMargin/reduceMargin
         #

ccxt/hyperliquid.py

@@ -1544,14 +1544,17 @@ class hyperliquid(Exchange, ImplicitAPI):
         :param int [limit]: the maximum number of open orders structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.user]: user address, will default to self.walletAddress if not provided
+        :param str [params.method]: 'openOrders' or 'frontendOpenOrders' default is 'frontendOpenOrders'
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         userAddress = None
         userAddress, params = self.handle_public_address('fetchOpenOrders', params)
+        method = None
+        method, params = self.handle_option_and_params(params, 'fetchOpenOrders', 'method', 'frontendOpenOrders')
         self.load_markets()
         market = self.safe_market(symbol)
         request = {
-            'type': 'openOrders',
+            'type': method,
             'user': userAddress,
         }
         response = self.publicPostInfo(self.extend(request, params))
@@ -1725,6 +1728,25 @@ class hyperliquid(Exchange, ImplicitAPI):
         #           "oid":6195281425
         #        }
         #     }
+        # frontendOrder
+        # {
+        #     "children": [],
+        #     "cloid": null,
+        #     "coin": "BLUR",
+        #     "isPositionTpsl": False,
+        #     "isTrigger": True,
+        #     "limitPx": "0.5",
+        #     "oid": 8670487141,
+        #     "orderType": "Stop Limit",
+        #     "origSz": "20.0",
+        #     "reduceOnly": False,
+        #     "side": "B",
+        #     "sz": "20.0",
+        #     "tif": null,
+        #     "timestamp": 1715523663687,
+        #     "triggerCondition": "Price above 0.6",
+        #     "triggerPx": "0.6"
+        # }
         #
         entry = self.safe_dict_n(order, ['order', 'resting', 'filled'])
         if entry is None:
@@ -1755,7 +1777,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'lastTradeTimestamp': None,
             'lastUpdateTimestamp': None,
             'symbol': symbol,
-            'type': self.safe_string_lower(entry, 'orderType'),
+            'type': self.parse_order_type(self.safe_string_lower(entry, 'orderType')),
             'timeInForce': self.safe_string_upper(entry, 'tif'),
             'postOnly': None,
             'reduceOnly': self.safe_bool(entry, 'reduceOnly'),
@@ -2190,7 +2212,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'code': self.safe_string(response, 'status'),
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #    {
         #        'type': 'default'

ccxt/okx.py

@@ -269,6 +269,9 @@ class okx(Exchange, ImplicitAPI):
                         'sprd/books': 1 / 2,
                         'sprd/ticker': 1,
                         'sprd/public-trades': 1 / 5,
+                        'market/sprd-ticker': 2,
+                        'market/sprd-candles': 2,
+                        'market/sprd-history-candles': 2,
                         'tradingBot/grid/ai-param': 1,
                         'tradingBot/grid/min-investment': 1,
                         'tradingBot/public/rsi-back-testing': 1,
@@ -6235,7 +6238,7 @@ class okx(Exchange, ImplicitAPI):
             'status': 'ok' if (errorCode == '0') else 'failed',
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         # addMargin/reduceMargin
         #

ccxt/phemex.py

@@ -3790,7 +3790,7 @@ class phemex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "code": 0,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.20'
+__version__ = '4.3.21'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/kucoinfutures.py

@@ -4,7 +4,7 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 import ccxt.async_support
-from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
@@ -22,6 +22,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
                 'watchTickers': True,
                 'watchBidsAsks': True,
                 'watchTrades': True,
+                'watchOHLCV': True,
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchBalance': True,
@@ -32,6 +33,21 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
                 'watchOrderBookForSymbols': True,
             },
             'options': {
+                'timeframes': {
+                    '1m': '1min',
+                    '3m': '1min',
+                    '5m': '5min',
+                    '15m': '15min',
+                    '30m': '30min',
+                    '1h': '1hour',
+                    '2h': '2hour',
+                    '4h': '4hour',
+                    '8h': '8hour',
+                    '12h': '12hour',
+                    '1d': '1day',
+                    '1w': '1week',
+                    '1M': '1month',
+                },
                 'accountsByType': {
                     'swap': 'future',
                     'cross': 'margin',
@@ -540,6 +556,77 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         client.resolve(trades, messageHash)
         return message
 
+    async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/klines
+        watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        symbol = self.symbol(symbol)
+        url = await self.negotiate(False)
+        marketId = self.market_id(symbol)
+        timeframes = self.safe_dict(self.options, 'timeframes')
+        timeframeId = self.safe_string(timeframes, timeframe, timeframe)
+        topic = '/contractMarket/limitCandle:' + marketId + '_' + timeframeId
+        messageHash = 'ohlcv::' + symbol + '_' + timeframe
+        ohlcv = await self.subscribe(url, messageHash, topic, None, params)
+        if self.newUpdates:
+            limit = ohlcv.getLimit(symbol, limit)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
+
+    def handle_ohlcv(self, client: Client, message):
+        #
+        #    {
+        #        "topic":"/contractMarket/limitCandle:LTCUSDTM_1min",
+        #        "type":"message",
+        #        "data":{
+        #            "symbol":"LTCUSDTM",
+        #            "candles":[
+        #                "1715470980",
+        #                "81.38",
+        #                "81.38",
+        #                "81.38",
+        #                "81.38",
+        #                "61.0",
+        #                "61"
+        #            ],
+        #            "time":1715470994801
+        #        },
+        #        "subject":"candle.stick"
+        #    }
+        #
+        topic = self.safe_string(message, 'topic')
+        parts = topic.split('_')
+        timeframeId = self.safe_string(parts, 1)
+        data = self.safe_dict(message, 'data')
+        timeframes = self.safe_dict(self.options, 'timeframes')
+        timeframe = self.find_timeframe(timeframeId, timeframes)
+        marketId = self.safe_string(data, 'symbol')
+        symbol = self.safe_symbol(marketId)
+        messageHash = 'ohlcv::' + symbol + '_' + timeframe
+        ohlcv = self.safe_list(data, 'candles')
+        parsed = [
+            self.safe_integer(ohlcv, 0),
+            self.safe_number(ohlcv, 1),
+            self.safe_number(ohlcv, 2),
+            self.safe_number(ohlcv, 3),
+            self.safe_number(ohlcv, 4),
+            self.safe_number(ohlcv, 6),  # Note value 5 is incorrect and will be fixed in subsequent versions of kucoin
+        ]
+        self.ohlcvs[symbol] = self.safe_dict(self.ohlcvs, symbol, {})
+        if not (timeframe in self.ohlcvs[symbol]):
+            limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
+            self.ohlcvs[symbol][timeframe] = ArrayCacheByTimestamp(limit)
+        stored = self.ohlcvs[symbol][timeframe]
+        stored.append(parsed)
+        client.resolve(stored, messageHash)
+
     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
@@ -923,6 +1010,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         methods = {
             'level2': self.handle_order_book,
             'ticker': self.handle_ticker,
+            'candle.stick': self.handle_ohlcv,
             'tickerV2': self.handle_bid_ask,
             'availableBalance.change': self.handle_balance,
             'match': self.handle_trade,

ccxt/pro/woo.py

@@ -531,6 +531,16 @@ class woo(ccxt.async_support.woo):
         request = self.extend(subscribe, message)
         return await self.watch(url, messageHash, request, messageHash, subscribe)
 
+    async def watch_private_multiple(self, messageHashes, message, params={}):
+        await self.authenticate(params)
+        url = self.urls['api']['ws']['private'] + '/' + self.uid
+        requestId = self.request_id(url)
+        subscribe = {
+            'id': requestId,
+        }
+        request = self.extend(subscribe, message)
+        return await self.watch_multiple(url, messageHashes, request, messageHashes, subscribe)
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         :see: https://docs.woo.org/#executionreport
@@ -540,10 +550,13 @@ class woo(ccxt.async_support.woo):
         :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
+        :param bool [params.trigger]: True if trigger order
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        topic = 'executionreport'
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
+        topic = 'algoexecutionreportv2' if (trigger) else 'executionreport'
+        params = self.omit(params, ['stop', 'trigger'])
         messageHash = topic
         if symbol is not None:
             market = self.market(symbol)
@@ -562,15 +575,19 @@ class woo(ccxt.async_support.woo):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         :see: https://docs.woo.org/#executionreport
+        :see: https://docs.woo.org/#algoexecutionreportv2
         watches information on multiple trades made by the user
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param bool [params.trigger]: True if trigger order
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        topic = 'executionreport'
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
+        topic = 'algoexecutionreportv2' if (trigger) else 'executionreport'
+        params = self.omit(params, ['stop', 'trigger'])
         messageHash = 'myTrades'
         if symbol is not None:
             market = self.market(symbol)
@@ -692,14 +709,24 @@ class woo(ccxt.async_support.woo):
         #         }
         #     }
         #
-        order = self.safe_dict(message, 'data')
-        tradeId = self.safe_string(order, 'tradeId')
-        if (tradeId is not None) and (tradeId != '0'):
-            self.handle_my_trade(client, order)
-        self.handle_order(client, order)
+        topic = self.safe_string(message, 'topic')
+        data = self.safe_value(message, 'data')
+        if isinstance(data, list):
+            # algoexecutionreportv2
+            for i in range(0, len(data)):
+                order = data[i]
+                tradeId = self.omit_zero(self.safe_string(data, 'tradeId'))
+                if tradeId is not None:
+                    self.handle_my_trade(client, order)
+                self.handle_order(client, order, topic)
+        else:
+            # executionreport
+            tradeId = self.omit_zero(self.safe_string(data, 'tradeId'))
+            if tradeId is not None:
+                self.handle_my_trade(client, data)
+            self.handle_order(client, data, topic)
 
-    def handle_order(self, client: Client, message):
-        topic = 'executionreport'
+    def handle_order(self, client: Client, message, topic):
         parsed = self.parse_ws_order(message)
         symbol = self.safe_string(parsed, 'symbol')
         orderId = self.safe_string(parsed, 'id')
@@ -776,11 +803,14 @@ class woo(ccxt.async_support.woo):
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """
         await self.load_markets()
-        messageHash = ''
+        messageHashes = []
         symbols = self.market_symbols(symbols)
         if not self.is_empty(symbols):
-            messageHash = '::' + ','.join(symbols)
-        messageHash = 'positions' + messageHash
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append('positions::' + symbol)
+        else:
+            messageHashes.append('positions')
         url = self.urls['api']['ws']['private'] + '/' + self.uid
         client = self.client(url)
         self.set_positions_cache(client, symbols)
@@ -793,7 +823,7 @@ class woo(ccxt.async_support.woo):
             'event': 'subscribe',
             'topic': 'position',
         }
-        newPositions = await self.watch_private(messageHash, request, params)
+        newPositions = await self.watch_private_multiple(messageHashes, request, params)
         if self.newUpdates:
             return newPositions
         return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit, True)
@@ -862,15 +892,8 @@ class woo(ccxt.async_support.woo):
             position = self.parse_position(rawPosition, market)
             newPositions.append(position)
             cache.append(position)
-        messageHashes = self.find_message_hashes(client, 'positions::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            positions = self.filter_by_array(newPositions, 'symbol', symbols, False)
-            if not self.is_empty(positions):
-                client.resolve(positions, messageHash)
+            messageHash = 'positions::' + market['symbol']
+            client.resolve(position, messageHash)
         client.resolve(newPositions, 'positions')
 
     async def watch_balance(self, params={}) -> Balances:
@@ -978,6 +1001,7 @@ class woo(ccxt.async_support.woo):
             'kline': self.handle_ohlcv,
             'auth': self.handle_auth,
             'executionreport': self.handle_order_update,
+            'algoexecutionreportv2': self.handle_order_update,
             'trade': self.handle_trade,
             'balance': self.handle_balance,
             'position': self.handle_positions,

{ccxt-4.3.20.dist-info → ccxt-4.3.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.3.20
+Version: 4.3.21
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -264,13 +264,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.20/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.3.20/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.21/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.3.21/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.20/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.21/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: