ccxt 4.4.88__py2.py3-none-any.whl → 4.4.91__py2.py3-none-any.whl

ccxt/gate.py

@@ -1241,7 +1241,7 @@ class gate(Exchange, ImplicitAPI):
             self.fetch_option_markets(params),
         ]
         if not sandboxMode:
-            # gate does not have a sandbox for spot markets
+            # gate doesn't have a sandbox for spot markets
             mainnetOnly = [self.fetch_spot_markets(params)]
             rawPromises = self.array_concat(rawPromises, mainnetOnly)
         promises = rawPromises
@@ -1263,17 +1263,21 @@ class gate(Exchange, ImplicitAPI):
         #         {
         #             "id": "QTUM_ETH",
         #             "base": "QTUM",
+        #             "base_name": "Quantum",
         #             "quote": "ETH",
+        #             "quote_name": "Ethereum",
         #             "fee": "0.2",
         #             "min_base_amount": "0.01",
         #             "min_quote_amount": "0.001",
+        #             "max_quote_amount": "50000",
         #             "amount_precision": 3,
         #             "precision": 6,
         #             "trade_status": "tradable",
-        #             "sell_start": 0,
-        #             "buy_start": 0
+        #             "sell_start": 1607313600,
+        #             "buy_start": 1700492400,
+        #             "type": "normal",
+        #             "trade_url": "https://www.gate.io/trade/QTUM_ETH",
         #         }
-        #     ]
         #
         #  Margin
         #
@@ -1304,6 +1308,8 @@ class gate(Exchange, ImplicitAPI):
             tradeStatus = self.safe_string(market, 'trade_status')
             leverage = self.safe_number(market, 'leverage')
             margin = leverage is not None
+            buyStart = self.safe_integer_product(spotMarket, 'buy_start', 1000)  # buy_start is the trading start time, while sell_start is offline orders start time
+            createdTs = buyStart if (buyStart != 0) else None
             result.append({
                 'id': id,
                 'symbol': base + '/' + quote,
@@ -1353,7 +1359,7 @@ class gate(Exchange, ImplicitAPI):
                         'max': self.safe_number(market, 'max_quote_amount') if margin else None,
                     },
                 },
-                'created': None,
+                'created': createdTs,
                 'info': market,
             })
         return result
@@ -1418,6 +1424,7 @@ class gate(Exchange, ImplicitAPI):
         #        "funding_next_apply": 1610035200,
         #        "short_users": 977,
         #        "config_change_time": 1609899548,
+        #        "create_time": 1609800048,
         #        "trade_size": 28530850594,
         #        "position_size": 5223816,
         #        "long_users": 455,
@@ -1548,7 +1555,7 @@ class gate(Exchange, ImplicitAPI):
                     'max': None,
                 },
             },
-            'created': None,
+            'created': self.safe_integer_product(market, 'create_time', 1000),
             'info': market,
         }
 
@@ -1645,7 +1652,7 @@ class gate(Exchange, ImplicitAPI):
                     'contractSize': self.parse_number('1'),
                     'expiry': expiry,
                     'expiryDatetime': self.iso8601(expiry),
-                    'strike': strike,
+                    'strike': self.parse_number(strike),
                     'optionType': optionType,
                     'precision': {
                         'amount': self.parse_number('1'),  # all options have self step size

ccxt/hashkey.py

@@ -1151,47 +1151,43 @@ class hashkey(Exchange, ImplicitAPI):
             currecy = coins[i]
             currencyId = self.safe_string(currecy, 'coinId')
             code = self.safe_currency_code(currencyId)
-            allowWithdraw = self.safe_bool(currecy, 'allowWithdraw')
-            allowDeposit = self.safe_bool(currecy, 'allowDeposit')
             networks = self.safe_list(currecy, 'chainTypes')
-            networksById = self.safe_dict(self.options, 'networksById')
             parsedNetworks: dict = {}
             for j in range(0, len(networks)):
                 network = networks[j]
                 networkId = self.safe_string(network, 'chainType')
-                networkName = self.safe_string(networksById, networkId, networkId)
-                maxWithdrawQuantity = self.omit_zero(self.safe_string(network, 'maxWithdrawQuantity'))
-                networkDeposit = self.safe_bool(network, 'allowDeposit')
-                networkWithdraw = self.safe_bool(network, 'allowWithdraw')
-                parsedNetworks[networkName] = {
+                networkCode = self.network_code_to_id(networkId)
+                parsedNetworks[networkCode] = {
                     'id': networkId,
-                    'network': networkName,
+                    'network': networkCode,
                     'limits': {
                         'withdraw': {
                             'min': self.safe_number(network, 'minWithdrawQuantity'),
-                            'max': self.parse_number(maxWithdrawQuantity),
+                            'max': self.parse_number(self.omit_zero(self.safe_string(network, 'maxWithdrawQuantity'))),
                         },
                         'deposit': {
                             'min': self.safe_number(network, 'minDepositQuantity'),
                             'max': None,
                         },
                     },
-                    'active': networkDeposit and networkWithdraw,
-                    'deposit': networkDeposit,
-                    'withdraw': networkWithdraw,
+                    'active': None,
+                    'deposit': self.safe_bool(network, 'allowDeposit'),
+                    'withdraw': self.safe_bool(network, 'allowWithdraw'),
                     'fee': self.safe_number(network, 'withdrawFee'),
                     'precision': None,
                     'info': network,
                 }
-            result[code] = {
+            rawType = self.safe_string(currecy, 'tokenType')
+            type = 'fiat' if (rawType == 'REAL_MONEY') else 'crypto'
+            result[code] = self.safe_currency_structure({
                 'id': currencyId,
                 'code': code,
                 'precision': None,
-                'type': self.parse_currency_type(self.safe_string(currecy, 'tokenType')),
+                'type': type,
                 'name': self.safe_string(currecy, 'coinFullName'),
-                'active': allowWithdraw and allowDeposit,
-                'deposit': allowDeposit,
-                'withdraw': allowWithdraw,
+                'active': None,
+                'deposit': self.safe_bool(currecy, 'allowDeposit'),
+                'withdraw': self.safe_bool(currecy, 'allowWithdraw'),
                 'fee': None,
                 'limits': {
                     'deposit': {
@@ -1205,18 +1201,9 @@ class hashkey(Exchange, ImplicitAPI):
                 },
                 'networks': parsedNetworks,
                 'info': currecy,
-            }
+            })
         return result
 
-    def parse_currency_type(self, type):
-        types = {
-            'CHAIN_TOKEN': 'crypto',
-            'ERC20_TOKEN': 'crypto',
-            'BSC_TOKEN': 'crypto',
-            'REAL_MONEY': 'fiat',
-        }
-        return self.safe_string(types, type)
-
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data

ccxt/hollaex.py

@@ -15,6 +15,7 @@ from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import OrderImmediatelyFillable
 from ccxt.base.errors import NetworkError
+from ccxt.base.errors import InvalidNonce
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
@@ -262,6 +263,7 @@ class hollaex(Exchange, ImplicitAPI):
             },
             'exceptions': {
                 'broad': {
+                    'API request is expired': InvalidNonce,
                     'Invalid token': AuthenticationError,
                     'Order not found': OrderNotFound,
                     'Insufficient balance': InsufficientFunds,
@@ -796,7 +798,8 @@ class hollaex(Exchange, ImplicitAPI):
         #      "price":0.147411,
         #      "timestamp":"2022-01-26T17:53:34.650Z",
         #      "order_id":"cba78ecb-4187-4da2-9d2f-c259aa693b5a",
-        #      "fee":0.01031877,"fee_coin":"usdt"
+        #      "fee":0.01031877,
+        #      "fee_coin":"usdt"
         #  }
         #
         marketId = self.safe_string(trade, 'symbol')
@@ -809,11 +812,12 @@ class hollaex(Exchange, ImplicitAPI):
         priceString = self.safe_string(trade, 'price')
         amountString = self.safe_string(trade, 'size')
         feeCostString = self.safe_string(trade, 'fee')
+        feeCoin = self.safe_string(trade, 'fee_coin')
         fee = None
         if feeCostString is not None:
             fee = {
                 'cost': feeCostString,
-                'currency': market['quote'],
+                'currency': self.safe_currency_code(feeCoin),
             }
         return self.safe_trade({
             'info': trade,
@@ -899,7 +903,7 @@ class hollaex(Exchange, ImplicitAPI):
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
-        :param int [limit]: the maximum amount of candles to fetch
+        :param int [limit]: the maximum amount of candles to fetch(max 500)
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: timestamp in ms of the latest candle to fetch
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
@@ -910,16 +914,24 @@ class hollaex(Exchange, ImplicitAPI):
             'symbol': market['id'],
             'resolution': self.safe_string(self.timeframes, timeframe, timeframe),
         }
+        paginate = False
+        maxLimit = 500
+        paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate', paginate)
+        if paginate:
+            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, maxLimit)
         until = self.safe_integer(params, 'until')
-        end = self.seconds()
-        if until is not None:
-            end = self.parse_to_int(until / 1000)
-        defaultSpan = 2592000  # 30 days
-        if since is not None:
-            request['from'] = self.parse_to_int(since / 1000)
-        else:
-            request['from'] = end - defaultSpan
-        request['to'] = end
+        timeDelta = self.parse_timeframe(timeframe) * maxLimit * 1000
+        start = since
+        now = self.milliseconds()
+        if until is None and start is None:
+            until = now
+            start = until - timeDelta
+        elif until is None:
+            until = now  # the exchange has not a lot of trades, so if we count until by limit and limit is small, it may return empty result
+        elif start is None:
+            start = until - timeDelta
+        request['from'] = self.parse_to_int(start / 1000)  # convert to seconds
+        request['to'] = self.parse_to_int(until / 1000)  # convert to seconds
         params = self.omit(params, 'until')
         response = self.publicGetChart(self.extend(request, params))
         #
@@ -1277,11 +1289,10 @@ class hollaex(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        convertedAmount = float(self.amount_to_precision(symbol, amount))
         request: dict = {
             'symbol': market['id'],
             'side': side,
-            'size': self.normalize_number_if_needed(convertedAmount),
+            'size': self.amount_to_precision(symbol, amount),
             'type': type,
             # 'stop': float(self.price_to_precision(symbol, stopPrice)),
             # 'meta': {},  # other options such
@@ -1292,10 +1303,9 @@ class hollaex(Exchange, ImplicitAPI):
         isMarketOrder = type == 'market'
         postOnly = self.is_post_only(isMarketOrder, exchangeSpecificParam, params)
         if not isMarketOrder:
-            convertedPrice = float(self.price_to_precision(symbol, price))
-            request['price'] = self.normalize_number_if_needed(convertedPrice)
+            request['price'] = self.price_to_precision(symbol, price)
         if triggerPrice is not None:
-            request['stop'] = self.normalize_number_if_needed(float(self.price_to_precision(symbol, triggerPrice)))
+            request['stop'] = self.price_to_precision(symbol, triggerPrice)
         if postOnly:
             request['meta'] = {'post_only': True}
         params = self.omit(params, ['postOnly', 'timeInForce', 'stopPrice', 'triggerPrice', 'stop'])
@@ -1943,11 +1953,6 @@ class hollaex(Exchange, ImplicitAPI):
         coins = self.safe_dict(response, 'coins', {})
         return self.parse_deposit_withdraw_fees(coins, codes, 'symbol')
 
-    def normalize_number_if_needed(self, number):
-        if self.is_round_number(number):
-            number = int(number)
-        return number
-
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         query = self.omit(params, self.extract_params(path))
         path = '/' + self.version + '/' + self.implode_params(path, params)

ccxt/hyperliquid.py

@@ -56,6 +56,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'createMarketSellOrderWithCost': False,
                 'createOrder': True,
                 'createOrders': True,
+                'createOrderWithTakeProfitAndStopLoss': True,
                 'createReduceOnlyOrder': True,
                 'createStopOrder': True,
                 'createTriggerOrder': True,
@@ -239,7 +240,16 @@ class hyperliquid(Exchange, ImplicitAPI):
                         'triggerDirection': False,
                         'stopLossPrice': False,
                         'takeProfitPrice': False,
-                        'attachedStopLossTakeProfit': None,
+                        'attachedStopLossTakeProfit': {
+                            'triggerPriceType': {
+                                'last': False,
+                                'mark': False,
+                                'index': False,
+                            },
+                            'triggerPrice': True,
+                            'type': True,
+                            'price': True,
+                        },
                         'timeInForce': {
                             'IOC': True,
                             'FOK': False,
@@ -1403,6 +1413,65 @@ class hyperliquid(Exchange, ImplicitAPI):
         statuses = self.safe_list(data, 'statuses', [])
         return self.parse_orders(statuses, None)
 
+    def create_order_request(self, symbol: str, type: OrderType, side: OrderSide, amount: str, price: Str = None, params={}):
+        market = self.market(symbol)
+        type = type.upper()
+        side = side.upper()
+        isMarket = (type == 'MARKET')
+        isBuy = (side == 'BUY')
+        clientOrderId = self.safe_string_2(params, 'clientOrderId', 'client_id')
+        slippage = self.safe_string(params, 'slippage')
+        defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
+        postOnly = self.safe_bool(params, 'postOnly', False)
+        if postOnly:
+            defaultTimeInForce = 'alo'
+        timeInForce = self.safe_string_lower(params, 'timeInForce', defaultTimeInForce)
+        timeInForce = self.capitalize(timeInForce)
+        triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
+        stopLossPrice = self.safe_string(params, 'stopLossPrice', triggerPrice)
+        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
+        isTrigger = (stopLossPrice or takeProfitPrice)
+        px = None
+        if isMarket:
+            if price is None:
+                raise ArgumentsRequired(self.id + '  market orders require price to calculate the max slippage price. Default slippage can be set in options(default is 5%).')
+            px = Precise.string_mul(price, Precise.string_add('1', slippage)) if (isBuy) else Precise.string_mul(price, Precise.string_sub('1', slippage))
+            px = self.price_to_precision(symbol, px)  # round after adding slippage
+        else:
+            px = self.price_to_precision(symbol, price)
+        sz = self.amount_to_precision(symbol, amount)
+        reduceOnly = self.safe_bool(params, 'reduceOnly', False)
+        orderType: dict = {}
+        if isTrigger:
+            isTp = False
+            if takeProfitPrice is not None:
+                triggerPrice = self.price_to_precision(symbol, takeProfitPrice)
+                isTp = True
+            else:
+                triggerPrice = self.price_to_precision(symbol, stopLossPrice)
+            orderType['trigger'] = {
+                'isMarket': isMarket,
+                'triggerPx': triggerPrice,
+                'tpsl': 'tp' if (isTp) else 'sl',
+            }
+        else:
+            orderType['limit'] = {
+                'tif': timeInForce,
+            }
+        params = self.omit(params, ['clientOrderId', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce', 'client_id', 'reduceOnly', 'postOnly'])
+        orderObj: dict = {
+            'a': self.parse_to_int(market['baseId']),
+            'b': isBuy,
+            'p': px,
+            's': sz,
+            'r': reduceOnly,
+            't': orderType,
+            # 'c': clientOrderId,
+        }
+        if clientOrderId is not None:
+            orderObj['c'] = clientOrderId
+        return orderObj
+
     def create_orders_request(self, orders, params={}) -> dict:
         """
         create a list of trade orders
@@ -1430,77 +1499,59 @@ class hyperliquid(Exchange, ImplicitAPI):
         params = self.omit(params, ['slippage', 'clientOrderId', 'client_id', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce'])
         nonce = self.milliseconds()
         orderReq = []
+        grouping = 'na'
         for i in range(0, len(orders)):
             rawOrder = orders[i]
             marketId = self.safe_string(rawOrder, 'symbol')
             market = self.market(marketId)
             symbol = market['symbol']
             type = self.safe_string_upper(rawOrder, 'type')
-            isMarket = (type == 'MARKET')
             side = self.safe_string_upper(rawOrder, 'side')
-            isBuy = (side == 'BUY')
             amount = self.safe_string(rawOrder, 'amount')
             price = self.safe_string(rawOrder, 'price')
             orderParams = self.safe_dict(rawOrder, 'params', {})
-            clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
             slippage = self.safe_string(orderParams, 'slippage', defaultSlippage)
-            defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
-            postOnly = self.safe_bool(orderParams, 'postOnly', False)
-            if postOnly:
-                defaultTimeInForce = 'alo'
-            timeInForce = self.safe_string_lower(orderParams, 'timeInForce', defaultTimeInForce)
-            timeInForce = self.capitalize(timeInForce)
-            triggerPrice = self.safe_string_2(orderParams, 'triggerPrice', 'stopPrice')
-            stopLossPrice = self.safe_string(orderParams, 'stopLossPrice', triggerPrice)
-            takeProfitPrice = self.safe_string(orderParams, 'takeProfitPrice')
-            isTrigger = (stopLossPrice or takeProfitPrice)
-            px = None
-            if isMarket:
-                if price is None:
-                    raise ArgumentsRequired(self.id + '  market orders require price to calculate the max slippage price. Default slippage can be set in options(default is 5%).')
-                px = Precise.string_mul(price, Precise.string_add('1', slippage)) if (isBuy) else Precise.string_mul(price, Precise.string_sub('1', slippage))
-                px = self.price_to_precision(symbol, px)  # round after adding slippage
-            else:
-                px = self.price_to_precision(symbol, price)
-            sz = self.amount_to_precision(symbol, amount)
-            reduceOnly = self.safe_bool(orderParams, 'reduceOnly', False)
-            orderType: dict = {}
+            orderParams['slippage'] = slippage
+            stopLoss = self.safe_value(orderParams, 'stopLoss')
+            takeProfit = self.safe_value(orderParams, 'takeProfit')
+            isTrigger = (stopLoss or takeProfit)
+            orderParams = self.omit(orderParams, ['stopLoss', 'takeProfit'])
+            mainOrderObj: dict = self.create_order_request(symbol, type, side, amount, price, orderParams)
+            orderReq.append(mainOrderObj)
             if isTrigger:
-                isTp = False
-                if takeProfitPrice is not None:
-                    triggerPrice = self.price_to_precision(symbol, takeProfitPrice)
-                    isTp = True
+                # grouping opposed orders for sl/tp
+                stopLossOrderTriggerPrice = self.safe_string_n(stopLoss, ['triggerPrice', 'stopPrice'])
+                stopLossOrderType = self.safe_string(stopLoss, 'type')
+                stopLossOrderLimitPrice = self.safe_string_n(stopLoss, ['price', 'stopLossPrice'], stopLossOrderTriggerPrice)
+                takeProfitOrderTriggerPrice = self.safe_string_n(takeProfit, ['triggerPrice', 'stopPrice'])
+                takeProfitOrderType = self.safe_string(takeProfit, 'type')
+                takeProfitOrderLimitPrice = self.safe_string_n(takeProfit, ['price', 'takeProfitPrice'], takeProfitOrderTriggerPrice)
+                grouping = 'normalTpsl'
+                orderParams = self.omit(orderParams, ['stopLoss', 'takeProfit'])
+                triggerOrderSide = ''
+                if side == 'BUY':
+                    triggerOrderSide = 'sell'
                 else:
-                    triggerPrice = self.price_to_precision(symbol, stopLossPrice)
-                orderType['trigger'] = {
-                    'isMarket': isMarket,
-                    'triggerPx': triggerPrice,
-                    'tpsl': 'tp' if (isTp) else 'sl',
-                }
-            else:
-                orderType['limit'] = {
-                    'tif': timeInForce,
-                }
-            orderParams = self.omit(orderParams, ['clientOrderId', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce', 'client_id', 'reduceOnly', 'postOnly'])
-            orderObj: dict = {
-                'a': self.parse_to_int(market['baseId']),
-                'b': isBuy,
-                'p': px,
-                's': sz,
-                'r': reduceOnly,
-                't': orderType,
-                # 'c': clientOrderId,
-            }
-            if clientOrderId is not None:
-                orderObj['c'] = clientOrderId
-            orderReq.append(orderObj)
+                    triggerOrderSide = 'buy'
+                if takeProfit is not None:
+                    orderObj: dict = self.create_order_request(symbol, takeProfitOrderType, triggerOrderSide, amount, takeProfitOrderLimitPrice, self.extend(orderParams, {
+                        'takeProfitPrice': takeProfitOrderTriggerPrice,
+                        'reduceOnly': True,
+                    }))
+                    orderReq.append(orderObj)
+                if stopLoss is not None:
+                    orderObj: dict = self.create_order_request(symbol, stopLossOrderType, triggerOrderSide, amount, stopLossOrderLimitPrice, self.extend(orderParams, {
+                        'stopLossPrice': stopLossOrderTriggerPrice,
+                        'reduceOnly': True,
+                    }))
+                    orderReq.append(orderObj)
         vaultAddress = None
         vaultAddress, params = self.handle_option_and_params(params, 'createOrder', 'vaultAddress')
         vaultAddress = self.format_vault_address(vaultAddress)
         orderAction: dict = {
             'type': 'order',
             'orders': orderReq,
-            'grouping': 'na',
+            'grouping': grouping,
             # 'brokerCode': 1,  # cant
         }
         if vaultAddress is None: