ccxt 4.4.61__py2.py3-none-any.whl → 4.4.63__py2.py3-none-any.whl

ccxt/async_support/bybit.py

@@ -74,7 +74,9 @@ class bybit(Exchange, ImplicitAPI):
                 'createTrailingAmountOrder': True,
                 'createTriggerOrder': True,
                 'editOrder': True,
+                'editOrders': True,
                 'fetchBalance': True,
+                'fetchBidsAsks': 'emulated',
                 'fetchBorrowInterest': False,  # temporarily disabled, doesn't work
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
@@ -255,6 +257,7 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/spot-lever-token/reference': 5,
                         # spot margin trade
                         'v5/spot-margin-trade/data': 5,
+                        'v5/spot-margin-trade/collateral': 5,
                         'v5/spot-cross-margin-trade/data': 5,
                         'v5/spot-cross-margin-trade/pledge-token': 5,
                         'v5/spot-cross-margin-trade/borrow-token': 5,
@@ -1240,6 +1243,9 @@ class bybit(Exchange, ImplicitAPI):
                     'fetchOHLCV': {
                         'limit': 1000,
                     },
+                    'editOrders': {
+                        'max': 10,
+                    },
                 },
                 'spot': {
                     'extends': 'default',
@@ -1340,7 +1346,7 @@ class bybit(Exchange, ImplicitAPI):
                 # so we're assuming UTA is enabled
                 self.options['enableUnifiedMargin'] = False
                 self.options['enableUnifiedAccount'] = True
-                self.options['unifiedMarginStatus'] = 3
+                self.options['unifiedMarginStatus'] = 6
                 return [self.options['enableUnifiedMargin'], self.options['enableUnifiedAccount']]
             rawPromises = [self.privateGetV5UserQueryApi(params), self.privateGetV5AccountInfo(params)]
             promises = await asyncio.gather(*rawPromises)
@@ -1405,7 +1411,7 @@ class bybit(Exchange, ImplicitAPI):
             accountResult = self.safe_dict(accountInfo, 'result', {})
             self.options['enableUnifiedMargin'] = self.safe_integer(result, 'unified') == 1
             self.options['enableUnifiedAccount'] = self.safe_integer(result, 'uta') == 1
-            self.options['unifiedMarginStatus'] = self.safe_integer(accountResult, 'unifiedMarginStatus', 3)  # default to uta.1 if not found
+            self.options['unifiedMarginStatus'] = self.safe_integer(accountResult, 'unifiedMarginStatus', 6)  # default to uta 2.0 pro if not found
         return [self.options['enableUnifiedMargin'], self.options['enableUnifiedAccount']]
 
     async def upgrade_unified_trade_account(self, params={}):
@@ -2463,6 +2469,20 @@ class bybit(Exchange, ImplicitAPI):
         tickerList = self.safe_list(result, 'list', [])
         return self.parse_tickers(tickerList, parsedSymbols)
 
+    async def fetch_bids_asks(self, symbols: Strings = None, params={}):
+        """
+        fetches the bid and ask price and volume for multiple markets
+
+        https://bybit-exchange.github.io/docs/v5/market/tickers
+
+        :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 exchange API endpoint
+        :param str [params.subType]: *contract only* 'linear', 'inverse'
+        :param str [params.baseCoin]: *option only* base coin, default is 'BTC'
+        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        return await self.fetch_tickers(symbols, params)
+
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
         #
         #     [
@@ -3284,7 +3304,7 @@ class bybit(Exchange, ImplicitAPI):
         isInverse = (type == 'inverse')
         isFunding = (lowercaseRawType == 'fund') or (lowercaseRawType == 'funding')
         if isUnifiedAccount:
-            unifiedMarginStatus = self.safe_integer(self.options, 'unifiedMarginStatus', 3)
+            unifiedMarginStatus = self.safe_integer(self.options, 'unifiedMarginStatus', 6)
             if unifiedMarginStatus < 5:
                 # it's not uta.20 where inverse are unified
                 if isInverse:
@@ -3985,13 +4005,15 @@ class bybit(Exchange, ImplicitAPI):
             price = self.safe_value(rawOrder, 'price')
             orderParams = self.safe_dict(rawOrder, 'params', {})
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams, isUta)
+            del orderRequest['category']
             ordersRequests.append(orderRequest)
         symbols = self.market_symbols(orderSymbols, None, False, True, True)
         market = self.market(symbols[0])
+        unifiedMarginStatus = self.safe_integer(self.options, 'unifiedMarginStatus', 6)
         category = None
         category, params = self.get_bybit_type('createOrders', market, params)
-        if category == 'inverse':
-            raise NotSupported(self.id + ' createOrders does not allow inverse orders')
+        if (category == 'inverse') and (unifiedMarginStatus < 5):
+            raise NotSupported(self.id + ' createOrders does not allow inverse orders for non UTA2.0 account')
         request: dict = {
             'category': category,
             'request': ordersRequests,
@@ -4158,6 +4180,91 @@ class bybit(Exchange, ImplicitAPI):
             'id': self.safe_string(result, 'orderId'),
         })
 
+    async def edit_orders(self, orders: List[OrderRequest], params={}):
+        """
+        edit a list of trade orders
+
+        https://bybit-exchange.github.io/docs/v5/order/batch-amend
+
+        :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 exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        ordersRequests = []
+        orderSymbols = []
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            symbol = self.safe_string(rawOrder, 'symbol')
+            orderSymbols.append(symbol)
+            id = self.safe_string(rawOrder, 'id')
+            type = self.safe_string(rawOrder, 'type')
+            side = self.safe_string(rawOrder, 'side')
+            amount = self.safe_value(rawOrder, 'amount')
+            price = self.safe_value(rawOrder, 'price')
+            orderParams = self.safe_dict(rawOrder, 'params', {})
+            orderRequest = self.edit_order_request(id, symbol, type, side, amount, price, orderParams)
+            del orderRequest['category']
+            ordersRequests.append(orderRequest)
+        orderSymbols = self.market_symbols(orderSymbols, None, False, True, True)
+        market = self.market(orderSymbols[0])
+        unifiedMarginStatus = self.safe_integer(self.options, 'unifiedMarginStatus', 6)
+        category = None
+        category, params = self.get_bybit_type('editOrders', market, params)
+        if (category == 'inverse') and (unifiedMarginStatus < 5):
+            raise NotSupported(self.id + ' editOrders does not allow inverse orders for non UTA2.0 account')
+        request: dict = {
+            'category': category,
+            'request': ordersRequests,
+        }
+        response = await self.privatePostV5OrderAmendBatch(self.extend(request, params))
+        result = self.safe_dict(response, 'result', {})
+        data = self.safe_list(result, 'list', [])
+        retInfo = self.safe_dict(response, 'retExtInfo', {})
+        codes = self.safe_list(retInfo, 'list', [])
+        # self.extend the error with the unsuccessful orders
+        for i in range(0, len(codes)):
+            code = codes[i]
+            retCode = self.safe_integer(code, 'code')
+            if retCode != 0:
+                data[i] = self.extend(data[i], code)
+        #
+        # {
+        #     "retCode": 0,
+        #     "retMsg": "OK",
+        #     "result": {
+        #         "list": [
+        #             {
+        #                 "category": "option",
+        #                 "symbol": "ETH-30DEC22-500-C",
+        #                 "orderId": "b551f227-7059-4fb5-a6a6-699c04dbd2f2",
+        #                 "orderLinkId": ""
+        #             },
+        #             {
+        #                 "category": "option",
+        #                 "symbol": "ETH-30DEC22-700-C",
+        #                 "orderId": "fa6a595f-1a57-483f-b9d3-30e9c8235a52",
+        #                 "orderLinkId": ""
+        #             }
+        #         ]
+        #     },
+        #     "retExtInfo": {
+        #         "list": [
+        #             {
+        #                 "code": 0,
+        #                 "msg": "OK"
+        #             },
+        #             {
+        #                 "code": 0,
+        #                 "msg": "OK"
+        #             }
+        #         ]
+        #     },
+        #     "time": 1672222808060
+        # }
+        #
+        return self.parse_orders(data)
+
     def cancel_order_request(self, id: str, symbol: Str = None, params={}):
         market = self.market(symbol)
         request: dict = {

ccxt/async_support/gate.py

@@ -24,7 +24,6 @@ from ccxt.base.errors import OrderImmediatelyFillable
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import BadResponse
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
@@ -1798,100 +1797,80 @@ class gate(Exchange, ImplicitAPI):
             await self.load_unified_status()
         response = await self.publicSpotGetCurrencies(params)
         #
-        #    {
-        #        "currency": "BCN",
-        #        "delisted": False,
-        #        "withdraw_disabled": True,
-        #        "withdraw_delayed": False,
-        #        "deposit_disabled": True,
-        #        "trade_disabled": False
-        #    }
-        #
-        #    {
-        #        "currency":"USDT_ETH",
-        #        "delisted":false,
-        #        "withdraw_disabled":false,
-        #        "withdraw_delayed":false,
-        #        "deposit_disabled":false,
-        #        "trade_disabled":false,
-        #        "chain":"ETH"
-        #    }
-        #
+        #  [
+        #   {
+        #       "currency": "USDT_ETH",
+        #       "name": "Tether",
+        #       "delisted": False,
+        #       "withdraw_disabled": False,
+        #       "withdraw_delayed": False,
+        #       "deposit_disabled": False,
+        #       "trade_disabled": True,
+        #       "chain": "ETH"
+        #    },
+        #  ]
+        #
+        indexedCurrencies = self.index_by(response, 'currency')
         result: dict = {}
         for i in range(0, len(response)):
             entry = response[i]
             currencyId = self.safe_string(entry, 'currency')
-            currencyIdLower = self.safe_string_lower(entry, 'currency')
             parts = currencyId.split('_')
-            currency = parts[0]
-            code = self.safe_currency_code(currency)
-            networkId = self.safe_string(entry, 'chain')
-            networkCode = None
-            if networkId is not None:
-                networkCode = self.network_id_to_code(networkId, code)
-            delisted = self.safe_value(entry, 'delisted')
-            withdrawDisabled = self.safe_bool(entry, 'withdraw_disabled', False)
-            depositDisabled = self.safe_bool(entry, 'deposit_disabled', False)
-            tradeDisabled = self.safe_bool(entry, 'trade_disabled', False)
-            withdrawEnabled = not withdrawDisabled
-            depositEnabled = not depositDisabled
-            tradeEnabled = not tradeDisabled
-            listed = not delisted
-            active = listed and tradeEnabled and withdrawEnabled and depositEnabled
-            if self.safe_value(result, code) is None:
+            partFirst = self.safe_string(parts, 0)
+            # if there's an underscore then the second part is always the chain name(except the _OLD suffix)
+            currencyName = currencyId if currencyId.endswith('_OLD') else partFirst
+            withdrawEnabled = not self.safe_bool(entry, 'withdraw_disabled')
+            depositEnabled = not self.safe_bool(entry, 'deposit_disabled')
+            tradeDisabled = not self.safe_bool(entry, 'trade_disabled')
+            precision = self.parse_number('0.0001')  # temporary safe default, because no value provided from API
+            code = self.safe_currency_code(currencyName)
+            # check leveraged tokens(e.g. BTC3S, ETH5L)
+            isLeveragedToken = False
+            if currencyId.endswith('3S') or currencyId.endswith('3L') or currencyId.endswith('5S') or currencyId.endswith('5L'):
+                realCurrencyId = currencyId[0:-2]
+                if realCurrencyId in indexedCurrencies:
+                    isLeveragedToken = True
+            type = 'leveraged' if isLeveragedToken else 'crypto'
+            # some networks are null, they are mostly obsolete & unsupported dead tokens, so we can default their networkId to their tokenname
+            networkId = self.safe_string(entry, 'chain', currencyId)
+            networkCode = self.network_id_to_code(networkId, code)
+            networkEntry = {
+                'info': entry,
+                'id': networkId,
+                'network': networkCode,
+                'limits': {
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'active': not tradeDisabled,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
+                'fee': None,
+                'precision': precision,
+            }
+            # check if first entry for the specific currency
+            if not (code in result):
                 result[code] = {
-                    'id': currency,
+                    'id': currencyName,
+                    'lowerCaseId': currencyName.lower(),
                     'code': code,
-                    'info': None,
-                    'name': None,
-                    'active': active,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'fee': None,
-                    'fees': [],
-                    'precision': self.parse_number('1e-4'),
+                    'type': type,
+                    'precision': precision,
                     'limits': self.limits,
                     'networks': {},
+                    'info': [],  # will be filled below
                 }
-            depositAvailable = self.safe_value(result[code], 'deposit')
-            depositAvailable = depositEnabled if (depositEnabled) else depositAvailable
-            withdrawAvailable = self.safe_value(result[code], 'withdraw')
-            withdrawAvailable = withdrawEnabled if (withdrawEnabled) else withdrawAvailable
-            networks = self.safe_value(result[code], 'networks', {})
-            if networkCode is not None:
-                networks[networkCode] = {
-                    'info': entry,
-                    'id': networkId,
-                    'network': networkCode,
-                    'currencyId': currencyId,
-                    'lowerCaseCurrencyId': currencyIdLower,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'active': active,
-                    'fee': None,
-                    'precision': self.parse_number('1e-4'),
-                    'limits': {
-                        'amount': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'withdraw': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'deposit': {
-                            'min': None,
-                            'max': None,
-                        },
-                    },
-                }
-            result[code]['networks'] = networks
-            info = self.safe_value(result[code], 'info', [])
+            result[code]['networks'][networkCode] = networkEntry
+            info = self.safe_list(result[code], 'info', [])
             info.append(entry)
             result[code]['info'] = info
-            result[code]['active'] = depositAvailable and withdrawAvailable
-            result[code]['deposit'] = depositAvailable
-            result[code]['withdraw'] = withdrawAvailable
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
         return result
 
     async def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
@@ -2136,6 +2115,27 @@ class gate(Exchange, ImplicitAPI):
             }
         return result
 
+    async def fetch_deposit_addresses_by_network(self, code: str, params={}) -> List[DepositAddress]:
+        """
+        fetch a dictionary of addresses for a currency, indexed by network
+        :param str code: unified currency code of the currency for the deposit address
+        :param dict [params]: extra parameters specific to the api endpoint
+        :returns dict: a dictionary of `address structures <https://docs.ccxt.com/#/?id=address-structure>` indexed by the network
+        """
+        await self.load_markets()
+        currency = self.currency(code)
+        request = {
+            'currency': currency['id'],
+        }
+        response = await self.privateWalletGetDepositAddress(self.extend(request, params))
+        chains = self.safe_value(response, 'multichain_addresses', [])
+        currencyId = self.safe_string(response, 'currency')
+        currency = self.safe_currency(currencyId, currency)
+        parsed = self.parse_deposit_addresses(chains, [currency['code']], False, {
+            'currency': currency['id'],
+        })
+        return self.index_by(parsed, 'network')
+
     async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         fetch the deposit address for a currency associated with self account
@@ -2148,65 +2148,30 @@ class gate(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         await self.load_markets()
-        currency = self.currency(code)
-        rawNetwork = self.safe_string_upper(params, 'network')
-        params = self.omit(params, 'network')
-        request: dict = {
-            'currency': currency['id'],  # todo: currencies have network-junctions
-        }
-        response = await self.privateWalletGetDepositAddress(self.extend(request, params))
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        chainsIndexedById = await self.fetch_deposit_addresses_by_network(code, params)
+        selectedNetworkId = self.select_network_code_from_unified_networks(code, networkCode, chainsIndexedById)
+        return chainsIndexedById[selectedNetworkId]
+
+    def parse_deposit_address(self, depositAddress, currency=None):
         #
-        #    {
-        #        "currency": "XRP",
-        #        "address": "rHcFoo6a9qT5NHiVn1THQRhsEGcxtYCV4d 391331007",
-        #        "multichain_addresses": [
-        #            {
-        #                "chain": "XRP",
-        #                "address": "rHcFoo6a9qT5NHiVn1THQRhsEGcxtYCV4d",
-        #                "payment_id": "391331007",
-        #                "payment_name": "Tag",
-        #                "obtain_failed": 0
-        #            }
-        #        ]
-        #    }
+        #     {
+        #         chain: "BTC",
+        #         address: "1Nxu.......Ys",
+        #         payment_id: "",
+        #         payment_name: "",
+        #         obtain_failed: "0",
+        #     }
         #
-        currencyId = self.safe_string(response, 'currency')
-        code = self.safe_currency_code(currencyId)
-        networkId = self.network_code_to_id(rawNetwork, code)
-        network = None
-        tag = None
-        address = None
-        if networkId is not None:
-            addresses = self.safe_value(response, 'multichain_addresses')
-            for i in range(0, len(addresses)):
-                entry = addresses[i]
-                entryNetwork = self.safe_string(entry, 'chain')
-                if networkId == entryNetwork:
-                    obtainFailed = self.safe_integer(entry, 'obtain_failed')
-                    if obtainFailed:
-                        break
-                    address = self.safe_string(entry, 'address')
-                    tag = self.safe_string(entry, 'payment_id')
-                    network = self.network_id_to_code(networkId, code)
-                    break
-        else:
-            addressField = self.safe_string(response, 'address')
-            if addressField is not None:
-                if addressField.find('New address is being generated for you, please wait') >= 0:
-                    raise BadResponse(self.id + ' ' + 'New address is being generated for you, please wait a few seconds and try again to get the address.')
-                if addressField.find(' ') >= 0:
-                    splitted = addressField.split(' ')
-                    address = splitted[0]
-                    tag = splitted[1]
-                else:
-                    address = addressField
+        address = self.safe_string(depositAddress, 'address')
         self.check_address(address)
         return {
-            'info': response,
-            'currency': code,
-            'network': network,
+            'info': depositAddress,
+            'currency': self.safe_string(currency, 'code'),
             'address': address,
-            'tag': tag,
+            'tag': self.safe_string(depositAddress, 'payment_id'),
+            'network': self.network_id_to_code(self.safe_string(depositAddress, 'chain')),
         }
 
     async def fetch_trading_fee(self, symbol: str, params={}) -> TradingFeeInterface:
@@ -3819,14 +3784,10 @@ class gate(Exchange, ImplicitAPI):
         }
         if tag is not None:
             request['memo'] = tag
-        networks = self.safe_value(self.options, 'networks', {})
-        network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
-        network = self.safe_string_lower(networks, network, network)  # handle ETH>ERC20 alias
-        if network is not None:
-            request['chain'] = network
-            params = self.omit(params, 'network')
-        else:
-            request['chain'] = currency['id']  # todo: currencies have network-junctions
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        if networkCode is not None:
+            request['chain'] = self.network_code_to_id(networkCode)
         response = await self.privateWithdrawalsPostWithdrawals(self.extend(request, params))
         #
         #    {

ccxt/async_support/kraken.py

@@ -981,9 +981,9 @@ class kraken(Exchange, ImplicitAPI):
             'high': self.safe_string(high, 1),
             'low': self.safe_string(low, 1),
             'bid': self.safe_string(bid, 0),
-            'bidVolume': None,
+            'bidVolume': self.safe_string(bid, 2),
             'ask': self.safe_string(ask, 0),
-            'askVolume': None,
+            'askVolume': self.safe_string(ask, 2),
             'vwap': vwap,
             'open': self.safe_string(ticker, 'o'),
             'close': last,