ccxt 4.4.33__py2.py3-none-any.whl → 4.4.35__py2.py3-none-any.whl

ccxt/async_support/bybit.py

@@ -1077,6 +1077,7 @@ class bybit(Exchange, ImplicitAPI):
                 'default': {
                     'sandbox': True,
                     'createOrder': {
+                        'marginMode': False,
                         'triggerPrice': True,
                         'triggerPriceType': {
                             'last': True,
@@ -1094,7 +1095,6 @@ class bybit(Exchange, ImplicitAPI):
                             },
                             'limitPrice': True,
                         },
-                        'marginMode': False,
                         'timeInForce': {
                             'GTC': True,
                             'IOC': True,
@@ -1114,6 +1114,7 @@ class bybit(Exchange, ImplicitAPI):
                         'max': 10,
                     },
                     'fetchMyTrades': {
+                        'marginMode': False,
                         'limit': 100,
                         'daysBack': 365 * 2,  # 2 years
                         'untilDays': 7,  # days between start-end
@@ -1124,18 +1125,18 @@ class bybit(Exchange, ImplicitAPI):
                         'trailing': False,
                     },
                     'fetchOpenOrders': {
-                        'limit': 50,
                         'marginMode': False,
+                        'limit': 50,
                         'trigger': True,
                         'trailing': False,
                     },
                     'fetchOrders': None,
                     'fetchClosedOrders': {
+                        'marginMode': False,
                         'limit': 50,
                         'daysBackClosed': 365 * 2,  # 2 years
                         'daysBackCanceled': 1,
                         'untilDays': 7,
-                        'marginMode': False,
                         'trigger': True,
                         'trailing': False,
                     },
@@ -1146,6 +1147,7 @@ class bybit(Exchange, ImplicitAPI):
                 'spot': {
                     'extends': 'default',
                     'createOrder': {
+                        'marginMode': False,
                         'triggerPrice': True,
                         'triggerPriceType': None,
                         'triggerDirection': False,
@@ -1155,7 +1157,6 @@ class bybit(Exchange, ImplicitAPI):
                             'triggerPriceType': None,
                             'limitPrice': True,
                         },
-                        'marginMode': False,
                         'timeInForce': {
                             'GTC': True,
                             'IOC': True,
@@ -1229,7 +1230,7 @@ class bybit(Exchange, ImplicitAPI):
 
     def add_pagination_cursor_to_result(self, response):
         result = self.safe_dict(response, 'result', {})
-        data = self.safe_value_n(result, ['list', 'rows', 'data', 'dataList'], [])
+        data = self.safe_list_n(result, ['list', 'rows', 'data', 'dataList'], [])
         paginationCursor = self.safe_string_2(result, 'nextPageCursor', 'cursor')
         dataLength = len(data)
         if (paginationCursor is not None) and (dataLength > 0):
@@ -1240,12 +1241,12 @@ class bybit(Exchange, ImplicitAPI):
 
     async def is_unified_enabled(self, params={}):
         """
-        :param dict [params]: extra parameters specific to the exchange API endpoint
 
         https://bybit-exchange.github.io/docs/v5/user/apikey-info#http-request
         https://bybit-exchange.github.io/docs/v5/account/account-info
 
         returns [enableUnifiedMargin, enableUnifiedAccount] so the user can check if unified account is enabled
+        :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns any: [enableUnifiedMargin, enableUnifiedAccount]
         """
         # The API key of user id must own one of permissions will be allowed to call following API endpoints.
@@ -2278,6 +2279,7 @@ class bybit(Exchange, ImplicitAPI):
         :param str[] symbols: unified symbols of the markets to fetch the ticker for, all market tickers 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: an array of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
@@ -2319,10 +2321,11 @@ class bybit(Exchange, ImplicitAPI):
         # only if passedSubType is None, then use spot
         if type == 'spot' and passedSubType is None:
             request['category'] = 'spot'
-        elif type == 'swap' or type == 'future' or subType is not None:
-            request['category'] = subType
         elif type == 'option':
             request['category'] = 'option'
+            request['baseCoin'] = self.safe_string(params, 'baseCoin', 'BTC')
+        elif type == 'swap' or type == 'future' or subType is not None:
+            request['category'] = subType
         response = await self.publicGetV5MarketTickers(self.extend(request, params))
         #
         #     {
@@ -3109,7 +3112,7 @@ class bybit(Exchange, ImplicitAPI):
             'datetime': self.iso8601(timestamp),
         }
         responseResult = self.safe_dict(response, 'result', {})
-        currencyList = self.safe_value_n(responseResult, ['loanAccountList', 'list', 'balance'])
+        currencyList = self.safe_list_n(responseResult, ['loanAccountList', 'list', 'balance'])
         if currencyList is None:
             # usdc wallet
             code = 'USDC'
@@ -3879,7 +3882,7 @@ class bybit(Exchange, ImplicitAPI):
             side = self.safe_string(rawOrder, 'side')
             amount = self.safe_value(rawOrder, 'amount')
             price = self.safe_value(rawOrder, 'price')
-            orderParams = self.safe_value(rawOrder, 'params', {})
+            orderParams = self.safe_dict(rawOrder, 'params', {})
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams, isUta)
             ordersRequests.append(orderRequest)
         symbols = self.market_symbols(orderSymbols, None, False, True, True)

ccxt/async_support/cex.py

@@ -27,7 +27,7 @@ class cex(Exchange, ImplicitAPI):
             'id': 'cex',
             'name': 'CEX.IO',
             'countries': ['GB', 'EU', 'CY', 'RU'],
-            'rateLimit': 1667,  # 100 req/min
+            'rateLimit': 300,  # 200 req/min
             'pro': True,
             'has': {
                 'CORS': None,
@@ -39,6 +39,8 @@ class cex(Exchange, ImplicitAPI):
                 'cancelAllOrders': True,
                 'cancelOrder': True,
                 'createOrder': True,
+                'createStopOrder': True,
+                'createTriggerOrder': True,
                 'fetchAccounts': True,
                 'fetchBalance': True,
                 'fetchClosedOrder': True,
@@ -919,7 +921,7 @@ class cex(Exchange, ImplicitAPI):
         #            },
         #            ...
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_orders(data, market, since, limit)
 
     async def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
@@ -988,10 +990,16 @@ class cex(Exchange, ImplicitAPI):
 
     def parse_order_status(self, status: Str):
         statuses: dict = {
+            'PENDING_NEW': 'open',
+            'NEW': 'open',
+            'PARTIALLY_FILLED': 'open',
             'FILLED': 'closed',
+            'EXPIRED': 'expired',
+            'REJECTED': 'rejected',
+            'PENDING_CANCEL': 'canceling',
             'CANCELLED': 'canceled',
         }
-        return self.safe_string(statuses, status, None)
+        return self.safe_string(statuses, status, status)
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
         #
@@ -1040,7 +1048,7 @@ class cex(Exchange, ImplicitAPI):
             currencyId = self.safe_string(order, 'feeCurrency')
             feeCode = self.safe_currency_code(currencyId)
             fee['currency'] = feeCode
-            fee['fee'] = feeAmount
+            fee['cost'] = feeAmount
         timestamp = self.safe_integer(order, 'serverCreateTimestamp')
         requestedBase = self.safe_number(order, 'requestedAmountCcy1')
         executedBase = self.safe_number(order, 'executedAmountCcy1')
@@ -1084,6 +1092,7 @@ class cex(Exchange, ImplicitAPI):
         :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.accountId]: account-id to use(default is empty string)
+        :param float [params.triggerPrice]: the price at which a trigger order is triggered at
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         accountId = None

ccxt/async_support/coinbase.py

@@ -2182,7 +2182,8 @@ class coinbase(Exchange, ImplicitAPI):
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean [params.v3]: default False, set True to use v3 api endpoint
-        :param dict [params.type]: "spot"(default) or "swap" or "future"
+        :param str [params.type]: "spot"(default) or "swap" or "future"
+        :param int [params.limit]: default 250, maximum number of accounts to return
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         await self.load_markets()
@@ -2199,7 +2200,7 @@ class coinbase(Exchange, ImplicitAPI):
             request['limit'] = 250
             response = await self.v3PrivateGetBrokerageAccounts(self.extend(request, params))
         else:
-            request['limit'] = 100
+            request['limit'] = 250
             response = await self.v2PrivateGetAccounts(self.extend(request, params))
         #
         # v2PrivateGetAccounts

ccxt/async_support/coinex.py

@@ -69,6 +69,7 @@ class coinex(Exchange, ImplicitAPI):
                 'createOrders': True,
                 'createReduceOnlyOrder': True,
                 'createStopLossOrder': True,
+                'createStopOrder': True,
                 'createTakeProfitOrder': True,
                 'createTriggerOrder': True,
                 'editOrder': True,

ccxt/async_support/coinone.py

@@ -240,7 +240,7 @@ class coinone(Exchange, ImplicitAPI):
         #     }
         #
         result: dict = {}
-        currencies = self.safe_value(response, 'currencies', [])
+        currencies = self.safe_list(response, 'currencies', [])
         for i in range(0, len(currencies)):
             entry = currencies[i]
             id = self.safe_string(entry, 'symbol')
@@ -320,7 +320,7 @@ class coinone(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        tickers = self.safe_value(response, 'tickers', [])
+        tickers = self.safe_list(response, 'tickers', [])
         result = []
         for i in range(0, len(tickers)):
             entry = self.safe_value(tickers, i)
@@ -570,7 +570,7 @@ class coinone(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'tickers', [])
+        data = self.safe_list(response, 'tickers', [])
         ticker = self.safe_dict(data, 0, {})
         return self.parse_ticker(ticker, market)
 
@@ -603,8 +603,8 @@ class coinone(Exchange, ImplicitAPI):
         #
         timestamp = self.safe_integer(ticker, 'timestamp')
         last = self.safe_string(ticker, 'last')
-        asks = self.safe_value(ticker, 'best_asks')
-        bids = self.safe_value(ticker, 'best_bids')
+        asks = self.safe_list(ticker, 'best_asks', [])
+        bids = self.safe_list(ticker, 'best_bids', [])
         baseId = self.safe_string(ticker, 'target_currency')
         quoteId = self.safe_string(ticker, 'quote_currency')
         base = self.safe_currency_code(baseId)
@@ -658,7 +658,7 @@ class coinone(Exchange, ImplicitAPI):
         #
         timestamp = self.safe_integer(trade, 'timestamp')
         market = self.safe_market(None, market)
-        isSellerMaker = self.safe_value(trade, 'is_seller_maker')
+        isSellerMaker = self.safe_bool(trade, 'is_seller_maker')
         side = None
         if isSellerMaker is not None:
             side = 'sell' if isSellerMaker else 'buy'
@@ -1063,7 +1063,7 @@ class coinone(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        walletAddress = self.safe_value(response, 'walletAddress', {})
+        walletAddress = self.safe_dict(response, 'walletAddress', {})
         keys = list(walletAddress.keys())
         result: dict = {}
         for i in range(0, len(keys)):

ccxt/async_support/coinsph.py

@@ -555,7 +555,7 @@ class coinsph(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        markets = self.safe_value(response, 'symbols')
+        markets = self.safe_list(response, 'symbols', [])
         result = []
         for i in range(0, len(markets)):
             market = markets[i]
@@ -564,7 +564,7 @@ class coinsph(Exchange, ImplicitAPI):
             quoteId = self.safe_string(market, 'quoteAsset')
             base = self.safe_currency_code(baseId)
             quote = self.safe_currency_code(quoteId)
-            limits = self.index_by(self.safe_value(market, 'filters'), 'filterType')
+            limits = self.index_by(self.safe_list(market, 'filters', []), 'filterType')
             amountLimits = self.safe_value(limits, 'LOT_SIZE', {})
             priceLimits = self.safe_value(limits, 'PRICE_FILTER', {})
             costLimits = self.safe_value(limits, 'NOTIONAL', {})
@@ -644,7 +644,7 @@ class coinsph(Exchange, ImplicitAPI):
                 ids.append(id)
             request['symbols'] = ids
         defaultMethod = 'publicGetOpenapiQuoteV1Ticker24hr'
-        options = self.safe_value(self.options, 'fetchTickers', {})
+        options = self.safe_dict(self.options, 'fetchTickers', {})
         method = self.safe_string(options, 'method', defaultMethod)
         tickers = None
         if method == 'publicGetOpenapiQuoteV1TickerPrice':
@@ -673,7 +673,7 @@ class coinsph(Exchange, ImplicitAPI):
             'symbol': market['id'],
         }
         defaultMethod = 'publicGetOpenapiQuoteV1Ticker24hr'
-        options = self.safe_value(self.options, 'fetchTicker', {})
+        options = self.safe_dict(self.options, 'fetchTicker', {})
         method = self.safe_string(options, 'method', defaultMethod)
         ticker = None
         if method == 'publicGetOpenapiQuoteV1TickerPrice':
@@ -1002,7 +1002,7 @@ class coinsph(Exchange, ImplicitAPI):
                 'cost': feeCost,
                 'currency': self.safe_currency_code(feeCurrencyId),
             }
-        isBuyer = self.safe_value_2(trade, 'isBuyer', 'isBuyerMaker', None)
+        isBuyer = self.safe_bool_2(trade, 'isBuyer', 'isBuyerMaker', None)
         side = None
         if isBuyer is not None:
             side = 'buy' if (isBuyer is True) else 'sell'
@@ -1064,7 +1064,7 @@ class coinsph(Exchange, ImplicitAPI):
         return self.parse_balance(response)
 
     def parse_balance(self, response) -> Balances:
-        balances = self.safe_value(response, 'balances', [])
+        balances = self.safe_list(response, 'balances', [])
         result: dict = {
             'info': response,
             'timestamp': None,
@@ -1484,7 +1484,7 @@ class coinsph(Exchange, ImplicitAPI):
         #       }
         #     ]
         #
-        tradingFee = self.safe_value(response, 0, {})
+        tradingFee = self.safe_dict(response, 0, {})
         return self.parse_trading_fee(tradingFee, market)
 
     async def fetch_trading_fees(self, params={}) -> TradingFees:

ccxt/async_support/coinspot.py

@@ -270,7 +270,7 @@ class coinspot(Exchange, ImplicitAPI):
         response = await self.publicGetLatest(params)
         id = market['id']
         id = id.lower()
-        prices = self.safe_value(response, 'prices')
+        prices = self.safe_dict(response, 'prices', {})
         #
         #     {
         #         "status":"ok",
@@ -301,22 +301,22 @@ class coinspot(Exchange, ImplicitAPI):
         #
         #    {
         #        "status": "ok",
-        #        "prices": {
-        #        "btc": {
-        #        "bid": "25050",
-        #        "ask": "25370",
-        #        "last": "25234"
-        #        },
-        #        "ltc": {
-        #        "bid": "79.39192993",
-        #        "ask": "87.98",
-        #        "last": "87.95"
+        #        "prices":   {
+        #            "btc":   {
+        #                "bid": "25050",
+        #                "ask": "25370",
+        #                "last": "25234"
+        #            },
+        #            "ltc":   {
+        #                "bid": "79.39192993",
+        #                "ask": "87.98",
+        #                "last": "87.95"
+        #            }
         #        }
-        #      }
         #    }
         #
         result: dict = {}
-        prices = self.safe_value(response, 'prices')
+        prices = self.safe_dict(response, 'prices', {})
         ids = list(prices.keys())
         for i in range(0, len(ids)):
             id = ids[i]
@@ -377,35 +377,35 @@ class coinspot(Exchange, ImplicitAPI):
             request['startdate'] = self.yyyymmdd(since)
         response = await self.privatePostRoMyTransactions(self.extend(request, params))
         #  {
-        #   "status": "ok",
-        #   "buyorders": [
-        #     {
-        #       "otc": False,
-        #       "market": "ALGO/AUD",
-        #       "amount": 386.95197925,
-        #       "created": "2022-10-20T09:56:44.502Z",
-        #       "audfeeExGst": 1.80018002,
-        #       "audGst": 0.180018,
-        #       "audtotal": 200
-        #     },
-        #   ],
-        #   "sellorders": [
-        #     {
-        #       "otc": False,
-        #       "market": "SOLO/ALGO",
-        #       "amount": 154.52345614,
-        #       "total": 115.78858204658796,
-        #       "created": "2022-04-16T09:36:43.698Z",
-        #       "audfeeExGst": 1.08995731,
-        #       "audGst": 0.10899573,
-        #       "audtotal": 118.7
-        #     },
-        #   ]
+        #      "status": "ok",
+        #      "buyorders": [
+        #          {
+        #              "otc": False,
+        #              "market": "ALGO/AUD",
+        #              "amount": 386.95197925,
+        #              "created": "2022-10-20T09:56:44.502Z",
+        #              "audfeeExGst": 1.80018002,
+        #              "audGst": 0.180018,
+        #              "audtotal": 200
+        #          },
+        #      ],
+        #      "sellorders": [
+        #          {
+        #              "otc": False,
+        #              "market": "SOLO/ALGO",
+        #              "amount": 154.52345614,
+        #              "total": 115.78858204658796,
+        #              "created": "2022-04-16T09:36:43.698Z",
+        #              "audfeeExGst": 1.08995731,
+        #              "audGst": 0.10899573,
+        #              "audtotal": 118.7
+        #          },
+        #      ]
         # }
-        buyTrades = self.safe_value(response, 'buyorders', [])
+        buyTrades = self.safe_list(response, 'buyorders', [])
         for i in range(0, len(buyTrades)):
             buyTrades[i]['side'] = 'buy'
-        sellTrades = self.safe_value(response, 'sellorders', [])
+        sellTrades = self.safe_list(response, 'sellorders', [])
         for i in range(0, len(sellTrades)):
             sellTrades[i]['side'] = 'sell'
         trades = self.array_concat(buyTrades, sellTrades)