ccxt 4.4.85__py2.py3-none-any.whl → 4.4.87__py2.py3-none-any.whl

ccxt/ascendex.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.ascendex import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Any, Balances, Bool, Currencies, Currency, DepositAddress, Int, Leverage, Leverages, LeverageTier, LeverageTiers, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Account, Any, Balances, Currencies, Currency, DepositAddress, Int, Leverage, Leverages, LeverageTier, LeverageTiers, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -477,6 +477,7 @@ class ascendex(Exchange, ImplicitAPI):
                 'broad': {},
             },
             'commonCurrencies': {
+                'XBT': 'XBT',  # self is not BTC ! just another token
                 'BOND': 'BONDED',
                 'BTCBEAR': 'BEAR',
                 'BTCBULL': 'BULL',
@@ -497,112 +498,82 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
-        assetsPromise = self.v1PublicGetAssets(params)
-        #
-        #     {
-        #         "code":0,
-        #         "data":[
-        #             {
-        #                 "assetCode" : "LTCBULL",
-        #                 "assetName" : "3X Long LTC Token",
-        #                 "precisionScale" : 9,
-        #                 "nativeScale" : 4,
-        #                 "withdrawalFee" : "0.2",
-        #                 "minWithdrawalAmt" : "1.0",
-        #                 "status" : "Normal"
-        #             },
-        #         ]
-        #     }
-        #
-        marginPromise = self.v1PublicGetMarginAssets(params)
-        #
-        #     {
-        #         "code":0,
-        #         "data":[
-        #             {
-        #                 "assetCode":"BTT",
-        #                 "displayName": "BTT",
-        #                 "borrowAssetCode":"BTT-B",
-        #                 "interestAssetCode":"BTT-I",
-        #                 "nativeScale":0,
-        #                 "numConfirmations":1,
-        #                 "withdrawFee":"100.0",
-        #                 "minWithdrawalAmt":"1000.0",
-        #                 "statusCode":"Normal",
-        #                 "statusMessage":"",
-        #                 "interestRate":"0.001"
-        #             }
-        #         ]
-        #     }
-        #
-        cashPromise = self.v1PublicGetCashAssets(params)
+        response = self.v2PublicGetAssets(params)
         #
-        #     {
-        #         "code":0,
-        #         "data":[
-        #             {
-        #                 "assetCode":"LTCBULL",
-        #                 "displayName": "LTCBULL",
-        #                 "nativeScale":4,
-        #                 "numConfirmations":20,
-        #                 "withdrawFee":"0.2",
-        #                 "minWithdrawalAmt":"1.0",
-        #                 "statusCode":"Normal",
-        #                 "statusMessage":""  # hideFromWalletTx
-        #             }
+        #    {
+        #        "code": "0",
+        #        "data": [
+        #            {
+        #                "assetCode": "USDT",
+        #                "assetName": "Tether",
+        #                "precisionScale": 9,
+        #                "nativeScale": 4,
+        #                "blockChain": [
+        #                    {
+        #                        "chainName": "Solana",
+        #                        "withdrawFee": "2.0",
+        #                        "allowDeposit": True,
+        #                        "allowWithdraw": True,
+        #                        "minDepositAmt": "0.01",
+        #                        "minWithdrawal": "4.0",
+        #                        "numConfirmations": 1
+        #                    },
+        #                    ...
+        #                ]
+        #            },
         #         ]
-        #     }
+        #    }
         #
-        assets, margin, cash = [assetsPromise, marginPromise, cashPromise]
-        assetsData = self.safe_list(assets, 'data', [])
-        marginData = self.safe_list(margin, 'data', [])
-        cashData = self.safe_list(cash, 'data', [])
-        assetsById = self.index_by(assetsData, 'assetCode')
-        marginById = self.index_by(marginData, 'assetCode')
-        cashById = self.index_by(cashData, 'assetCode')
-        dataById = self.deep_extend(assetsById, marginById, cashById)
-        ids = list(dataById.keys())
+        data = self.safe_list(response, 'data', [])
         result: dict = {}
-        for i in range(0, len(ids)):
-            id = self.safe_string(ids, i)
-            currency = dataById[id]
+        for i in range(0, len(data)):
+            currency = data[i]
+            id = self.safe_string(currency, 'assetCode')
             code = self.safe_currency_code(id)
-            scale = self.safe_string_2(currency, 'precisionScale', 'nativeScale')
-            precision = self.parse_number(self.parse_precision(scale))
-            fee = self.safe_number_2(currency, 'withdrawFee', 'withdrawalFee')
-            status = self.safe_string(currency, 'status')
-            statusCode = self.safe_string(currency, 'statusCode')
-            active = (status == 'Normal')
-            depositEnabled: Bool = None
-            withdrawEnabled: Bool = None
-            if status == 'Delisted' or statusCode == 'hideFromWalletTx':
-                depositEnabled = False
-                withdrawEnabled = False
-            elif status == 'Normal':
-                depositEnabled = True
-                withdrawEnabled = True
-            elif status == 'NoTransaction' or statusCode == 'NoTransaction':
-                depositEnabled = True
-                withdrawEnabled = False
-            elif status == 'NoDeposit':
-                depositEnabled = False
-                withdrawEnabled = True
-            marginInside = ('borrowAssetCode' in currency)
-            result[code] = {
+            chains = self.safe_list(currency, 'blockChain', [])
+            precision = self.parse_number(self.parse_precision(self.safe_string(currency, 'nativeScale')))
+            networks = {}
+            for j in range(0, len(chains)):
+                networkEtnry = chains[j]
+                networkId = self.safe_string(networkEtnry, 'chainName')
+                networkCode = self.network_code_to_id(networkId)
+                networks[networkCode] = {
+                    'fee': self.safe_number(networkEtnry, 'withdrawFee'),
+                    'active': None,
+                    'withdraw': self.safe_bool(networkEtnry, 'allowWithdraw'),
+                    'deposit': self.safe_bool(networkEtnry, 'allowDeposit'),
+                    'precision': precision,
+                    'limits': {
+                        'amount': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': self.safe_number(networkEtnry, 'minWithdrawal'),
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': self.safe_number(networkEtnry, 'minDepositAmt'),
+                            'max': None,
+                        },
+                    },
+                }
+            # todo type: if chainsLength == 0 and (assetName.endswith(' Staking') or assetName.find(' Reward ') >= 0 or assetName.find('Slot Auction') >= 0 or assetName.find(' Freeze Asset') >= 0):
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'type': None,
-                'margin': marginInside,
+                'margin': None,
                 'name': self.safe_string(currency, 'assetName'),
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'fee': fee,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
                 'precision': precision,
                 'limits': {
                     'amount': {
-                        'min': precision,
+                        'min': None,
                         'max': None,
                     },
                     'withdraw': {
@@ -610,8 +581,8 @@ class ascendex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},  # todo
-            }
+                'networks': networks,
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:
@@ -620,6 +591,12 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
+        spotPromise = self.fetch_spot_markets(params)
+        contractPromise = self.fetch_contract_markets(params)
+        spotMarkets, contractMarkets = [spotPromise, contractPromise]
+        return self.array_concat(spotMarkets, contractMarkets)
+
+    def fetch_spot_markets(self, params={}) -> List[Market]:
         productsPromise = self.v1PublicGetProducts(params)
         #
         #     {
@@ -671,7 +648,91 @@ class ascendex(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        perpetualsPromise = self.v2PublicGetFuturesContract(params)
+        products, cash = [productsPromise, cashPromise]
+        productsData = self.safe_list(products, 'data', [])
+        productsById = self.index_by(productsData, 'symbol')
+        cashData = self.safe_list(cash, 'data', [])
+        cashAndPerpetualsById = self.index_by(cashData, 'symbol')
+        dataById = self.deep_extend(productsById, cashAndPerpetualsById)
+        ids = list(dataById.keys())
+        result = []
+        for i in range(0, len(ids)):
+            id = ids[i]
+            if id.find('-PERP') >= 0:
+                continue  # skip perpetuals, endpoint returns them
+            market = dataById[id]
+            status = self.safe_string(market, 'status')
+            domain = self.safe_string(market, 'domain')
+            active = False
+            if ((status == 'Normal') or (status == 'InternalTrading')) and (domain != 'LeveragedETF'):
+                active = True
+            minQty = self.safe_number(market, 'minQty')
+            maxQty = self.safe_number(market, 'maxQty')
+            minPrice = self.safe_number(market, 'tickSize')
+            maxPrice: Num = None
+            underlying = self.safe_string_2(market, 'underlying', 'symbol')
+            parts = underlying.split('/')
+            baseId = self.safe_string(parts, 0)
+            quoteId = self.safe_string(parts, 1)
+            base = self.safe_currency_code(baseId)
+            quote = self.safe_currency_code(quoteId)
+            fee = self.safe_number(market, 'commissionReserveRate')
+            marginTradable = self.safe_bool(market, 'marginTradable', False)
+            result.append({
+                'id': id,
+                'symbol': base + '/' + quote,
+                'base': base,
+                'baseId': baseId,
+                'quote': quote,
+                'quoteId': quoteId,
+                'settle': None,
+                'settleId': None,
+                'type': 'spot',
+                'spot': True,
+                'margin': marginTradable,
+                'swap': False,
+                'future': False,
+                'option': False,
+                'active': active,
+                'contract': False,
+                'linear': None,
+                'inverse': None,
+                'taker': fee,
+                'maker': fee,
+                'contractSize': None,
+                'expiry': None,
+                'expiryDatetime': None,
+                'strike': None,
+                'optionType': None,
+                'precision': {
+                    'amount': self.safe_number(market, 'lotSize'),
+                    'price': self.safe_number(market, 'tickSize'),
+                },
+                'limits': {
+                    'leverage': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'amount': {
+                        'min': minQty,
+                        'max': maxQty,
+                    },
+                    'price': {
+                        'min': minPrice,
+                        'max': maxPrice,
+                    },
+                    'cost': {
+                        'min': self.safe_number(market, 'minNotional'),
+                        'max': self.safe_number(market, 'maxNotional'),
+                    },
+                },
+                'created': self.safe_integer(market, 'tradingStartTime'),
+                'info': market,
+            })
+        return result
+
+    def fetch_contract_markets(self, params={}) -> List[Market]:
+        contracts = self.v2PublicGetFuturesContract(params)
         #
         #    {
         #        "code": 0,
@@ -684,9 +745,9 @@ class ascendex(Exchange, ImplicitAPI):
         #                "underlying": "BTC/USDT",
         #                "tradingStartTime": 1579701600000,
         #                "priceFilter": {
-        #                    "minPrice": "1",
+        #                    "minPrice": "0.1",
         #                    "maxPrice": "1000000",
-        #                    "tickSize": "1"
+        #                    "tickSize": "0.1"
         #                },
         #                "lotSizeFilter": {
         #                    "minQty": "0.0001",
@@ -709,50 +770,25 @@ class ascendex(Exchange, ImplicitAPI):
         #        ]
         #    }
         #
-        products, cash, perpetuals = [productsPromise, cashPromise, perpetualsPromise]
-        productsData = self.safe_list(products, 'data', [])
-        productsById = self.index_by(productsData, 'symbol')
-        cashData = self.safe_list(cash, 'data', [])
-        perpetualsData = self.safe_list(perpetuals, 'data', [])
-        cashAndPerpetualsData = self.array_concat(cashData, perpetualsData)
-        cashAndPerpetualsById = self.index_by(cashAndPerpetualsData, 'symbol')
-        dataById = self.deep_extend(productsById, cashAndPerpetualsById)
-        ids = list(dataById.keys())
+        data = self.safe_list(contracts, 'data', [])
         result = []
-        for i in range(0, len(ids)):
-            id = ids[i]
-            market = dataById[id]
-            settleId = self.safe_string(market, 'settlementAsset')
-            settle = self.safe_currency_code(settleId)
-            status = self.safe_string(market, 'status')
-            domain = self.safe_string(market, 'domain')
-            active = False
-            if ((status == 'Normal') or (status == 'InternalTrading')) and (domain != 'LeveragedETF'):
-                active = True
-            spot = settle is None
-            swap = not spot
-            linear = True if swap else None
-            minQty = self.safe_number(market, 'minQty')
-            maxQty = self.safe_number(market, 'maxQty')
-            minPrice = self.safe_number(market, 'tickSize')
-            maxPrice: Num = None
-            underlying = self.safe_string_2(market, 'underlying', 'symbol')
+        for i in range(0, len(data)):
+            market = data[i]
+            id = self.safe_string(market, 'symbol')
+            underlying = self.safe_string(market, 'underlying')
             parts = underlying.split('/')
             baseId = self.safe_string(parts, 0)
-            quoteId = self.safe_string(parts, 1)
             base = self.safe_currency_code(baseId)
+            quoteId = self.safe_string(parts, 1)
             quote = self.safe_currency_code(quoteId)
-            symbol = base + '/' + quote
-            if swap:
-                lotSizeFilter = self.safe_dict(market, 'lotSizeFilter')
-                minQty = self.safe_number(lotSizeFilter, 'minQty')
-                maxQty = self.safe_number(lotSizeFilter, 'maxQty')
-                priceFilter = self.safe_dict(market, 'priceFilter')
-                minPrice = self.safe_number(priceFilter, 'minPrice')
-                maxPrice = self.safe_number(priceFilter, 'maxPrice')
-                symbol = base + '/' + quote + ':' + settle
+            settleId = self.safe_string(market, 'settlementAsset')
+            settle = self.safe_currency_code(settleId)
+            linear = settle == quote
+            inverse = settle == base
+            symbol = base + '/' + quote + ':' + settle
+            priceFilter = self.safe_dict(market, 'priceFilter')
+            lotSizeFilter = self.safe_dict(market, 'lotSizeFilter')
             fee = self.safe_number(market, 'commissionReserveRate')
-            marginTradable = self.safe_bool(market, 'marginTradable', False)
             result.append({
                 'id': id,
                 'symbol': symbol,
@@ -762,26 +798,26 @@ class ascendex(Exchange, ImplicitAPI):
                 'baseId': baseId,
                 'quoteId': quoteId,
                 'settleId': settleId,
-                'type': 'swap' if swap else 'spot',
-                'spot': spot,
-                'margin': marginTradable if spot else None,
-                'swap': swap,
+                'type': 'swap',
+                'spot': False,
+                'margin': None,
+                'swap': True,
                 'future': False,
                 'option': False,
-                'active': active,
-                'contract': swap,
+                'active': self.safe_string(market, 'status') == 'Normal',
+                'contract': True,
                 'linear': linear,
-                'inverse': not linear if swap else None,
+                'inverse': inverse,
                 'taker': fee,
                 'maker': fee,
-                'contractSize': self.parse_number('1') if swap else None,
+                'contractSize': self.parse_number('1'),
                 'expiry': None,
                 'expiryDatetime': None,
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.safe_number(market, 'lotSize'),
-                    'price': self.safe_number(market, 'tickSize'),
+                    'amount': self.safe_number(lotSizeFilter, 'lotSize'),
+                    'price': self.safe_number(priceFilter, 'tickSize'),
                 },
                 'limits': {
                     'leverage': {
@@ -789,12 +825,12 @@ class ascendex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                     'amount': {
-                        'min': minQty,
-                        'max': maxQty,
+                        'min': self.safe_number(lotSizeFilter, 'minQty'),
+                        'max': self.safe_number(lotSizeFilter, 'maxQty'),
                     },
                     'price': {
-                        'min': minPrice,
-                        'max': maxPrice,
+                        'min': self.safe_number(priceFilter, 'minPrice'),
+                        'max': self.safe_number(priceFilter, 'maxPrice'),
                     },
                     'cost': {
                         'min': self.safe_number(market, 'minNotional'),

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.85'
+__version__ = '4.4.87'
 
 # -----------------------------------------------------------------------------
 
@@ -87,6 +87,7 @@ from ccxt.async_support.bitrue import bitrue
 from ccxt.async_support.bitso import bitso                                      # noqa: F401
 from ccxt.async_support.bitstamp import bitstamp                                # noqa: F401
 from ccxt.async_support.bitteam import bitteam                                  # noqa: F401
+from ccxt.async_support.bittrade import bittrade                                # noqa: F401
 from ccxt.async_support.bitvavo import bitvavo                                  # noqa: F401
 from ccxt.async_support.blockchaincom import blockchaincom                      # noqa: F401
 from ccxt.async_support.blofin import blofin                                    # noqa: F401
@@ -127,7 +128,6 @@ from ccxt.async_support.hitbtc import hitbtc
 from ccxt.async_support.hollaex import hollaex                                  # noqa: F401
 from ccxt.async_support.htx import htx                                          # noqa: F401
 from ccxt.async_support.huobi import huobi                                      # noqa: F401
-from ccxt.async_support.huobijp import huobijp                                  # noqa: F401
 from ccxt.async_support.hyperliquid import hyperliquid                          # noqa: F401
 from ccxt.async_support.independentreserve import independentreserve            # noqa: F401
 from ccxt.async_support.indodax import indodax                                  # noqa: F401
@@ -135,18 +135,19 @@ from ccxt.async_support.kraken import kraken
 from ccxt.async_support.krakenfutures import krakenfutures                      # noqa: F401
 from ccxt.async_support.kucoin import kucoin                                    # noqa: F401
 from ccxt.async_support.kucoinfutures import kucoinfutures                      # noqa: F401
-from ccxt.async_support.kuna import kuna                                        # noqa: F401
 from ccxt.async_support.latoken import latoken                                  # noqa: F401
 from ccxt.async_support.lbank import lbank                                      # noqa: F401
 from ccxt.async_support.luno import luno                                        # noqa: F401
 from ccxt.async_support.mercado import mercado                                  # noqa: F401
 from ccxt.async_support.mexc import mexc                                        # noqa: F401
+from ccxt.async_support.modetrade import modetrade                              # noqa: F401
 from ccxt.async_support.myokx import myokx                                      # noqa: F401
 from ccxt.async_support.ndax import ndax                                        # noqa: F401
 from ccxt.async_support.novadax import novadax                                  # noqa: F401
 from ccxt.async_support.oceanex import oceanex                                  # noqa: F401
 from ccxt.async_support.okcoin import okcoin                                    # noqa: F401
 from ccxt.async_support.okx import okx                                          # noqa: F401
+from ccxt.async_support.okxus import okxus                                      # noqa: F401
 from ccxt.async_support.onetrading import onetrading                            # noqa: F401
 from ccxt.async_support.oxfun import oxfun                                      # noqa: F401
 from ccxt.async_support.p2b import p2b                                          # noqa: F401
@@ -194,6 +195,7 @@ exchanges = [
     'bitso',
     'bitstamp',
     'bitteam',
+    'bittrade',
     'bitvavo',
     'blockchaincom',
     'blofin',
@@ -234,7 +236,6 @@ exchanges = [
     'hollaex',
     'htx',
     'huobi',
-    'huobijp',
     'hyperliquid',
     'independentreserve',
     'indodax',
@@ -242,18 +243,19 @@ exchanges = [
     'krakenfutures',
     'kucoin',
     'kucoinfutures',
-    'kuna',
     'latoken',
     'lbank',
     'luno',
     'mercado',
     'mexc',
+    'modetrade',
     'myokx',
     'ndax',
     'novadax',
     'oceanex',
     'okcoin',
     'okx',
+    'okxus',
     'onetrading',
     'oxfun',
     'p2b',