ccxt 4.4.42__py2.py3-none-any.whl → 4.4.44__py2.py3-none-any.whl

ccxt/async_support/coinbase.py

@@ -386,7 +386,7 @@ class coinbase(Exchange, ImplicitAPI):
                 'user_native_currency': 'USD',  # needed to get fees for v3
             },
             'features': {
-                'spot': {
+                'default': {
                     'sandbox': False,
                     'createOrder': {
                         'marginMode': True,
@@ -404,6 +404,11 @@ class coinbase(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
+                        'leverage': True,  # todo implement
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': True,
+                        'selfTradePrevention': False,
+                        'iceberg': False,
                     },
                     'createOrders': None,
                     'fetchMyTrades': {
@@ -444,21 +449,20 @@ class coinbase(Exchange, ImplicitAPI):
                         'limit': 350,
                     },
                 },
+                'spot': {
+                    'extends': 'default',
+                },
                 'swap': {
                     'linear': {
-                        'extends': 'spot',
-                    },
-                    'inverse': {
-                        'extends': 'spot',
+                        'extends': 'default',
                     },
+                    'inverse': None,
                 },
                 'future': {
                     'linear': {
-                        'extends': 'spot',
-                    },
-                    'inverse': {
-                        'extends': 'spot',
+                        'extends': 'default',
                     },
+                    'inverse': None,
                 },
             },
         })

ccxt/async_support/coinbaseinternational.py

@@ -265,7 +265,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                 },
             },
             'features': {
-                'spot': {
+                'default': {
                     'sandbox': True,
                     'createOrder': {
                         'marginMode': False,
@@ -284,6 +284,11 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': False,
+                        'marketBuyRequiresPrice': True,
+                        'selfTradePrevention': True,  # todo: implement
+                        'iceberg': False,
                     },
                     'createOrders': None,
                     'fetchMyTrades': {
@@ -309,21 +314,20 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                         'limit': 300,
                     },
                 },
+                'spot': {
+                    'extends': 'default',
+                },
                 'swap': {
                     'linear': {
-                        'extends': 'spot',
+                        'extends': 'default',
                     },
                     'inverse': {
-                        'extends': 'spot',
+                        'extends': 'default',
                     },
                 },
                 'future': {
-                    'linear': {
-                        'extends': 'spot',
-                    },
-                    'inverse': {
-                        'extends': 'spot',
-                    },
+                    'linear': None,
+                    'inverse': None,
                 },
             },
         })

ccxt/async_support/coincatch.py

@@ -848,8 +848,8 @@ class coincatch(Exchange, ImplicitAPI):
             settleId = self.safe_string(supportMarginCoins, 0)
             settle = self.safe_currency_code(settleId)
             suffix = ':' + settle
-            isLinear = baseId == settleId  # todo check
-            isInverse = quoteId == settleId  # todo check
+            isLinear = quoteId == settleId  # todo check
+            isInverse = baseId == settleId  # todo check
             if isLinear:
                 subType = 'linear'
             elif isInverse:

ccxt/async_support/coinex.py

@@ -533,11 +533,11 @@ class coinex(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
-                        # exchange-supported features
-                        # 'marketBuyRequiresPrice': True,
-                        # 'marketBuyByCost': True,
-                        # 'selfTradePrevention': True,
-                        # 'iceberg': True,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': True,
+                        'selfTradePrevention': True,  # todo: implement
+                        'iceberg': True,  # todo implement
                     },
                     'createOrders': {
                         'max': 5,

ccxt/async_support/cryptocom.py

@@ -389,10 +389,12 @@ class cryptocom(Exchange, ImplicitAPI):
                             'GTD': False,
                         },
                         'hedged': False,
-                        # exchange-supported features
-                        'selfTradePrevention': True,
+                        'selfTradePrevention': True,  # todo: implement
                         'trailing': False,
                         'iceberg': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': True,
                     },
                     'createOrders': {
                         'max': 10,

ccxt/async_support/defx.py

@@ -926,10 +926,10 @@ class defx(Exchange, ImplicitAPI):
         id = self.safe_string(trade, 'id')
         oid = self.safe_string(trade, 'orderId')
         takerOrMaker = self.safe_string_lower(trade, 'role')
-        buyerMaker = self.safe_string(trade, 'buyerMaker')
+        buyerMaker = self.safe_bool(trade, 'buyerMaker')
         side = self.safe_string_lower(trade, 'side')
         if buyerMaker is not None:
-            if buyerMaker == 'true':
+            if buyerMaker:
                 side = 'sell'
             else:
                 side = 'buy'

ccxt/async_support/delta.py

@@ -734,7 +734,7 @@ class delta(Exchange, ImplicitAPI):
             else:
                 # other markets(swap, futures, move, spread, irs) seem to use the step of '1' contract
                 amountPrecision = self.parse_number('1')
-            linear = (settle == base)
+            linear = (settle == quote)
             optionType = None
             symbol = base + '/' + quote
             if swap or future or option:

ccxt/async_support/gate.py

@@ -724,7 +724,7 @@ class gate(Exchange, ImplicitAPI):
                 },
             },
             'features': {
-                'spot': {
+                'default': {
                     'sandbox': True,
                     'createOrder': {
                         'marginMode': True,
@@ -743,9 +743,11 @@ class gate(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
-                        # exchange-specific features
-                        'iceberg': True,
-                        'selfTradePrevention': True,
+                        'iceberg': True,  # todo implement
+                        'selfTradePrevention': True,  # todo implement
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': True,
                     },
                     'createOrders': {
                         'max': 40,  # NOTE! max 10 per symbol
@@ -781,6 +783,9 @@ class gate(Exchange, ImplicitAPI):
                         'limit': 1000,
                     },
                 },
+                'spot': {
+                    'extends': 'default',
+                },
                 'forDerivatives': {
                     'extends': 'spot',
                     'createOrder': {

ccxt/async_support/gemini.py

@@ -311,6 +311,69 @@ class gemini(Exchange, ImplicitAPI):
                     },
                 },
             },
+            'features': {
+                'default': {
+                    'sandbox': True,
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPrice': True,
+                        'triggerPriceType': None,
+                        'triggerDirection': False,
+                        'stopLossPrice': False,  # todo
+                        'takeProfitPrice': False,  # todo
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'IOC': True,
+                            'FOK': True,
+                            'PO': True,
+                            'GTD': False,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': False,
+                        'iceberg': False,
+                    },
+                    'createOrders': None,
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'limit': 500,
+                        'daysBack': None,
+                        'untilDays': None,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': None,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOrders': None,
+                    'fetchClosedOrders': None,  # todo: implement
+                    'fetchOHLCV': {
+                        'limit': None,
+                    },
+                },
+                'spot': {
+                    'extends': 'default',
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'default',
+                    },
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
         })
 
     async def fetch_currencies(self, params={}) -> Currencies:
@@ -1431,8 +1494,8 @@ class gemini(Exchange, ImplicitAPI):
         }
         type = self.safe_string(params, 'type', type)
         params = self.omit(params, 'type')
-        triggerPrice = self.safe_string_n(params, ['stop_price', 'stopPrice'])
-        params = self.omit(params, ['stop_price', 'stopPrice', 'type'])
+        triggerPrice = self.safe_string_n(params, ['triggerPrice', 'stop_price', 'stopPrice'])
+        params = self.omit(params, ['triggerPrice', 'stop_price', 'stopPrice', 'type'])
         if type == 'stopLimit':
             raise ArgumentsRequired(self.id + ' createOrder() requires a triggerPrice parameter or a stop_price parameter for ' + type + ' orders')
         if triggerPrice is not None:

ccxt/async_support/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,
@@ -2393,8 +2391,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 await self.create_order(symbol, 'market', 'buy', cost, None, params)
+        req = {
+            'cost': cost,
+        }
+        return await self.create_order(symbol, 'market', 'buy', cost, None, self.extend(req, params))
 
     async def create_spot_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
         """

ccxt/async_support/htx.py

@@ -115,6 +115,7 @@ class htx(Exchange, ImplicitAPI):
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
                 'fetchOpenInterestHistory': True,
+                'fetchOpenInterests': True,
                 'fetchOpenOrder': None,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
@@ -1270,9 +1271,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,
@@ -8004,6 +8007,100 @@ class htx(Exchange, ImplicitAPI):
         tick = self.safe_list(data, 'tick')
         return self.parse_open_interests_history(tick, market, since, limit)
 
+    async 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>`
+        """
+        await 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 = await 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 = await 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 = await 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)
+
     async def fetch_open_interest(self, symbol: str, params={}):
         """
         Retrieves the open interest of a currency
@@ -8162,8 +8259,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/async_support/hyperliquid.py

@@ -32,7 +32,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'countries': [],
             'version': 'v1',
             'rateLimit': 50,  # 1200 requests per minute, 20 request per second
-            'certified': False,
+            'certified': True,
             'pro': True,
             'dex': True,
             'has': {
@@ -247,6 +247,11 @@ class hyperliquid(Exchange, ImplicitAPI):
                         },
                         'hedged': False,
                         'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': False,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': False,
+                        'iceberg': False,
                     },
                     'createOrders': {
                         'max': 1000,

ccxt/async_support/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': {
@@ -1483,8 +1488,10 @@ class kraken(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         # only buy orders are supported by the endpoint
-        params['cost'] = cost
-        return await self.create_order(symbol, 'market', side, cost, None, params)
+        req = {
+            'cost': cost,
+        }
+        return await self.create_order(symbol, 'market', side, 1, None, self.extend(req, params))
 
     async def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """

ccxt/async_support/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,

ccxt/async_support/kucoin.py

@@ -1026,11 +1026,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,
@@ -2286,8 +2286,10 @@ class kucoin(Exchange, ImplicitAPI):
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        params['cost'] = cost
-        return await self.create_order(symbol, 'market', side, cost, None, params)
+        req = {
+            'cost': cost,
+        }
+        return await self.create_order(symbol, 'market', side, 0, None, self.extend(req, params))
 
     async def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """

ccxt/async_support/kucoinfutures.py

@@ -398,11 +398,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,

ccxt/async_support/mexc.py

@@ -710,10 +710,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': {
@@ -769,14 +771,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,
@@ -2187,8 +2189,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 await self.create_order(symbol, 'market', 'buy', 0, None, params)
+        req = {
+            'cost': cost,
+        }
+        return await self.create_order(symbol, 'market', 'buy', 0, None, self.extend(req, params))
 
     async def create_market_sell_order_with_cost(self, symbol: str, cost: float, params={}):
         """
@@ -2205,8 +2209,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 await self.create_order(symbol, 'market', 'sell', 0, None, params)
+        req = {
+            'cost': cost,
+        }
+        return await self.create_order(symbol, 'market', 'sell', 0, None, self.extend(req, params))
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """