ccxt 4.1.28__py2.py3-none-any.whl → 4.1.30__py2.py3-none-any.whl

ccxt/bitget.py

@@ -49,7 +49,7 @@ class bitget(Exchange, ImplicitAPI):
             'has': {
                 'CORS': None,
                 'spot': True,
-                'margin': None,
+                'margin': True,
                 'swap': True,
                 'future': True,
                 'option': False,
@@ -64,6 +64,7 @@ class bitget(Exchange, ImplicitAPI):
                 'editOrder': True,
                 'fetchAccounts': False,
                 'fetchBalance': True,
+                'fetchBorrowInterest': True,
                 'fetchBorrowRate': True,
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
@@ -1487,19 +1488,43 @@ class bitget(Exchange, ImplicitAPI):
         """
         retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes for a single market
         :see: https://bitgetlimited.github.io/apidoc/en/mix/#get-position-tier
+        :see: https://bitgetlimited.github.io/apidoc/en/margin/#get-isolated-tier-data
+        :see: https://bitgetlimited.github.io/apidoc/en/margin/#get-cross-tier-data
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the bitget api endpoint
+        :param str [params.marginMode]: for spot margin 'cross' or 'isolated', default is 'isolated'
+        :param str [params.code]: required for cross spot margin
         :returns dict: a `leverage tiers structure <https://github.com/ccxt/ccxt/wiki/Manual#leverage-tiers-structure>`
         """
         self.load_markets()
         request = {}
-        market = None
         market = self.market(symbol)
-        if market['spot']:
+        type = None
+        type, params = self.handle_market_type_and_params('fetchMarketLeverageTiers', market, params)
+        response = None
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('fetchMarketLeverageTiers', params, 'isolated')
+        if (type == 'swap') or (type == 'future'):
+            marketId = market['id']
+            parts = marketId.split('_')
+            productType = self.safe_string_upper(parts, 1)
+            request['symbol'] = marketId
+            request['productType'] = productType
+            response = self.publicMixGetMarketQueryPositionLever(self.extend(request, params))
+        elif marginMode == 'isolated':
+            request['symbol'] = market['info']['symbolName']
+            response = self.publicMarginGetIsolatedPublicTierData(self.extend(request, params))
+        elif marginMode == 'cross':
+            code = self.safe_string(params, 'code')
+            self.check_required_argument('fetchMarketLeverageTiers', code, 'code')
+            params = self.omit(params, 'code')
+            currency = self.currency(code)
+            request['coin'] = currency['code']
+            response = self.publicMarginGetCrossPublicTierData(self.extend(request, params))
+        else:
             raise BadRequest(self.id + ' fetchMarketLeverageTiers() symbol does not support market ' + symbol)
-        request['symbol'] = market['id']
-        request['productType'] = 'UMCBL'
-        response = self.publicMixGetMarketQueryPositionLever(self.extend(request, params))
+        #
+        # swap and future
         #
         #     {
         #         "code":"00000",
@@ -1516,10 +1541,50 @@ class bitget(Exchange, ImplicitAPI):
         #         "requestTime":1627292076687
         #     }
         #
-        result = self.safe_value(response, 'data')
+        # isolated
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "requestTime": 1698352496622,
+        #         "data": [
+        #             {
+        #                 "tier": "1",
+        #                 "symbol": "BTCUSDT",
+        #                 "leverage": "10",
+        #                 "baseCoin": "BTC",
+        #                 "quoteCoin": "USDT",
+        #                 "baseMaxBorrowableAmount": "3",
+        #                 "quoteMaxBorrowableAmount": "30000",
+        #                 "maintainMarginRate": "0.05",
+        #                 "initRate": "0.1111"
+        #             },
+        #         ]
+        #     }
+        #
+        # cross
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "requestTime": 1698352997077,
+        #         "data": [
+        #             {
+        #                 "tier": "1",
+        #                 "leverage": "3",
+        #                 "coin": "BTC",
+        #                 "maxBorrowableAmount": "26",
+        #                 "maintainMarginRate": "0.1"
+        #             }
+        #         ]
+        #     }
+        #
+        result = self.safe_value(response, 'data', [])
         return self.parse_market_leverage_tiers(result, market)
 
     def parse_market_leverage_tiers(self, info, market=None):
+        #
+        # swap and future
         #
         #     [
         #         {
@@ -1529,22 +1594,56 @@ class bitget(Exchange, ImplicitAPI):
         #             "leverage": 125,
         #             "keepMarginRate": "0.004"
         #         }
-        #     ],
+        #     ]
+        #
+        # isolated
+        #
+        #     [
+        #         {
+        #             "tier": "1",
+        #             "symbol": "BTCUSDT",
+        #             "leverage": "10",
+        #             "baseCoin": "BTC",
+        #             "quoteCoin": "USDT",
+        #             "baseMaxBorrowableAmount": "3",
+        #             "quoteMaxBorrowableAmount": "30000",
+        #             "maintainMarginRate": "0.05",
+        #             "initRate": "0.1111"
+        #         }
+        #     ]
+        #
+        # cross
+        #
+        #     [
+        #         {
+        #             "tier": "1",
+        #             "leverage": "3",
+        #             "coin": "BTC",
+        #             "maxBorrowableAmount": "26",
+        #             "maintainMarginRate": "0.1"
+        #         }
+        #     ]
         #
         tiers = []
+        minNotional = 0
         for i in range(0, len(info)):
             item = info[i]
-            minNotional = self.safe_number(item, 'startUnit')
-            maxNotional = self.safe_number(item, 'endUnit')
+            minimumNotional = self.safe_number(item, 'startUnit')
+            if minimumNotional is not None:
+                minNotional = minimumNotional
+            maxNotional = self.safe_number_n(item, ['endUnit', 'maxBorrowableAmount', 'baseMaxBorrowableAmount'])
+            marginCurrency = self.safe_string_2(item, 'coin', 'baseCoin')
+            currencyId = marginCurrency if (marginCurrency is not None) else market['base']
             tiers.append({
-                'tier': self.sum(i, 1),
-                'currency': market['base'],
+                'tier': self.safe_integer_2(item, 'level', 'tier'),
+                'currency': self.safe_currency_code(currencyId),
                 'minNotional': minNotional,
                 'maxNotional': maxNotional,
-                'maintenanceMarginRate': self.safe_number(item, 'keepMarginRate'),
+                'maintenanceMarginRate': self.safe_number_2(item, 'keepMarginRate', 'maintainMarginRate'),
                 'maxLeverage': self.safe_number(item, 'leverage'),
                 'info': item,
             })
+            minNotional = maxNotional
         return tiers
 
     def fetch_deposits(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
@@ -3167,12 +3266,16 @@ class bitget(Exchange, ImplicitAPI):
         create a list of trade orders(all orders should be of the same symbol)
         :see: https://bitgetlimited.github.io/apidoc/en/spot/#batch-order
         :see: https://bitgetlimited.github.io/apidoc/en/mix/#batch-order
+        :see: https://bitgetlimited.github.io/apidoc/en/margin/#isolated-batch-order
+        :see: https://bitgetlimited.github.io/apidoc/en/margin/#cross-batch-order
         :param array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+        :param dict [params]: extra parameters specific to the api endpoint
         :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
         """
         self.load_markets()
         ordersRequests = []
         symbol = None
+        marginMode = None
         for i in range(0, len(orders)):
             rawOrder = orders[i]
             marketId = self.safe_string(rawOrder, 'symbol')
@@ -3186,20 +3289,34 @@ class bitget(Exchange, ImplicitAPI):
             amount = self.safe_value(rawOrder, 'amount')
             price = self.safe_value(rawOrder, 'price')
             orderParams = self.safe_value(rawOrder, 'params', {})
+            marginResult = self.handle_margin_mode_and_params('createOrders', params)
+            currentMarginMode = marginResult[0]
+            if currentMarginMode is not None:
+                if marginMode is None:
+                    marginMode = currentMarginMode
+                else:
+                    if marginMode != currentMarginMode:
+                        raise BadRequest(self.id + ' createOrders() requires all orders to have the same margin mode(isolated or cross)')
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
             ordersRequests.append(orderRequest)
         market = self.market(symbol)
+        symbolRequest = (market['info']['symbolName']) if (marginMode is not None) else (market['id'])
         request = {
-            'symbol': market['id'],
+            'symbol': symbolRequest,
         }
         response = None
         if market['spot']:
             request['orderList'] = ordersRequests
-            response = self.privateSpotPostTradeBatchOrders(request)
-        else:
+        if (market['swap']) or (market['future']):
             request['orderDataList'] = ordersRequests
             request['marginCoin'] = market['settleId']
             response = self.privateMixPostOrderBatchOrders(request)
+        elif marginMode == 'isolated':
+            response = self.privateMarginPostIsolatedOrderBatchPlaceOrder(request)
+        elif marginMode == 'cross':
+            response = self.privateMarginPostCrossOrderBatchPlaceOrder(request)
+        else:
+            response = self.privateSpotPostTradeBatchOrders(request)
         #
         # {
         #     "code": "00000",
@@ -5954,6 +6071,138 @@ class bitget(Exchange, ImplicitAPI):
             'info': info,
         }
 
+    def fetch_borrow_interest(self, code: Optional[str] = None, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        fetch the interest owed by the user for borrowing currency for margin trading
+        :see: https://bitgetlimited.github.io/apidoc/en/margin/#get-isolated-interest-records
+        :see: https://bitgetlimited.github.io/apidoc/en/margin/#get-cross-interest-records
+        :param str [code]: unified currency code
+        :param str [symbol]: unified market symbol when fetching interest in isolated markets
+        :param int [since]: the earliest time in ms to fetch borrow interest for
+        :param int [limit]: the maximum number of structures to retrieve
+        :param dict [params]: extra parameters specific to the bitget api endpoint
+        :returns dict[]: a list of `borrow interest structures <https://github.com/ccxt/ccxt/wiki/Manual#borrow-interest-structure>`
+        """
+        self.load_markets()
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+        request = {}
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+            request['coin'] = currency['id']
+        if since is not None:
+            request['startTime'] = since
+        else:
+            request['startTime'] = self.milliseconds() - 7776000000
+        if limit is not None:
+            request['pageSize'] = limit
+        response = None
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('fetchBorrowInterest', params, 'cross')
+        if marginMode == 'isolated':
+            self.check_required_symbol('fetchBorrowInterest', symbol)
+            request['symbol'] = market['info']['symbolName']
+            response = self.privateMarginGetIsolatedInterestList(self.extend(request, params))
+        elif marginMode == 'cross':
+            response = self.privateMarginGetCrossInterestList(self.extend(request, params))
+        #
+        # isolated
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "requestTime": 1698282523888,
+        #         "data": {
+        #             "resultList": [
+        #                 {
+        #                     "interestId": "1100560904468705284",
+        #                     "interestCoin": "USDT",
+        #                     "interestRate": "0.000126279",
+        #                     "loanCoin": "USDT",
+        #                     "amount": "0.00000298",
+        #                     "type": "scheduled",
+        #                     "symbol": "BTCUSDT",
+        #                     "ctime": "1698120000000"
+        #                 },
+        #             ],
+        #             "maxId": "1100560904468705284",
+        #             "minId": "1096915487398965249"
+        #         }
+        #     }
+        #
+        # cross
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "requestTime": 1698282552126,
+        #         "data": {
+        #             "resultList": [
+        #                 {
+        #                     "interestId": "1099126154352799744",
+        #                     "interestCoin": "USDT",
+        #                     "interestRate": "0.000126279",
+        #                     "loanCoin": "USDT",
+        #                     "amount": "0.00002631",
+        #                     "type": "scheduled",
+        #                     "ctime": "1697778000000"
+        #                 },
+        #             ],
+        #             "maxId": "1099126154352799744",
+        #             "minId": "1096917004629716993"
+        #         }
+        #     }
+        #
+        data = self.safe_value(response, 'data', {})
+        rows = self.safe_value(data, 'resultList', [])
+        interest = self.parse_borrow_interests(rows, market)
+        return self.filter_by_currency_since_limit(interest, code, since, limit)
+
+    def parse_borrow_interest(self, info, market=None):
+        #
+        # isolated
+        #
+        #     {
+        #         "interestId": "1100560904468705284",
+        #         "interestCoin": "USDT",
+        #         "interestRate": "0.000126279",
+        #         "loanCoin": "USDT",
+        #         "amount": "0.00000298",
+        #         "type": "scheduled",
+        #         "symbol": "BTCUSDT",
+        #         "ctime": "1698120000000"
+        #     }
+        #
+        # cross
+        #
+        #     {
+        #         "interestId": "1099126154352799744",
+        #         "interestCoin": "USDT",
+        #         "interestRate": "0.000126279",
+        #         "loanCoin": "USDT",
+        #         "amount": "0.00002631",
+        #         "type": "scheduled",
+        #         "ctime": "1697778000000"
+        #     }
+        #
+        marketId = self.safe_string(info, 'symbol')
+        market = self.safe_market(marketId, market)
+        marginMode = 'isolated' if (marketId is not None) else 'cross'
+        timestamp = self.safe_integer(info, 'ctime')
+        return {
+            'symbol': self.safe_string(market, 'symbol'),
+            'marginMode': marginMode,
+            'currency': self.safe_currency_code(self.safe_string(info, 'interestCoin')),
+            'interest': self.safe_number(info, 'amount'),
+            'interestRate': self.safe_number(info, 'interestRate'),
+            'amountBorrowed': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'info': info,
+        }
+
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
         if not response:
             return None  # fallback to default error handler

ccxt/bitopro.py

@@ -1071,13 +1071,13 @@ class bitopro(Exchange, ImplicitAPI):
         request = {
             # 'pair': market['id'],  # optional
         }
-        # privateDeleteOrdersAll or privateDeleteOrdersPair
-        method = self.safe_string(self.options, 'privateDeleteOrdersPair', 'privateDeleteOrdersAll')
+        response = None
         if symbol is not None:
             market = self.market(symbol)
             request['pair'] = market['id']
-            method = 'privateDeleteOrdersPair'
-        response = getattr(self, method)(self.extend(request, params))
+            response = self.privateDeleteOrdersPair(self.extend(request, params))
+        else:
+            response = self.privateDeleteOrdersAll(self.extend(request, params))
         result = self.safe_value(response, 'data', {})
         #
         #     {

ccxt/bitrue.py

@@ -794,6 +794,16 @@ class bitrue(Exchange, ImplicitAPI):
         return orderbook
 
     def parse_ticker(self, ticker, market=None):
+        #
+        # fetchBidsAsks
+        #
+        #     {
+        #         "symbol": "LTCBTC",
+        #         "bidPrice": "4.00000000",
+        #         "bidQty": "431.00000000",
+        #         "askPrice": "4.00000200",
+        #         "askQty": "9.00000000"
+        #     }
         #
         # fetchTicker
         #
@@ -818,10 +828,10 @@ class bitrue(Exchange, ImplicitAPI):
             'datetime': None,
             'high': self.safe_string(ticker, 'high24hr'),
             'low': self.safe_string(ticker, 'low24hr'),
-            'bid': self.safe_string(ticker, 'highestBid'),
-            'bidVolume': None,
-            'ask': self.safe_string(ticker, 'lowestAsk'),
-            'askVolume': None,
+            'bid': self.safe_string_2(ticker, 'highestBid', 'bidPrice'),
+            'bidVolume': self.safe_string(ticker, 'bidQty'),
+            'ask': self.safe_string_2(ticker, 'lowestAsk', 'askPrice'),
+            'askVolume': self.safe_string(ticker, 'askQty'),
             'vwap': None,
             'open': None,
             'close': last,
@@ -941,23 +951,30 @@ class bitrue(Exchange, ImplicitAPI):
     def fetch_bids_asks(self, symbols: Optional[List[str]] = None, params={}):
         """
         fetches the bid and ask price and volume for multiple markets
+        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#symbol-order-book-ticker
         :param str[]|None symbols: unified symbols of the markets to fetch the bids and asks for, all markets are returned if not assigned
         :param dict [params]: extra parameters specific to the bitrue api endpoint
         :returns dict: a dictionary of `ticker structures <https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure>`
         """
         self.load_markets()
-        defaultType = self.safe_string_2(self.options, 'fetchBidsAsks', 'defaultType', 'spot')
-        type = self.safe_string(params, 'type', defaultType)
-        query = self.omit(params, 'type')
-        method = None
-        if type == 'future':
-            method = 'fapiPublicGetTickerBookTicker'
-        elif type == 'delivery':
-            method = 'dapiPublicGetTickerBookTicker'
-        else:
-            method = 'publicGetTickerBookTicker'
-        response = getattr(self, method)(query)
-        return self.parse_tickers(response, symbols)
+        symbols = self.market_symbols(symbols)
+        market = None
+        request = {}
+        if symbols is not None:
+            first = self.safe_string(symbols, 0)
+            market = self.market(first)
+            request['symbol'] = market['id']
+        response = self.v1PublicGetTickerBookTicker(self.extend(request, params))
+        #     {
+        #         "symbol": "LTCBTC",
+        #         "bidPrice": "4.00000000",
+        #         "bidQty": "431.00000000",
+        #         "askPrice": "4.00000200",
+        #         "askQty": "9.00000000"
+        #     }
+        data = {}
+        data[market['id']] = response
+        return self.parse_tickers(data, symbols)
 
     def fetch_tickers(self, symbols: Optional[List[str]] = None, params={}):
         """

ccxt/bybit.py

@@ -634,6 +634,7 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/position/trading-stop': 5,  # 10/s => cost = 50 / 10 = 5
                         'v5/position/set-auto-add-margin': 2.5,
                         'v5/position/add-margin': 2.5,
+                        'v5/position/confirm-pending-mmr': 2.5,
                         # account
                         'v5/account/upgrade-to-uta': 2.5,
                         'v5/account/set-margin-mode': 2.5,
@@ -3071,8 +3072,11 @@ class bybit(Exchange, ImplicitAPI):
         #         "time": 1672125441042
         #     }
         #
+        timestamp = self.safe_integer(response, 'time')
         result = {
             'info': response,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
         }
         responseResult = self.safe_value(response, 'result', {})
         currencyList = self.safe_value_n(responseResult, ['loanAccountList', 'list', 'balance'])

ccxt/cryptocom.py

@@ -50,6 +50,7 @@ class cryptocom(Exchange, ImplicitAPI):
                 'borrowMargin': True,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'cancelOrders': True,
                 'createOrder': True,
                 'createOrders': True,
                 'fetchAccounts': True,
@@ -1323,6 +1324,34 @@ class cryptocom(Exchange, ImplicitAPI):
         result = self.safe_value(response, 'result', {})
         return self.parse_order(result, market)
 
+    def cancel_orders(self, ids, symbol: Optional[str] = None, params={}):
+        """
+        cancel multiple orders
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#private-cancel-order-list-list
+        :param str[] ids: order ids
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the okx api endpoint
+        :returns dict: an list of `order structures <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
+        """
+        self.check_required_symbol('cancelOrders', symbol)
+        self.load_markets()
+        market = self.market(symbol)
+        orderRequests = []
+        for i in range(0, len(ids)):
+            id = ids[i]
+            order = {
+                'instrument_name': market['id'],
+                'order_id': str(id),
+            }
+            orderRequests.append(order)
+        request = {
+            'contingency_type': 'LIST',
+            'order_list': orderRequests,
+        }
+        response = self.v1PrivatePostPrivateCancelOrderList(self.extend(request, params))
+        result = self.safe_value(response, 'result', [])
+        return self.parse_orders(result, market, None, None, params)
+
     def fetch_open_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all unfilled currently open orders