ccxt 4.4.69__py2.py3-none-any.whl → 4.4.70__py2.py3-none-any.whl

ccxt/hyperliquid.py

@@ -1756,11 +1756,12 @@ class hyperliquid(Exchange, ImplicitAPI):
             isTrigger = (stopLossPrice or takeProfitPrice)
             reduceOnly = self.safe_bool(orderParams, 'reduceOnly', False)
             orderParams = self.omit(orderParams, ['slippage', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'clientOrderId', 'client_id', 'postOnly', 'reduceOnly'])
-            px = str(price)
+            px = self.number_to_string(price)
             if isMarket:
-                px = str(Precise.string_mul(price), Precise.string_add('1', slippage)) if (isBuy) else str(Precise.string_mul(price), Precise.string_sub('1', slippage))
+                px = Precise.string_mul(px, Precise.string_add('1', slippage)) if (isBuy) else Precise.string_mul(px, Precise.string_sub('1', slippage))
+                px = self.price_to_precision(symbol, px)
             else:
-                px = self.price_to_precision(symbol, str(price))
+                px = self.price_to_precision(symbol, px)
             sz = self.amount_to_precision(symbol, amount)
             orderType: dict = {}
             if isTrigger:
@@ -2242,6 +2243,10 @@ class hyperliquid(Exchange, ImplicitAPI):
             side = 'sell' if (side == 'A') else 'buy'
         totalAmount = self.safe_string_2(entry, 'origSz', 'totalSz')
         remaining = self.safe_string(entry, 'sz')
+        tif = self.safe_string_upper(entry, 'tif')
+        postOnly = None
+        if tif is not None:
+            postOnly = (tif == 'ALO')
         return self.safe_order({
             'info': order,
             'id': self.safe_string(entry, 'oid'),
@@ -2252,8 +2257,8 @@ class hyperliquid(Exchange, ImplicitAPI):
             'lastUpdateTimestamp': self.safe_integer(order, 'statusTimestamp'),
             'symbol': symbol,
             'type': self.parse_order_type(self.safe_string_lower(entry, 'orderType')),
-            'timeInForce': self.safe_string_upper(entry, 'tif'),
-            'postOnly': None,
+            'timeInForce': tif,
+            'postOnly': postOnly,
             'reduceOnly': self.safe_bool(entry, 'reduceOnly'),
             'side': side,
             'price': self.safe_string(entry, 'limitPx'),
@@ -2371,6 +2376,10 @@ class hyperliquid(Exchange, ImplicitAPI):
         if side is not None:
             side = 'sell' if (side == 'A') else 'buy'
         fee = self.safe_string(trade, 'fee')
+        takerOrMaker = None
+        crossed = self.safe_bool(trade, 'crossed')
+        if crossed is not None:
+            takerOrMaker = 'taker' if crossed else 'maker'
         return self.safe_trade({
             'info': trade,
             'timestamp': timestamp,
@@ -2380,7 +2389,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'order': self.safe_string(trade, 'oid'),
             'type': None,
             'side': side,
-            'takerOrMaker': None,
+            'takerOrMaker': takerOrMaker,
             'price': price,
             'amount': amount,
             'cost': None,
@@ -2927,7 +2936,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'tagTo': None,
             'tagFrom': None,
             'type': None,
-            'amount': self.safe_integer(delta, 'usdc'),
+            'amount': self.safe_number(delta, 'usdc'),
             'currency': None,
             'status': self.safe_string(transaction, 'status'),
             'updated': None,

ccxt/okx.py

@@ -332,7 +332,9 @@ class okx(Exchange, ImplicitAPI):
                         'trade/easy-convert-currency-list': 20,
                         'trade/easy-convert-history': 20,
                         'trade/one-click-repay-currency-list': 20,
+                        'trade/one-click-repay-currency-list-v2': 20,
                         'trade/one-click-repay-history': 20,
+                        'trade/one-click-repay-history-v2': 20,
                         'trade/account-rate-limit': 1,
                         # asset
                         'asset/currencies': 5 / 3,
@@ -489,6 +491,7 @@ class okx(Exchange, ImplicitAPI):
                         'trade/cancel-advance-algos': 1,
                         'trade/easy-convert': 20,
                         'trade/one-click-repay': 20,
+                        'trade/one-click-repay-v2': 20,
                         'trade/mass-cancel': 4,
                         'trade/cancel-all-after': 10,
                         # asset
@@ -3043,6 +3046,7 @@ class okx(Exchange, ImplicitAPI):
         :param str [params.trailingPercent]: the percent to trail away from the current market price
         :param str [params.tpOrdKind]: 'condition' or 'limit', the default is 'condition'
         :param bool [params.hedged]: *swap and future only* True for hedged mode, False for one way mode
+        :param str [params.marginMode]: 'cross' or 'isolated', the default is 'cross'
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.69'
+__version__ = '4.4.70'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitget.py

@@ -52,6 +52,10 @@ class bitget(ccxt.async_support.bitget):
                         'public': 'wss://ws.bitget.com/v2/ws/public',
                         'private': 'wss://ws.bitget.com/v2/ws/private',
                     },
+                    'demo': {
+                        'public': 'wss://wspap.bitget.com/v2/ws/public',
+                        'private': 'wss://wspap.bitget.com/v2/ws/private',
+                    },
                 },
             },
             'options': {
@@ -1125,7 +1129,7 @@ class bitget(ccxt.async_support.bitget):
             instType = 'SPOT'
         else:
             instType, params = self.get_inst_type(market, params)
-        if type == 'spot':
+        if type == 'spot' and (symbol is not None):
             subscriptionHash = subscriptionHash + ':' + symbol
         if isTrigger:
             subscriptionHash = subscriptionHash + ':stop'  # we don't want to re-use the same subscription hash for stop orders
@@ -1697,6 +1701,11 @@ class bitget(ccxt.async_support.bitget):
 
     async def watch_public(self, messageHash, args, params={}):
         url = self.urls['api']['ws']['public']
+        sandboxMode = self.safe_bool_2(self.options, 'sandboxMode', 'sandbox', False)
+        if sandboxMode:
+            instType = self.safe_string(args, 'instType')
+            if (instType != 'SCOIN-FUTURES') and (instType != 'SUSDT-FUTURES') and (instType != 'SUSDC-FUTURES'):
+                url = self.urls['api']['demo']['public']
         request: dict = {
             'op': 'subscribe',
             'args': [args],
@@ -1706,6 +1715,11 @@ class bitget(ccxt.async_support.bitget):
 
     async def un_watch_public(self, messageHash, args, params={}):
         url = self.urls['api']['ws']['public']
+        sandboxMode = self.safe_bool_2(self.options, 'sandboxMode', 'sandbox', False)
+        if sandboxMode:
+            instType = self.safe_string(args, 'instType')
+            if (instType != 'SCOIN-FUTURES') and (instType != 'SUSDT-FUTURES') and (instType != 'SUSDC-FUTURES'):
+                url = self.urls['api']['demo']['public']
         request: dict = {
             'op': 'unsubscribe',
             'args': [args],
@@ -1715,6 +1729,12 @@ class bitget(ccxt.async_support.bitget):
 
     async def watch_public_multiple(self, messageHashes, argsArray, params={}):
         url = self.urls['api']['ws']['public']
+        sandboxMode = self.safe_bool_2(self.options, 'sandboxMode', 'sandbox', False)
+        if sandboxMode:
+            argsArrayFirst = self.safe_dict(argsArray, 0, {})
+            instType = self.safe_string(argsArrayFirst, 'instType')
+            if (instType != 'SCOIN-FUTURES') and (instType != 'SUSDT-FUTURES') and (instType != 'SUSDC-FUTURES'):
+                url = self.urls['api']['demo']['public']
         request: dict = {
             'op': 'subscribe',
             'args': argsArray,
@@ -1724,7 +1744,7 @@ class bitget(ccxt.async_support.bitget):
 
     async def authenticate(self, params={}):
         self.check_required_credentials()
-        url = self.urls['api']['ws']['private']
+        url = self.safe_string(params, 'url')
         client = self.client(url)
         messageHash = 'authenticated'
         future = client.future(messageHash)
@@ -1750,8 +1770,13 @@ class bitget(ccxt.async_support.bitget):
         return await future
 
     async def watch_private(self, messageHash, subscriptionHash, args, params={}):
-        await self.authenticate()
         url = self.urls['api']['ws']['private']
+        sandboxMode = self.safe_bool_2(self.options, 'sandboxMode', 'sandbox', False)
+        if sandboxMode:
+            instType = self.safe_string(args, 'instType')
+            if (instType != 'SCOIN-FUTURES') and (instType != 'SUSDT-FUTURES') and (instType != 'SUSDC-FUTURES'):
+                url = self.urls['api']['demo']['private']
+        await self.authenticate({'url': url})
         request: dict = {
             'op': 'subscribe',
             'args': [args],

ccxt/pro/bybit.py

@@ -1494,6 +1494,7 @@ class bybit(ccxt.async_support.bybit):
         :param int [since]: the earliest time in ms to fetch liquidations for
         :param int [limit]: the maximum number of liquidation structures to retrieve
         :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :param str [params.method]: exchange specific method, supported: liquidation, allLiquidation
         :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
         """
         await self.load_markets()
@@ -1501,8 +1502,10 @@ class bybit(ccxt.async_support.bybit):
         symbol = market['symbol']
         url = await self.get_url_by_market_type(symbol, False, 'watchLiquidations', params)
         params = self.clean_params(params)
+        method = None
+        method, params = self.handle_option_and_params(params, 'watchLiquidations', 'method', 'liquidation')
         messageHash = 'liquidations::' + symbol
-        topic = 'liquidation.' + market['id']
+        topic = method + '.' + market['id']
         newLiquidation = await self.watch_topics(url, [messageHash], [topic], params)
         if self.newUpdates:
             return newLiquidation
@@ -1510,52 +1513,92 @@ class bybit(ccxt.async_support.bybit):
 
     def handle_liquidation(self, client: Client, message):
         #
-        #   {
-        #       "data": {
-        #           "price": "0.03803",
-        #           "side": "Buy",
-        #           "size": "1637",
-        #           "symbol": "GALAUSDT",
-        #           "updatedTime": 1673251091822
-        #       },
-        #       "topic": "liquidation.GALAUSDT",
-        #       "ts": 1673251091822,
-        #       "type": "snapshot"
-        #   }
+        #     {
+        #         "data": {
+        #             "price": "0.03803",
+        #             "side": "Buy",
+        #             "size": "1637",
+        #             "symbol": "GALAUSDT",
+        #             "updatedTime": 1673251091822
+        #         },
+        #         "topic": "liquidation.GALAUSDT",
+        #         "ts": 1673251091822,
+        #         "type": "snapshot"
+        #     }
         #
-        rawLiquidation = self.safe_dict(message, 'data', {})
-        marketId = self.safe_string(rawLiquidation, 'symbol')
-        market = self.safe_market(marketId, None, '', 'contract')
-        symbol = market['symbol']
-        liquidation = self.parse_ws_liquidation(rawLiquidation, market)
-        liquidations = self.safe_value(self.liquidations, symbol)
-        if liquidations is None:
-            limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
-            liquidations = ArrayCache(limit)
-        liquidations.append(liquidation)
-        self.liquidations[symbol] = liquidations
-        client.resolve([liquidation], 'liquidations')
-        client.resolve([liquidation], 'liquidations::' + symbol)
+        #     {
+        #         "topic": "allLiquidation.ROSEUSDT",
+        #         "type": "snapshot",
+        #         "ts": 1739502303204,
+        #         "data": [
+        #             {
+        #                 "T": 1739502302929,
+        #                 "s": "ROSEUSDT",
+        #                 "S": "Sell",
+        #                 "v": "20000",
+        #                 "p": "0.04499"
+        #             }
+        #         ]
+        #     }
+        #
+        if isinstance(message['data'], list):
+            rawLiquidations = self.safe_list(message, 'data', [])
+            for i in range(0, len(rawLiquidations)):
+                rawLiquidation = rawLiquidations[i]
+                marketId = self.safe_string(rawLiquidation, 's')
+                market = self.safe_market(marketId, None, '', 'contract')
+                symbol = market['symbol']
+                liquidation = self.parse_ws_liquidation(rawLiquidation, market)
+                liquidations = self.safe_value(self.liquidations, symbol)
+                if liquidations is None:
+                    limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
+                    liquidations = ArrayCache(limit)
+                liquidations.append(liquidation)
+                self.liquidations[symbol] = liquidations
+                client.resolve([liquidation], 'liquidations')
+                client.resolve([liquidation], 'liquidations::' + symbol)
+        else:
+            rawLiquidation = self.safe_dict(message, 'data', {})
+            marketId = self.safe_string(rawLiquidation, 'symbol')
+            market = self.safe_market(marketId, None, '', 'contract')
+            symbol = market['symbol']
+            liquidation = self.parse_ws_liquidation(rawLiquidation, market)
+            liquidations = self.safe_value(self.liquidations, symbol)
+            if liquidations is None:
+                limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
+                liquidations = ArrayCache(limit)
+            liquidations.append(liquidation)
+            self.liquidations[symbol] = liquidations
+            client.resolve([liquidation], 'liquidations')
+            client.resolve([liquidation], 'liquidations::' + symbol)
 
     def parse_ws_liquidation(self, liquidation, market=None):
         #
-        #    {
-        #        "price": "0.03803",
-        #        "side": "Buy",
-        #        "size": "1637",
-        #        "symbol": "GALAUSDT",
-        #        "updatedTime": 1673251091822
-        #    }
+        #     {
+        #         "price": "0.03803",
+        #         "side": "Buy",
+        #         "size": "1637",
+        #         "symbol": "GALAUSDT",
+        #         "updatedTime": 1673251091822
+        #     }
+        #
+        #     {
+        #         "T": 1739502302929,
+        #         "s": "ROSEUSDT",
+        #         "S": "Sell",
+        #         "v": "20000",
+        #         "p": "0.04499"
+        #     }
         #
-        marketId = self.safe_string(liquidation, 'symbol')
+        marketId = self.safe_string_2(liquidation, 'symbol', 's')
         market = self.safe_market(marketId, market, '', 'contract')
-        timestamp = self.safe_integer(liquidation, 'updatedTime')
+        timestamp = self.safe_integer_2(liquidation, 'updatedTime', 'T')
         return self.safe_liquidation({
             'info': liquidation,
             'symbol': market['symbol'],
-            'contracts': self.safe_number(liquidation, 'size'),
+            'contracts': self.safe_number_2(liquidation, 'size', 'v'),
             'contractSize': self.safe_number(market, 'contractSize'),
-            'price': self.safe_number(liquidation, 'price'),
+            'price': self.safe_number_2(liquidation, 'price', 'p'),
             'baseValue': None,
             'quoteValue': None,
             'timestamp': timestamp,
@@ -2318,6 +2361,7 @@ class bybit(ccxt.async_support.bybit):
             'user.openapi.perp.trade': self.handle_my_trades,
             'position': self.handle_positions,
             'liquidation': self.handle_liquidation,
+            'allLiquidation': self.handle_liquidation,
             'pong': self.handle_pong,
             'order.create': self.handle_order_ws,
             'order.amend': self.handle_order_ws,

ccxt/test/tests_async.py

@@ -765,8 +765,8 @@ class testMainClass:
                 self.assert_new_and_stored_output(exchange, skip_keys, new_item, stored_item, strict_type_check)
         else:
             # built-in types like strings, numbers, booleans
-            sanitized_new_output = None if (not new_output) else new_output  # we store undefined as nulls in the json file so we need to convert it back
-            sanitized_stored_output = None if (not stored_output) else stored_output
+            sanitized_new_output = None if (is_null_value(new_output)) else new_output  # we store undefined as nulls in the json file so we need to convert it back
+            sanitized_stored_output = None if (is_null_value(stored_output)) else stored_output
             new_output_string = str(sanitized_new_output) if sanitized_new_output else 'undefined'
             stored_output_string = str(sanitized_stored_output) if sanitized_stored_output else 'undefined'
             message_error = 'output value mismatch:' + new_output_string + ' != ' + stored_output_string
@@ -787,7 +787,7 @@ class testMainClass:
                 is_string = is_computed_string or is_stored_string
                 is_undefined = is_computed_undefined or is_stored_undefined  # undefined is a perfetly valid value
                 if is_boolean or is_string or is_undefined:
-                    if self.lang == 'C#':
+                    if (self.lang == 'C#') or (self.lang == 'GO'):
                         # tmp c# number comparsion
                         is_number = False
                         try:

ccxt/test/tests_sync.py

@@ -762,8 +762,8 @@ class testMainClass:
                 self.assert_new_and_stored_output(exchange, skip_keys, new_item, stored_item, strict_type_check)
         else:
             # built-in types like strings, numbers, booleans
-            sanitized_new_output = None if (not new_output) else new_output  # we store undefined as nulls in the json file so we need to convert it back
-            sanitized_stored_output = None if (not stored_output) else stored_output
+            sanitized_new_output = None if (is_null_value(new_output)) else new_output  # we store undefined as nulls in the json file so we need to convert it back
+            sanitized_stored_output = None if (is_null_value(stored_output)) else stored_output
             new_output_string = str(sanitized_new_output) if sanitized_new_output else 'undefined'
             stored_output_string = str(sanitized_stored_output) if sanitized_stored_output else 'undefined'
             message_error = 'output value mismatch:' + new_output_string + ' != ' + stored_output_string
@@ -784,7 +784,7 @@ class testMainClass:
                 is_string = is_computed_string or is_stored_string
                 is_undefined = is_computed_undefined or is_stored_undefined  # undefined is a perfetly valid value
                 if is_boolean or is_string or is_undefined:
-                    if self.lang == 'C#':
+                    if (self.lang == 'C#') or (self.lang == 'GO'):
                         # tmp c# number comparsion
                         is_number = False
                         try:

ccxt/tradeogre.py

@@ -140,7 +140,6 @@ class tradeogre(Exchange, ImplicitAPI):
                 },
                 'private': {
                     'get': {
-                        'account/balance': 1,
                         'account/balances': 1,
                         'account/order/{uuid}': 1,
                     },
@@ -150,6 +149,7 @@ class tradeogre(Exchange, ImplicitAPI):
                         'order/cancel': 1,
                         'orders': 1,
                         'account/orders': 1,
+                        'account/balance': 1,
                     },
                 },
             },
@@ -588,10 +588,26 @@ class tradeogre(Exchange, ImplicitAPI):
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.currency]: currency to fetch the balance for
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         self.load_markets()
-        response = self.privateGetAccountBalances(params)
+        response = None
+        currency = self.safe_string(params, 'currency')
+        if currency is not None:
+            response = self.privatePostAccountBalance(params)
+            singleCurrencyresult: dict = {
+                'info': response,
+            }
+            code = self.safe_currency_code(currency)
+            account = {
+                'total': self.safe_number(response, 'balance'),
+                'free': self.safe_number(response, 'available'),
+            }
+            singleCurrencyresult[code] = account
+            return self.safe_balance(singleCurrencyresult)
+        else:
+            response = self.privateGetAccountBalances(params)
         result = self.safe_dict(response, 'balances', {})
         return self.parse_balance(result)
 
@@ -744,11 +760,11 @@ class tradeogre(Exchange, ImplicitAPI):
             'side': self.safe_string(order, 'type'),
             'price': self.safe_string(order, 'price'),
             'triggerPrice': None,
-            'amount': self.safe_string(order, 'quantity'),
+            'amount': None,
             'cost': None,
             'average': None,
             'filled': self.safe_string(order, 'fulfilled'),
-            'remaining': None,
+            'remaining': self.safe_string(order, 'quantity'),
             'status': None,
             'fee': {
                 'currency': None,

{ccxt-4.4.69.dist-info → ccxt-4.4.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.69
+Version: 4.4.70
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -278,13 +278,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.4.69/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.69/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.70/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.70/dist/ccxt.browser.min.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.4.69/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.70/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object: