ccxt 4.3.2__py2.py3-none-any.whl → 4.3.4__py2.py3-none-any.whl

ccxt/async_support/hyperliquid.py

@@ -315,6 +315,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         #         ]
         #     ]
         #
+        #
         meta = self.safe_dict(response, 0, {})
         meta = self.safe_list(meta, 'universe', [])
         assetCtxs = self.safe_dict(response, 1, {})
@@ -373,10 +374,70 @@ class hyperliquid(Exchange, ImplicitAPI):
         #         },
         #     ],
         # ]
+        # mainnet
+        # [
+        #     {
+        #        "canonical_tokens2":[
+        #           0,
+        #           1
+        #        ],
+        #        "spot_infos":[
+        #           {
+        #              "name":"PURR/USDC",
+        #              "tokens":[
+        #                 1,
+        #                 0
+        #              ]
+        #           }
+        #        ],
+        #        "token_id_to_token":[
+        #           [
+        #              "0x6d1e7cde53ba9467b783cb7c530ce054",
+        #              0
+        #           ],
+        #           [
+        #              "0xc1fb593aeffbeb02f85e0308e9956a90",
+        #              1
+        #           ]
+        #        ],
+        #        "token_infos":[
+        #           {
+        #              "deployer":null,
+        #              "spec":{
+        #                 "name":"USDC",
+        #                 "szDecimals":"8",
+        #                 "weiDecimals":"8"
+        #              },
+        #              "spots":[
+        #              ]
+        #           },
+        #           {
+        #              "deployer":null,
+        #              "spec":{
+        #                 "name":"PURR",
+        #                 "szDecimals":"0",
+        #                 "weiDecimals":"5"
+        #              },
+        #              "spots":[
+        #                 0
+        #              ]
+        #           }
+        #        ]
+        #     },
+        #     [
+        #        {
+        #           "dayNtlVlm":"35001170.16631",
+        #           "markPx":"0.15743",
+        #           "midPx":"0.157555",
+        #           "prevDayPx":"0.158"
+        #        }
+        #     ]
+        # ]
         #
+        # response differs depending on the environment(mainnet vs sandbox)
         first = self.safe_dict(response, 0, {})
-        meta = self.safe_list(first, 'universe', [])
-        tokens = self.safe_list(first, 'tokens', [])
+        meta = self.safe_list_2(first, 'universe', 'spot_infos', [])
+        tokens = self.safe_list_2(first, 'tokens', 'token_infos', [])
         markets = []
         for i in range(0, len(meta)):
             market = self.safe_dict(meta, i, {})
@@ -392,14 +453,16 @@ class hyperliquid(Exchange, ImplicitAPI):
             maker = self.safe_number(fees, 'maker')
             tokensPos = self.safe_list(market, 'tokens', [])
             baseTokenPos = self.safe_integer(tokensPos, 0)
-            quoteTokenPos = self.safe_integer(tokensPos, 1)
+            # quoteTokenPos = self.safe_integer(tokensPos, 1)
             baseTokenInfo = self.safe_dict(tokens, baseTokenPos, {})
-            quoteTokenInfo = self.safe_dict(tokens, quoteTokenPos, {})
-            baseDecimals = self.safe_string(baseTokenInfo, 'szDecimals')
-            quoteDecimals = self.safe_integer(quoteTokenInfo, 'szDecimals')
+            # quoteTokenInfo = self.safe_dict(tokens, quoteTokenPos, {})
+            innerBaseTokenInfo = self.safe_dict(baseTokenInfo, 'spec', baseTokenInfo)
+            # innerQuoteTokenInfo = self.safe_dict(quoteTokenInfo, 'spec', quoteTokenInfo)
+            amountPrecision = self.parse_number(self.parse_precision(self.safe_string(innerBaseTokenInfo, 'szDecimals')))
+            # quotePrecision = self.parse_number(self.parse_precision(self.safe_string(innerQuoteTokenInfo, 'szDecimals')))
             baseId = self.number_to_string(i + 10000)
             markets.append(self.safe_market_structure({
-                'id': baseId,
+                'id': marketName,
                 'symbol': symbol,
                 'base': base,
                 'quote': quote,
@@ -409,14 +472,15 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'settleId': None,
                 'type': 'spot',
                 'spot': True,
+                'subType': None,
                 'margin': None,
                 'swap': False,
                 'future': False,
                 'option': False,
                 'active': True,
                 'contract': False,
-                'linear': True,
-                'inverse': False,
+                'linear': None,
+                'inverse': None,
                 'taker': taker,
                 'maker': maker,
                 'contractSize': None,
@@ -425,8 +489,8 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.parse_number(self.parse_precision(baseDecimals)),  # decimal places
-                    'price': quoteDecimals,  # significant digits
+                    'amount': amountPrecision,  # decimal places
+                    'price': 5,  # significant digits
                 },
                 'limits': {
                     'leverage': {
@@ -633,7 +697,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         market = self.market(symbol)
         request = {
             'type': 'l2Book',
-            'coin': market['base'],
+            'coin': market['base'] if market['swap'] else market['id'],
         }
         response = await self.publicPostInfo(self.extend(request, params))
         #
@@ -689,7 +753,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         request = {
             'type': 'candleSnapshot',
             'req': {
-                'coin': market['base'],
+                'coin': market['base'] if market['swap'] else market['id'],
                 'interval': timeframe,
                 'startTime': since,
                 'endTime': until,
@@ -792,6 +856,9 @@ class hyperliquid(Exchange, ImplicitAPI):
         return self.parse_trades(response, market, since, limit)
 
     def amount_to_precision(self, symbol, amount):
+        market = self.market(symbol)
+        if market['spot']:
+            return super(hyperliquid, self).amount_to_precision(symbol, amount)
         return self.decimal_to_precision(amount, ROUND, self.markets[symbol]['precision']['amount'], self.precisionMode)
 
     def price_to_precision(self, symbol: str, price) -> str:
@@ -2222,6 +2289,11 @@ class hyperliquid(Exchange, ImplicitAPI):
             return [self.walletAddress, params]
         raise ArgumentsRequired(self.id + ' ' + methodName + '() requires a user parameter inside \'params\' or the wallet address set')
 
+    def coin_to_market_id(self, coin: Str):
+        if coin.find('/') > -1:
+            return coin  # spot
+        return coin + '/USDC:USDC'
+
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
         if not response:
             return None  # fallback to default error handler

ccxt/async_support/okx.py

@@ -87,6 +87,8 @@ class okx(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchConvertCurrencies': True,
                 'fetchConvertQuote': True,
+                'fetchConvertTrade': True,
+                'fetchConvertTradeHistory': True,
                 'fetchCrossBorrowRate': True,
                 'fetchCrossBorrowRates': True,
                 'fetchCurrencies': True,
@@ -7203,6 +7205,96 @@ class okx(Exchange, ImplicitAPI):
         toCurrency = self.currency(toCurrencyId)
         return self.parse_conversion(result, fromCurrency, toCurrency)
 
+    async def fetch_convert_trade(self, id: str, code: Str = None, params={}) -> Conversion:
+        """
+        fetch the data for a conversion trade
+        :see: https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-convert-history
+        :param str id: the id of the trade that you want to fetch
+        :param str [code]: the unified currency code of the conversion trade
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `conversion structure <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        request = {
+            'clTReqId': id,
+        }
+        response = await self.privateGetAssetConvertHistory(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "data": [
+        #             {
+        #                 "clTReqId": "",
+        #                 "instId": "ETH-USDT",
+        #                 "side": "buy",
+        #                 "fillPx": "2932.401044",
+        #                 "baseCcy": "ETH",
+        #                 "quoteCcy": "USDT",
+        #                 "fillBaseSz": "0.01023052",
+        #                 "state": "fullyFilled",
+        #                 "tradeId": "trader16461885203381437",
+        #                 "fillQuoteSz": "30",
+        #                 "ts": "1646188520000"
+        #             }
+        #         ],
+        #         "msg": ""
+        #     }
+        #
+        data = self.safe_list(response, 'data', [])
+        result = self.safe_dict(data, 0, {})
+        fromCurrencyId = self.safe_string(result, 'baseCcy')
+        toCurrencyId = self.safe_string(result, 'quoteCcy')
+        fromCurrency = None
+        toCurrency = None
+        if fromCurrencyId is not None:
+            fromCurrency = self.currency(fromCurrencyId)
+        if toCurrencyId is not None:
+            toCurrency = self.currency(toCurrencyId)
+        return self.parse_conversion(result, fromCurrency, toCurrency)
+
+    async def fetch_convert_trade_history(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Conversion]:
+        """
+        fetch the users history of conversion trades
+        :see: https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-convert-history
+        :param str [code]: the unified currency code
+        :param int [since]: the earliest time in ms to fetch conversions for
+        :param int [limit]: the maximum number of conversion structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp in ms of the latest conversion to fetch
+        :returns dict[]: a list of `conversion structures <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        request = {}
+        request, params = self.handle_until_option('after', request, params)
+        if since is not None:
+            request['before'] = since
+        if limit is not None:
+            request['limit'] = limit
+        response = await self.privateGetAssetConvertHistory(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "data": [
+        #             {
+        #                 "clTReqId": "",
+        #                 "instId": "ETH-USDT",
+        #                 "side": "buy",
+        #                 "fillPx": "2932.401044",
+        #                 "baseCcy": "ETH",
+        #                 "quoteCcy": "USDT",
+        #                 "fillBaseSz": "0.01023052",
+        #                 "state": "fullyFilled",
+        #                 "tradeId": "trader16461885203381437",
+        #                 "fillQuoteSz": "30",
+        #                 "ts": "1646188520000"
+        #             }
+        #         ],
+        #         "msg": ""
+        #     }
+        #
+        rows = self.safe_list(response, 'data', [])
+        return self.parse_conversions(rows, 'baseCcy', 'quoteCcy', since, limit)
+
     def parse_conversion(self, conversion, fromCurrency: Currency = None, toCurrency: Currency = None) -> Conversion:
         #
         # fetchConvertQuote
@@ -7240,6 +7332,22 @@ class okx(Exchange, ImplicitAPI):
         #         "ts": "1646188520338"
         #     }
         #
+        # fetchConvertTrade, fetchConvertTradeHistory
+        #
+        #     {
+        #         "clTReqId": "",
+        #         "instId": "ETH-USDT",
+        #         "side": "buy",
+        #         "fillPx": "2932.401044",
+        #         "baseCcy": "ETH",
+        #         "quoteCcy": "USDT",
+        #         "fillBaseSz": "0.01023052",
+        #         "state": "fullyFilled",
+        #         "tradeId": "trader16461885203381437",
+        #         "fillQuoteSz": "30",
+        #         "ts": "1646188520000"
+        #     }
+        #
         timestamp = self.safe_integer_2(conversion, 'quoteTime', 'ts')
         fromCoin = self.safe_string(conversion, 'baseCcy')
         fromCode = self.safe_currency_code(fromCoin, fromCurrency)

ccxt/async_support/phemex.py

@@ -2699,11 +2699,15 @@ class phemex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelAllOrders() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
+        stop = self.safe_value_2(params, 'stop', 'trigger', False)
+        params = self.omit(params, 'stop', 'trigger')
         request = {
             'symbol': market['id'],
             # 'untriggerred': False,  # False to cancel non-conditional orders, True to cancel conditional orders
             # 'text': 'up to 40 characters max',
         }
+        if stop:
+            request['untriggerred'] = stop
         response = None
         if market['settle'] == 'USDT':
             response = await self.privateDeleteGOrdersAll(self.extend(request, params))

ccxt/async_support/poloniexfutures.py

@@ -383,8 +383,15 @@ class poloniexfutures(Exchange, ImplicitAPI):
         marketId = self.safe_string(ticker, 'symbol')
         symbol = self.safe_symbol(marketId, market)
         timestampString = self.safe_string(ticker, 'ts')
-        # check timestamp bcz bug: https://app.travis-ci.com/github/ccxt/ccxt/builds/269959181#L4011
-        multiplier = 0.00001 if (len(timestampString) == 18) else 0.000001
+        # check timestamp bcz bug: https://app.travis-ci.com/github/ccxt/ccxt/builds/269959181#L4011 and also 17 digits occured
+        multiplier = None
+        if len(timestampString) == 17:
+            multiplier = 0.0001
+        elif len(timestampString) == 18:
+            multiplier = 0.00001
+        else:
+            # 19 length default
+            multiplier = 0.000001
         timestamp = self.safe_integer_product(ticker, 'ts', multiplier)
         last = self.safe_string_2(ticker, 'price', 'lastPrice')
         percentage = Precise.string_mul(self.safe_string(ticker, 'priceChgPct'), '100')

ccxt/async_support/woo.py

@@ -69,6 +69,8 @@ class woo(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchConvertCurrencies': True,
                 'fetchConvertQuote': True,
+                'fetchConvertTrade': True,
+                'fetchConvertTradeHistory': True,
                 'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchDeposits': True,
@@ -2853,6 +2855,88 @@ class woo(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         return self.parse_conversion(data)
 
+    async def fetch_convert_trade(self, id: str, code: Str = None, params={}) -> Conversion:
+        """
+        fetch the data for a conversion trade
+        :see: https://docs.woo.org/#get-quote-trade
+        :param str id: the id of the trade that you want to fetch
+        :param str [code]: the unified currency code of the conversion trade
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `conversion structure <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        request = {
+            'quoteId': id,
+        }
+        response = await self.v3PrivateGetConvertTrade(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "quoteId": 12,
+        #             "buyAsset": "",
+        #             "sellAsset": "",
+        #             "buyAmount": 12.11,
+        #             "sellAmount": 12.11,
+        #             "tradeStatus": 12,
+        #             "createdTime": ""
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        fromCurrencyId = self.safe_string(data, 'sellAsset')
+        toCurrencyId = self.safe_string(data, 'buyAsset')
+        fromCurrency = None
+        toCurrency = None
+        if fromCurrencyId is not None:
+            fromCurrency = self.currency(fromCurrencyId)
+        if toCurrencyId is not None:
+            toCurrency = self.currency(toCurrencyId)
+        return self.parse_conversion(data, fromCurrency, toCurrency)
+
+    async def fetch_convert_trade_history(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Conversion]:
+        """
+        fetch the users history of conversion trades
+        :see: https://docs.woo.org/#get-quote-trades
+        :param str [code]: the unified currency code
+        :param int [since]: the earliest time in ms to fetch conversions for
+        :param int [limit]: the maximum number of conversion structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp in ms of the latest conversion to fetch
+        :returns dict[]: a list of `conversion structures <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        request = {}
+        request, params = self.handle_until_option('endTime', request, params)
+        if since is not None:
+            request['startTime'] = since
+        if limit is not None:
+            request['size'] = limit
+        response = await self.v3PrivateGetConvertTrades(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "count": 12,
+        #             "tradeVos":[
+        #                 {
+        #                     "quoteId": 12,
+        #                     "buyAsset": "",
+        #                     "sellAsset": "",
+        #                     "buyAmount": 12.11,
+        #                     "sellAmount": 12.11,
+        #                     "tradeStatus": 12,
+        #                     "createdTime": ""
+        #                 }
+        #                 ...
+        #             ]
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'tradeVos', [])
+        return self.parse_conversions(rows, 'sellAsset', 'buyAsset', since, limit)
+
     def parse_conversion(self, conversion, fromCurrency: Currency = None, toCurrency: Currency = None) -> Conversion:
         #
         # fetchConvertQuote
@@ -2877,10 +2961,22 @@ class woo(Exchange, ImplicitAPI):
         #         "rftAccepted": 1  # 1 -> success; 2 -> processing; 3 -> fail
         #     }
         #
-        timestamp = self.safe_integer(conversion, 'expireTimestamp')
-        fromCoin = self.safe_string(conversion, 'sellToken')
-        fromCode = self.safe_currency_code(fromCoin, fromCurrency)
-        to = self.safe_string(conversion, 'buyToken')
+        # fetchConvertTrade, fetchConvertTradeHistory
+        #
+        #     {
+        #         "quoteId": 12,
+        #         "buyAsset": "",
+        #         "sellAsset": "",
+        #         "buyAmount": 12.11,
+        #         "sellAmount": 12.11,
+        #         "tradeStatus": 12,
+        #         "createdTime": ""
+        #     }
+        #
+        timestamp = self.safe_integer_2(conversion, 'expireTimestamp', 'createdTime')
+        fromCurr = self.safe_string_2(conversion, 'sellToken', 'buyAsset')
+        fromCode = self.safe_currency_code(fromCurr, fromCurrency)
+        to = self.safe_string_2(conversion, 'buyToken', 'sellAsset')
         toCode = self.safe_currency_code(to, toCurrency)
         return {
             'info': conversion,
@@ -2888,9 +2984,9 @@ class woo(Exchange, ImplicitAPI):
             'datetime': self.iso8601(timestamp),
             'id': self.safe_string(conversion, 'quoteId'),
             'fromCurrency': fromCode,
-            'fromAmount': self.safe_number(conversion, 'sellQuantity'),
+            'fromAmount': self.safe_number_2(conversion, 'sellQuantity', 'sellAmount'),
             'toCurrency': toCode,
-            'toAmount': self.safe_number(conversion, 'buyQuantity'),
+            'toAmount': self.safe_number_2(conversion, 'buyQuantity', 'buyAmount'),
             'price': self.safe_number(conversion, 'buyPrice'),
             'fee': None,
         }

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.2'
+__version__ = '4.3.4'
 
 # -----------------------------------------------------------------------------
 
@@ -5454,6 +5454,25 @@ class Exchange(object):
     def parse_leverage(self, leverage, market: Market = None):
         raise NotSupported(self.id + ' parseLeverage() is not supported yet')
 
+    def parse_conversions(self, conversions: List[Any], fromCurrencyKey: Str = None, toCurrencyKey: Str = None, since: Int = None, limit: Int = None, params={}):
+        conversions = self.to_array(conversions)
+        result = []
+        fromCurrency = None
+        toCurrency = None
+        for i in range(0, len(conversions)):
+            entry = conversions[i]
+            fromId = self.safe_string(entry, fromCurrencyKey)
+            toId = self.safe_string(entry, toCurrencyKey)
+            if fromId is not None:
+                fromCurrency = self.currency(fromId)
+            if toId is not None:
+                toCurrency = self.currency(toId)
+            conversion = self.extend(self.parseConversion(entry, fromCurrency, toCurrency), params)
+            result.append(conversion)
+        sorted = self.sort_by(result, 'timestamp')
+        code = fromCurrency['code'] if (fromCurrency is not None) else None
+        return self.filter_by_currency_since_limit(sorted, code, since, limit)
+
     def parse_conversion(self, conversion, fromCurrency: Currency = None, toCurrency: Currency = None):
         raise NotSupported(self.id + ' parseConversion() is not supported yet')