ccxt 4.1.28__tar.gz → 4.1.30__tar.gz

{ccxt-4.1.28/ccxt.egg-info → ccxt-4.1.30}/PKG-INFO

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

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.1.28'
+__version__ = '4.1.30'
 
 # ----------------------------------------------------------------------------
 

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/abstract/bybit.py

@@ -427,6 +427,7 @@ class ImplicitAPI:
     private_post_v5_position_trading_stop = privatePostV5PositionTradingStop = Entry('v5/position/trading-stop', 'private', 'POST', {'cost': 5})
     private_post_v5_position_set_auto_add_margin = privatePostV5PositionSetAutoAddMargin = Entry('v5/position/set-auto-add-margin', 'private', 'POST', {'cost': 2.5})
     private_post_v5_position_add_margin = privatePostV5PositionAddMargin = Entry('v5/position/add-margin', 'private', 'POST', {'cost': 2.5})
+    private_post_v5_position_confirm_pending_mmr = privatePostV5PositionConfirmPendingMmr = Entry('v5/position/confirm-pending-mmr', 'private', 'POST', {'cost': 2.5})
     private_post_v5_account_upgrade_to_uta = privatePostV5AccountUpgradeToUta = Entry('v5/account/upgrade-to-uta', 'private', 'POST', {'cost': 2.5})
     private_post_v5_account_set_margin_mode = privatePostV5AccountSetMarginMode = Entry('v5/account/set-margin-mode', 'private', 'POST', {'cost': 2.5})
     private_post_v5_account_mmp_modify = privatePostV5AccountMmpModify = Entry('v5/account/mmp-modify', 'private', 'POST', {'cost': 2.5})

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/abstract/okex.py

@@ -190,6 +190,7 @@ class ImplicitAPI:
     private_post_sprd_order = privatePostSprdOrder = Entry('sprd/order', 'private', 'POST', {'cost': 1})
     private_post_sprd_cancel_order = privatePostSprdCancelOrder = Entry('sprd/cancel-order', 'private', 'POST', {'cost': 1})
     private_post_sprd_mass_cancel = privatePostSprdMassCancel = Entry('sprd/mass-cancel', 'private', 'POST', {'cost': 1})
+    private_post_sprd_amend_order = privatePostSprdAmendOrder = Entry('sprd/amend-order', 'private', 'POST', {'cost': 1})
     private_post_trade_order = privatePostTradeOrder = Entry('trade/order', 'private', 'POST', {'cost': 0.3333333333333333})
     private_post_trade_batch_orders = privatePostTradeBatchOrders = Entry('trade/batch-orders', 'private', 'POST', {'cost': 0.06666666666666667})
     private_post_trade_cancel_order = privatePostTradeCancelOrder = Entry('trade/cancel-order', 'private', 'POST', {'cost': 0.3333333333333333})

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/abstract/okex5.py

@@ -190,6 +190,7 @@ class ImplicitAPI:
     private_post_sprd_order = privatePostSprdOrder = Entry('sprd/order', 'private', 'POST', {'cost': 1})
     private_post_sprd_cancel_order = privatePostSprdCancelOrder = Entry('sprd/cancel-order', 'private', 'POST', {'cost': 1})
     private_post_sprd_mass_cancel = privatePostSprdMassCancel = Entry('sprd/mass-cancel', 'private', 'POST', {'cost': 1})
+    private_post_sprd_amend_order = privatePostSprdAmendOrder = Entry('sprd/amend-order', 'private', 'POST', {'cost': 1})
     private_post_trade_order = privatePostTradeOrder = Entry('trade/order', 'private', 'POST', {'cost': 0.3333333333333333})
     private_post_trade_batch_orders = privatePostTradeBatchOrders = Entry('trade/batch-orders', 'private', 'POST', {'cost': 0.06666666666666667})
     private_post_trade_cancel_order = privatePostTradeCancelOrder = Entry('trade/cancel-order', 'private', 'POST', {'cost': 0.3333333333333333})

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/abstract/okx.py

@@ -190,6 +190,7 @@ class ImplicitAPI:
     private_post_sprd_order = privatePostSprdOrder = Entry('sprd/order', 'private', 'POST', {'cost': 1})
     private_post_sprd_cancel_order = privatePostSprdCancelOrder = Entry('sprd/cancel-order', 'private', 'POST', {'cost': 1})
     private_post_sprd_mass_cancel = privatePostSprdMassCancel = Entry('sprd/mass-cancel', 'private', 'POST', {'cost': 1})
+    private_post_sprd_amend_order = privatePostSprdAmendOrder = Entry('sprd/amend-order', 'private', 'POST', {'cost': 1})
     private_post_trade_order = privatePostTradeOrder = Entry('trade/order', 'private', 'POST', {'cost': 0.3333333333333333})
     private_post_trade_batch_orders = privatePostTradeBatchOrders = Entry('trade/batch-orders', 'private', 'POST', {'cost': 0.06666666666666667})
     private_post_trade_cancel_order = privatePostTradeCancelOrder = Entry('trade/cancel-order', 'private', 'POST', {'cost': 0.3333333333333333})

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.1.28'
+__version__ = '4.1.30'
 
 # -----------------------------------------------------------------------------
 

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.1.28'
+__version__ = '4.1.30'
 
 # -----------------------------------------------------------------------------
 

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/async_support/base/ws/functions.py

@@ -9,7 +9,7 @@ import datetime
 
 
 def inflate(data):
-    return decompress(data, -MAX_WBITS).decode('utf-8')
+    return decompress(data, -MAX_WBITS)
 
 
 def inflate64(data):

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/async_support/bitget.py

@@ -50,7 +50,7 @@ class bitget(Exchange, ImplicitAPI):
             'has': {
                 'CORS': None,
                 'spot': True,
-                'margin': None,
+                'margin': True,
                 'swap': True,
                 'future': True,
                 'option': False,
@@ -65,6 +65,7 @@ class bitget(Exchange, ImplicitAPI):
                 'editOrder': True,
                 'fetchAccounts': False,
                 'fetchBalance': True,
+                'fetchBorrowInterest': True,
                 'fetchBorrowRate': True,
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
@@ -1488,19 +1489,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>`
         """
         await 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 = await self.publicMixGetMarketQueryPositionLever(self.extend(request, params))
+        elif marginMode == 'isolated':
+            request['symbol'] = market['info']['symbolName']
+            response = await 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 = await 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 = await self.publicMixGetMarketQueryPositionLever(self.extend(request, params))
+        #
+        # swap and future
         #
         #     {
         #         "code":"00000",
@@ -1517,10 +1542,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
         #
         #     [
         #         {
@@ -1530,22 +1595,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
 
     async def fetch_deposits(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
@@ -3168,12 +3267,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>`
         """
         await self.load_markets()
         ordersRequests = []
         symbol = None
+        marginMode = None
         for i in range(0, len(orders)):
             rawOrder = orders[i]
             marketId = self.safe_string(rawOrder, 'symbol')
@@ -3187,20 +3290,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 = await self.privateSpotPostTradeBatchOrders(request)
-        else:
+        if (market['swap']) or (market['future']):
             request['orderDataList'] = ordersRequests
             request['marginCoin'] = market['settleId']
             response = await self.privateMixPostOrderBatchOrders(request)
+        elif marginMode == 'isolated':
+            response = await self.privateMarginPostIsolatedOrderBatchPlaceOrder(request)
+        elif marginMode == 'cross':
+            response = await self.privateMarginPostCrossOrderBatchPlaceOrder(request)
+        else:
+            response = await self.privateSpotPostTradeBatchOrders(request)
         #
         # {
         #     "code": "00000",
@@ -5955,6 +6072,138 @@ class bitget(Exchange, ImplicitAPI):
             'info': info,
         }
 
+    async 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>`
+        """
+        await 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 = await self.privateMarginGetIsolatedInterestList(self.extend(request, params))
+        elif marginMode == 'cross':
+            response = await 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-4.1.28 → ccxt-4.1.30}/ccxt/async_support/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 = await getattr(self, method)(self.extend(request, params))
+            response = await self.privateDeleteOrdersPair(self.extend(request, params))
+        else:
+            response = await self.privateDeleteOrdersAll(self.extend(request, params))
         result = self.safe_value(response, 'data', {})
         #
         #     {

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/async_support/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):
     async 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>`
         """
         await 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 = await 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 = await 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)
 
     async def fetch_tickers(self, symbols: Optional[List[str]] = None, params={}):
         """

{ccxt-4.1.28 → ccxt-4.1.30}/ccxt/async_support/bybit.py

@@ -635,6 +635,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,
@@ -3072,8 +3073,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-4.1.28 → ccxt-4.1.30}/ccxt/async_support/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)
 
+    async 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)
+        await 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 = await self.v1PrivatePostPrivateCancelOrderList(self.extend(request, params))
+        result = self.safe_value(response, 'result', [])
+        return self.parse_orders(result, market, None, None, params)
+
     async def fetch_open_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all unfilled currently open orders