ccxt 4.4.43__py2.py3-none-any.whl → 4.4.45__py2.py3-none-any.whl

ccxt/gemini.py

@@ -329,6 +329,11 @@ class gemini(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': False,
+                        'iceberg': False,
                     },
                     'createOrders': None,
                     'fetchMyTrades': {

ccxt/hashkey.py

@@ -380,13 +380,11 @@ class hashkey(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
-                        # exchange-supported features
-                        # 'marketBuyRequiresPrice': False,
-                        # 'marketBuyByCost': False,
-                        # 'selfTradePrevention': True,
-                        # 'twap': False,
-                        # 'iceberg': False,
-                        # 'oco': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': True,  # todo fix
+                        'selfTradePrevention': True,  # todo implement
+                        'iceberg': False,
                     },
                     'createOrders': {
                         'max': 20,
@@ -1456,9 +1454,14 @@ class hashkey(Exchange, ImplicitAPI):
         if isBuyer is not None:
             side = 'buy' if isBuyer else 'sell'
         takerOrMaker = None
-        isMaker = self.safe_bool_n(trade, ['isMaker', 'isMarker', 'ibm'])
+        isMaker = self.safe_bool_n(trade, ['isMaker', 'isMarker'])
         if isMaker is not None:
             takerOrMaker = 'maker' if isMaker else 'taker'
+        isBuyerMaker = self.safe_bool(trade, 'ibm')
+        # if public trade
+        if isBuyerMaker is not None:
+            takerOrMaker = 'taker'
+            side = 'sell' if isBuyerMaker else 'buy'
         feeCost = self.safe_string(trade, 'commission')
         feeCurrncyId = self.safe_string(trade, 'commissionAsset')
         feeInfo = self.safe_dict(trade, 'fee')
@@ -2393,8 +2396,10 @@ class hashkey(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['spot']:
             raise NotSupported(self.id + ' createMarketBuyOrderWithCost() is supported for spot markets only')
-        params['cost'] = cost
-        return self.create_order(symbol, 'market', 'buy', cost, None, params)
+        req = {
+            'cost': cost,
+        }
+        return self.create_order(symbol, 'market', 'buy', cost, None, self.extend(req, params))
 
     def create_spot_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
         """

ccxt/htx.py

@@ -114,6 +114,7 @@ class htx(Exchange, ImplicitAPI):
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
                 'fetchOpenInterestHistory': True,
+                'fetchOpenInterests': True,
                 'fetchOpenOrder': None,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
@@ -1269,9 +1270,11 @@ class htx(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
-                        # exchange-specific features
                         'iceberg': False,
-                        'selfTradePrevention': True,
+                        'selfTradePrevention': True,  # todo implement
+                        'leverage': True,  # todo implement
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': True,
                     },
                     'createOrders': {
                         'max': 10,
@@ -1307,7 +1310,7 @@ class htx(Exchange, ImplicitAPI):
                         'trailing': False,
                         'untilDays': 2,
                         'limit': 500,
-                        'daysBackClosed': 180,
+                        'daysBack': 180,
                         'daysBackCanceled': 1 / 12,
                     },
                     'fetchOHLCV': {
@@ -1348,7 +1351,7 @@ class htx(Exchange, ImplicitAPI):
                         'trailing': False,
                         'untilDays': 2,
                         'limit': 50,
-                        'daysBackClosed': 90,
+                        'daysBack': 90,
                         'daysBackCanceled': 1 / 12,
                     },
                     'fetchOHLCV': {
@@ -8003,6 +8006,100 @@ class htx(Exchange, ImplicitAPI):
         tick = self.safe_list(data, 'tick')
         return self.parse_open_interests_history(tick, market, since, limit)
 
+    def fetch_open_interests(self, symbols: Strings = None, params={}):
+        """
+        Retrieves the open interest for a list of symbols
+
+        https://huobiapi.github.io/docs/dm/v1/en/#get-contract-open-interest-information
+        https://huobiapi.github.io/docs/coin_margined_swap/v1/en/#get-swap-open-interest-information
+        https://huobiapi.github.io/docs/usdt_swap/v1/en/#general-get-swap-open-interest-information
+
+        :param str[] [symbols]: a list of unified CCXT market symbols
+        :param dict [params]: exchange specific parameters
+        :returns dict[]: a list of `open interest structures <https://docs.ccxt.com/#/?id=open-interest-structure>`
+        """
+        self.load_markets()
+        symbols = self.market_symbols(symbols)
+        market = None
+        if symbols is not None:
+            symbolsLength = len(symbols)
+            if symbolsLength > 0:
+                first = self.safe_string(symbols, 0)
+                market = self.market(first)
+        request: dict = {}
+        subType = None
+        subType, params = self.handle_sub_type_and_params('fetchPositions', market, params, 'linear')
+        marketType = None
+        marketType, params = self.handle_market_type_and_params('fetchPositions', market, params)
+        response = None
+        if marketType == 'future':
+            response = self.contractPublicGetApiV1ContractOpenInterest(self.extend(request, params))
+            #
+            #     {
+            #         "status": "ok",
+            #         "data": [
+            #             {
+            #                 "volume": 118850.000000000000000000,
+            #                 "amount": 635.502025211544374189,
+            #                 "symbol": "BTC",
+            #                 "contract_type": "self_week",
+            #                 "contract_code": "BTC220930",
+            #                 "trade_amount": 1470.9400749347598691119206024033947897351,
+            #                 "trade_volume": 286286,
+            #                 "trade_turnover": 28628600.000000000000000000
+            #             }
+            #         ],
+            #         "ts": 1664337928805
+            #     }
+            #
+        elif subType == 'inverse':
+            response = self.contractPublicGetSwapApiV1SwapOpenInterest(self.extend(request, params))
+            #
+            #     {
+            #         "status": "ok",
+            #         "data": [
+            #             {
+            #                 "volume": 518018.000000000000000000,
+            #                 "amount": 2769.675777407074725180,
+            #                 "symbol": "BTC",
+            #                 "contract_code": "BTC-USD",
+            #                 "trade_amount": 9544.4032080046491323463688602729806842458,
+            #                 "trade_volume": 1848448,
+            #                 "trade_turnover": 184844800.000000000000000000
+            #             }
+            #         ],
+            #         "ts": 1664337226028
+            #     }
+            #
+        else:
+            request['contract_type'] = 'swap'
+            response = self.contractPublicGetLinearSwapApiV1SwapOpenInterest(self.extend(request, params))
+            #
+            #     {
+            #         "status": "ok",
+            #         "data": [
+            #             {
+            #                 "volume": 7192610.000000000000000000,
+            #                 "amount": 7192.610000000000000000,
+            #                 "symbol": "BTC",
+            #                 "value": 134654290.332000000000000000,
+            #                 "contract_code": "BTC-USDT",
+            #                 "trade_amount": 70692.804,
+            #                 "trade_volume": 70692804,
+            #                 "trade_turnover": 1379302592.9518,
+            #                 "business_type": "swap",
+            #                 "pair": "BTC-USDT",
+            #                 "contract_type": "swap",
+            #                 "trade_partition": "USDT"
+            #             }
+            #         ],
+            #         "ts": 1664336503144
+            #     }
+            #
+        data = self.safe_list(response, 'data', [])
+        result = self.parse_open_interests(data)
+        return self.filter_by_array(result, 'symbol', symbols)
+
     def fetch_open_interest(self, symbol: str, params={}):
         """
         Retrieves the open interest of a currency
@@ -8161,8 +8258,9 @@ class htx(Exchange, ImplicitAPI):
         timestamp = self.safe_integer(interest, 'ts')
         amount = self.safe_number(interest, 'volume')
         value = self.safe_number(interest, 'value')
+        marketId = self.safe_string(interest, 'contract_code')
         return self.safe_open_interest({
-            'symbol': self.safe_string(market, 'symbol'),
+            'symbol': self.safe_symbol(marketId, market),
             'baseVolume': amount,  # deprecated
             'quoteVolume': value,  # deprecated
             'openInterestAmount': amount,

ccxt/hyperliquid.py

@@ -246,6 +246,11 @@ class hyperliquid(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': False,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': False,
+                        'iceberg': False,
                     },
                     'createOrders': {
                         'max': 1000,
@@ -278,7 +283,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': False,
                         'limit': 2000,
-                        'daysBackClosed': None,
+                        'daysBack': None,
                         'daysBackCanceled': None,
                         'untilDays': None,
                         'trigger': False,

ccxt/kraken.py

@@ -464,6 +464,11 @@ class kraken(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': True,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': True,  # todo implement
+                        'iceberg': True,  # todo implement
                     },
                     'createOrders': None,
                     'fetchMyTrades': {
@@ -487,7 +492,7 @@ class kraken(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': False,
                         'limit': None,
-                        'daysBackClosed': None,
+                        'daysBack': None,
                         'daysBackCanceled': None,
                         'untilDays': 100000,
                         'trigger': False,
@@ -1483,8 +1488,10 @@ class kraken(Exchange, ImplicitAPI):
         """
         self.load_markets()
         # only buy orders are supported by the endpoint
-        params['cost'] = cost
-        return self.create_order(symbol, 'market', side, cost, None, params)
+        req = {
+            'cost': cost,
+        }
+        return self.create_order(symbol, 'market', side, 1, None, self.extend(req, params))
 
     def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """

ccxt/krakenfutures.py

@@ -299,6 +299,11 @@ class krakenfutures(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': False,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': False,
+                        'iceberg': False,
                     },
                     'createOrders': {
                         'max': 100,
@@ -320,7 +325,7 @@ class krakenfutures(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': False,
                         'limit': None,
-                        'daysBackClosed': None,
+                        'daysBack': None,
                         'daysBackCanceled': None,
                         'untilDays': None,
                         'trigger': False,

ccxt/kucoin.py

@@ -1025,11 +1025,11 @@ class kucoin(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
-                        # exchange-supported features
-                        # 'iceberg': True,
-                        # 'selfTradePrevention': True,
-                        # 'twap': False,
-                        # 'oco': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': True,  # todo implement
+                        'iceberg': True,  # todo implement
                     },
                     'createOrders': {
                         'max': 5,
@@ -1055,7 +1055,7 @@ class kucoin(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': True,
                         'limit': 500,
-                        'daysBackClosed': None,
+                        'daysBack': None,
                         'daysBackCanceled': None,
                         'untilDays': 7,
                         'trigger': True,
@@ -2285,8 +2285,10 @@ class kucoin(Exchange, ImplicitAPI):
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        params['cost'] = cost
-        return self.create_order(symbol, 'market', side, cost, None, params)
+        req = {
+            'cost': cost,
+        }
+        return self.create_order(symbol, 'market', side, 0, None, self.extend(req, params))
 
     def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """

ccxt/kucoinfutures.py

@@ -386,9 +386,8 @@ class kucoinfutures(kucoin, ImplicitAPI):
                         'stopLossPrice': True,
                         'takeProfitPrice': True,
                         'attachedStopLossTakeProfit': {
-                            'triggerPrice': None,
                             'triggerPriceType': None,
-                            'limitPrice': True,
+                            'price': True,
                         },
                         'timeInForce': {
                             'IOC': True,
@@ -398,11 +397,11 @@ class kucoinfutures(kucoin, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
-                        # exchange-supported features
-                        # 'iceberg': True,
-                        # 'selfTradePrevention': True,
-                        # 'twap': False,
-                        # 'oco': False,
+                        'leverage': True,  # todo implement
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': True,  # todo implement
+                        'iceberg': True,
                     },
                     'createOrders': {
                         'max': 20,
@@ -428,7 +427,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': False,
                         'limit': 1000,
-                        'daysBackClosed': None,
+                        'daysBack': None,
                         'daysBackCanceled': None,
                         'untilDays': None,
                         'trigger': True,

ccxt/lykke.py

@@ -209,7 +209,7 @@ class lykke(Exchange, ImplicitAPI):
         #     {
         #         "payload":[
         #             {
-        #                 "assetId":"115a60c2-0da1-40f9-a7f2-41da723b9074",
+        #                 "assetId":"115a60c2-0da1-40f9-a7f2-41da723b9075",
         #                 "name":"Monaco Token",
         #                 "symbol":"MCO",
         #                 "accuracy":6,

ccxt/mexc.py

@@ -709,10 +709,12 @@ class mexc(Exchange, ImplicitAPI):
                             'PO': True,
                             'GTD': False,
                         },
-                        'hedged': False,
-                        # exchange-supported features
-                        'selfTradePrevention': False,
+                        'hedged': True,  # todo implement
                         'trailing': False,
+                        'leverage': True,  # todo implement
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': False,
                         'iceberg': False,
                     },
                     'createOrders': {
@@ -746,7 +748,7 @@ class mexc(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': True,
                         'limit': 1000,
-                        'daysBackClosed': 7,
+                        'daysBack': 7,
                         'daysBackCanceled': 7,
                         'untilDays': 7,
                         'trigger': False,
@@ -768,14 +770,14 @@ class mexc(Exchange, ImplicitAPI):
                             'mark': True,
                             'index': True,
                         },
-                        'triggerDirection': True,
+                        'triggerDirection': True,  # todo
                         'stopLossPrice': False,  # todo
-                        'takeProfitPrice': False,
+                        'takeProfitPrice': False,  # todo
                         'hedged': True,
+                        'leverage': True,  # todo
+                        'marketBuyByCost': False,
                     },
-                    'createOrders': {
-                        'max': 50,
-                    },
+                    'createOrders': None,  # todo: needs implementation https://mexcdevelop.github.io/apidocs/contract_v1_en/#order-under-maintenance:~:text=Order%20the%20contract%20in%20batch
                     'fetchMyTrades': {
                         'marginMode': False,
                         'limit': 100,
@@ -802,7 +804,7 @@ class mexc(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': False,
                         'limit': 100,
-                        'daysBackClosed': 90,
+                        'daysBack': 90,
                         'daysBackCanceled': None,
                         'untilDays': 90,
                         'trigger': True,
@@ -2186,8 +2188,10 @@ class mexc(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['spot']:
             raise NotSupported(self.id + ' createMarketBuyOrderWithCost() supports spot orders only')
-        params['cost'] = cost
-        return self.create_order(symbol, 'market', 'buy', 0, None, params)
+        req = {
+            'cost': cost,
+        }
+        return self.create_order(symbol, 'market', 'buy', 0, None, self.extend(req, params))
 
     def create_market_sell_order_with_cost(self, symbol: str, cost: float, params={}):
         """
@@ -2204,8 +2208,10 @@ class mexc(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['spot']:
             raise NotSupported(self.id + ' createMarketBuyOrderWithCost() supports spot orders only')
-        params['cost'] = cost
-        return self.create_order(symbol, 'market', 'sell', 0, None, params)
+        req = {
+            'cost': cost,
+        }
+        return self.create_order(symbol, 'market', 'sell', 0, None, self.extend(req, params))
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """

ccxt/myokx.py

@@ -32,4 +32,12 @@ class myokx(okx, ImplicitAPI):
                     'rest': 'https://{hostname}',
                 },
             },
+            'has': {
+                'CORS': None,
+                'spot': True,
+                'margin': None,
+                'swap': False,
+                'future': False,
+                'option': False,
+            },
         })

ccxt/ndax.py

@@ -355,7 +355,7 @@ class ndax(Exchange, ImplicitAPI):
             #
             #     {
             #         "Authenticated": True,
-            #         "UserId":57765,
+            #         "UserId":57764,
             #         "SessionToken":"4a2a5857-c4e5-4fac-b09e-2c4c30b591a0"
             #     }
             #

ccxt/oceanex.py

@@ -497,7 +497,7 @@ class oceanex(Exchange, ImplicitAPI):
         #                  "funds":"6.0732952",
         #                  "market":"ethusdt",
         #                  "created_at":"2022-04-19T19:03:15Z",
-        #                  "created_on":1650394995,
+        #                  "created_on":1650394994,
         #                  "side":"bid"
         #              },
         #          ]

ccxt/okx.py

@@ -1206,7 +1206,6 @@ class okx(Exchange, ImplicitAPI):
                 'brokerId': 'e847386590ce4dBC',
             },
             'features': {
-                # https://www.okx.com/docs-v5/en/#order-book-trading-trade-post-place-order
                 'default': {
                     'sandbox': True,
                     'createOrder': {
@@ -1226,7 +1225,7 @@ class okx(Exchange, ImplicitAPI):
                                 'mark': True,
                                 'index': True,
                             },
-                            'limitPrice': True,
+                            'price': True,
                         },
                         'timeInForce': {
                             'IOC': True,
@@ -1235,12 +1234,12 @@ class okx(Exchange, ImplicitAPI):
                             'GTD': False,
                         },
                         'hedged': True,
-                        # even though the below params not unified yet, it's useful metadata for users to know that exchange supports them
-                        'selfTradePrevention': True,
                         'trailing': True,
-                        'twap': True,
-                        'iceberg': True,
-                        'oco': True,
+                        'iceberg': True,  # todo implement
+                        'leverage': False,
+                        'selfTradePrevention': True,  # todo implement
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
                     },
                     'createOrders': {
                         'max': 20,
@@ -1266,7 +1265,7 @@ class okx(Exchange, ImplicitAPI):
                     'fetchClosedOrders': {
                         'marginMode': False,
                         'limit': 100,
-                        'daysBackClosed': 90,  # 3 months
+                        'daysBack': 90,  # 3 months
                         'daysBackCanceled': 1 / 12,  # 2 hour
                         'untilDays': None,
                         'trigger': True,
@@ -1636,7 +1635,7 @@ class okx(Exchange, ImplicitAPI):
             'contractSize': self.safe_number(market, 'ctVal') if contract else None,
             'expiry': expiry,
             'expiryDatetime': self.iso8601(expiry),
-            'strike': strikePrice,
+            'strike': self.parse_number(strikePrice),
             'optionType': optionType,
             'created': self.safe_integer(market, 'listTime'),
             'precision': {
@@ -1835,7 +1834,7 @@ class okx(Exchange, ImplicitAPI):
                     }
             firstChain = self.safe_dict(chains, 0, {})
             result[code] = {
-                'info': None,
+                'info': chains,
                 'code': code,
                 'id': currencyId,
                 'name': self.safe_string(firstChain, 'name'),

ccxt/onetrading.py

@@ -865,7 +865,8 @@ class onetrading(Exchange, ImplicitAPI):
         #         {"instrument_code":"BTC_EUR","granularity":{"unit":"HOURS","period":1},"high":"9135.7","low":"9002.59","open":"9055.45","close":"9133.98","total_amount":"26.21919","volume":"238278.8724959","time":"2020-05-09T00:59:59.999Z","last_sequence":461521},
         #     ]
         #
-        return self.parse_ohlcvs(response, market, timeframe, since, limit)
+        ohlcv = self.safe_list(response, 'candlesticks')
+        return self.parse_ohlcvs(ohlcv, market, timeframe, since, limit)
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.43'
+__version__ = '4.4.45'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -3975,7 +3975,8 @@ class binance(ccxt.async_support.binance):
         if not rejected:
             client.reject(message, id)
         # reset connection if 5xx error
-        if self.safe_string(code, 0) == '5':
+        codeString = self.safe_string(error, 'code')
+        if (codeString is not None) and (codeString[0] == '5'):
             client.reset(message)
 
     def handle_message(self, client: Client, message):

ccxt/pro/bitcoincom.py

@@ -22,7 +22,10 @@ class bitcoincom(hitbtc):
             'urls': {
                 'logo': 'https://user-images.githubusercontent.com/1294454/97296144-514fa300-1861-11eb-952b-3d55d492200b.jpg',
                 'api': {
-                    'ws': 'wss://api.fmfw.io/api/2/ws',
+                    'ws': {
+                        'public': 'wss://api.fmfw.io/api/3/ws/public',
+                        'private': 'wss://api.fmfw.io/api/3/ws/trading',
+                    },
                 },
             },
             'fees': {

ccxt/pro/bitopro.py

@@ -77,7 +77,7 @@ class bitopro(ccxt.async_support.bitopro):
         if limit is None:
             endPart = market['id']
         else:
-            endPart = market['id'] + ':' + limit
+            endPart = market['id'] + ':' + self.number_to_string(limit)
         orderbook = await self.watch_public('order-books', messageHash, endPart)
         return orderbook.limit()
 

ccxt/pro/myokx.py

@@ -20,4 +20,9 @@ class myokx(okx):
                     'ws': 'wss://wseeapap.okx.com:8443/ws/v5',
                 },
             },
+            'has': {
+                'swap': False,
+                'future': False,
+                'option': False,
+            },
         })