ccxt 4.4.90__py2.py3-none-any.whl → 4.4.92__py2.py3-none-any.whl

ccxt/lbank.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.lbank import ImplicitAPI
 import hashlib
-from ccxt.base.types import Any, Balances, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFeeInterface, TradingFees, Transaction
+from ccxt.base.types import Any, Balances, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFeeInterface, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -61,6 +61,7 @@ class lbank(Exchange, ImplicitAPI):
                 'fetchClosedOrders': False,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
+                'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchDepositAddresses': False,
                 'fetchDepositAddressesByNetwork': False,
@@ -135,6 +136,7 @@ class lbank(Exchange, ImplicitAPI):
                             'currencyPairs': 2.5,
                             'accuracy': 2.5,
                             'usdToCny': 2.5,
+                            'assetConfigs': 2.5,
                             'withdrawConfigs': 2.5,
                             'timestamp': 2.5,
                             'ticker/24hr': 2.5,
@@ -221,6 +223,7 @@ class lbank(Exchange, ImplicitAPI):
                 },
             },
             'commonCurrencies': {
+                'XBT': 'XBT',  # not BTC!
                 'HIT': 'Hiver',
                 'VET_ERC20': 'VEN',
                 'PNT': 'Penta',
@@ -288,21 +291,12 @@ class lbank(Exchange, ImplicitAPI):
                     #     ptx: 1
                     # }
                 },
-                'inverse-networks': {
+                'networksById': {
                     'erc20': 'ERC20',
                     'trc20': 'TRC20',
-                    'omni': 'OMNI',
-                    'asa': 'ASA',
-                    'bep20(bsc)': 'BSC',
-                    'bep20': 'BSC',
-                    'heco': 'HT',
-                    'bep2': 'BNB',
-                    'btc': 'BTC',
-                    'dogecoin': 'DOGE',
-                    'matic': 'MATIC',
-                    'oec': 'OEC',
-                    'btctron': 'BTCTRON',
-                    'xrp': 'XRP',
+                    'TRX': 'TRC20',
+                    'bep20(bsc)': 'BEP20',
+                    'bep20': 'BEP20',
                 },
                 'defaultNetworks': {
                     'USDT': 'TRC20',
@@ -423,6 +417,104 @@ class lbank(Exchange, ImplicitAPI):
         #
         return self.safe_integer(response, 'data')
 
+    def fetch_currencies(self, params={}) -> Currencies:
+        """
+        fetches all available currencies on an exchange
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        response = self.spotPublicGetWithdrawConfigs(params)
+        #
+        #    {
+        #        "msg": "Success",
+        #        "result": "true",
+        #        "data": [
+        #            {
+        #                "amountScale": "4",
+        #                "chain": "bep20(bsc)",
+        #                "assetCode": "usdt",
+        #                "min": "10",
+        #                "transferAmtScale": "4",
+        #                "canWithDraw": True,
+        #                "fee": "0.0000",
+        #                "minTransfer": "0.0001",
+        #                "type": "1"
+        #            },
+        #            {
+        #                "amountScale": "4",
+        #                "chain": "trc20",
+        #                "assetCode": "usdt",
+        #                "min": "1",
+        #                "transferAmtScale": "4",
+        #                "canWithDraw": True,
+        #                "fee": "1.0000",
+        #                "minTransfer": "0.0001",
+        #                "type": "1"
+        #            },
+        #            ...
+        #        ],
+        #        "error_code": "0",
+        #        "ts": "1747973911431"
+        #    }
+        #
+        currenciesData = self.safe_list(response, 'data', [])
+        grouped = self.group_by(currenciesData, 'assetCode')
+        groupedKeys = list(grouped.keys())
+        result: dict = {}
+        for i in range(0, len(groupedKeys)):
+            id = str((groupedKeys[i]))  # some currencies are numeric
+            code = self.safe_currency_code(id)
+            networksRaw = grouped[id]
+            networks = {}
+            for j in range(0, len(networksRaw)):
+                networkEntry = networksRaw[j]
+                networkId = self.safe_string(networkEntry, 'chain')
+                networkCode = self.network_id_to_code(networkId)
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
+                    'limits': {
+                        'withdraw': {
+                            'min': self.safe_number(networkEntry, 'min'),
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': self.safe_number(networkEntry, 'minTransfer'),
+                            'max': None,
+                        },
+                    },
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': self.safe_bool(networkEntry, 'canWithDraw'),
+                    'fee': self.safe_number(networkEntry, 'fee'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(networkEntry, 'transferAmtScale'))),
+                    'info': networkEntry,
+                }
+            result[code] = self.safe_currency_structure({
+                'id': id,
+                'code': code,
+                'precision': None,
+                'type': None,
+                'name': None,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
+                'limits': {
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'networks': networks,
+                'info': networksRaw,
+            })
+        return result
+
     def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for lbank
@@ -2097,13 +2189,10 @@ class lbank(Exchange, ImplicitAPI):
         result = self.safe_value(response, 'data')
         address = self.safe_string(result, 'address')
         tag = self.safe_string(result, 'memo')
-        networkId = self.safe_string(result, 'netWork')
-        inverseNetworks = self.safe_value(self.options, 'inverse-networks', {})
-        networkCode = self.safe_string_upper(inverseNetworks, networkId, networkId)
         return {
             'info': response,
             'currency': code,
-            'network': networkCode,
+            'network': self.network_id_to_code(self.safe_string(result, 'netWork')),
             'address': address,
             'tag': tag,
         }
@@ -2137,12 +2226,10 @@ class lbank(Exchange, ImplicitAPI):
         result = self.safe_value(response, 'data')
         address = self.safe_string(result, 'address')
         tag = self.safe_string(result, 'memo')
-        inverseNetworks = self.safe_value(self.options, 'inverse-networks', {})
-        networkCode = self.safe_string_upper(inverseNetworks, network, network)
         return {
             'info': response,
             'currency': code,
-            'network': networkCode,  # will be None if not specified in request
+            'network': None,
             'address': address,
             'tag': tag,
         }
@@ -2262,9 +2349,6 @@ class lbank(Exchange, ImplicitAPI):
             type = 'withdrawal'
         txid = self.safe_string(transaction, 'txId')
         timestamp = self.safe_integer_2(transaction, 'insertTime', 'applyTime')
-        networks = self.safe_value(self.options, 'inverse-networks', {})
-        networkId = self.safe_string(transaction, 'networkName')
-        network = self.safe_string(networks, networkId, networkId)
         address = self.safe_string(transaction, 'address')
         addressFrom = None
         addressTo = None
@@ -2289,7 +2373,7 @@ class lbank(Exchange, ImplicitAPI):
             'txid': txid,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
-            'network': network,
+            'network': self.network_id_to_code(self.safe_string(transaction, 'networkName')),
             'address': address,
             'addressTo': addressTo,
             'addressFrom': addressFrom,
@@ -2482,10 +2566,9 @@ class lbank(Exchange, ImplicitAPI):
             withdrawFees[code] = {}
             for j in range(0, len(networkList)):
                 networkEntry = networkList[j]
-                networkId = self.safe_string(networkEntry, 'name')
-                networkCode = self.safe_string(self.options['inverse-networks'], networkId, networkId)
                 fee = self.safe_number(networkEntry, 'withdrawFee')
                 if fee is not None:
+                    networkCode = self.network_id_to_code(self.safe_string(networkEntry, 'name'))
                     withdrawFees[code][networkCode] = fee
         return {
             'withdraw': withdrawFees,
@@ -2533,8 +2616,7 @@ class lbank(Exchange, ImplicitAPI):
             if canWithdraw == 'true':
                 currencyId = self.safe_string(item, 'assetCode')
                 codeInner = self.safe_currency_code(currencyId)
-                chain = self.safe_string(item, 'chain')
-                network = self.safe_string(self.options['inverse-networks'], chain, chain)
+                network = self.network_id_to_code(self.safe_string(item, 'chain'))
                 if network is None:
                     network = codeInner
                 fee = self.safe_string(item, 'fee')
@@ -2675,8 +2757,7 @@ class lbank(Exchange, ImplicitAPI):
                         else:
                             resultCodeInfo = result[code]['info']
                             resultCodeInfo.append(fee)
-                        chain = self.safe_string(fee, 'chain')
-                        networkCode = self.safe_string(self.options['inverse-networks'], chain, chain)
+                        networkCode = self.network_id_to_code(self.safe_string(fee, 'chain'))
                         if networkCode is not None:
                             result[code]['networks'][networkCode] = {
                                 'withdraw': {
@@ -2726,8 +2807,7 @@ class lbank(Exchange, ImplicitAPI):
         networkList = self.safe_value(fee, 'networkList', [])
         for j in range(0, len(networkList)):
             networkEntry = networkList[j]
-            networkId = self.safe_string(networkEntry, 'name')
-            networkCode = self.safe_string_upper(self.options['inverse-networks'], networkId, networkId)
+            networkCode = self.network_id_to_code(self.safe_string(networkEntry, 'name'))
             withdrawFee = self.safe_number(networkEntry, 'withdrawFee')
             isDefault = self.safe_value(networkEntry, 'isDefault')
             if withdrawFee is not None:

ccxt/mexc.py

@@ -854,6 +854,7 @@ class mexc(Exchange, ImplicitAPI):
                 'PROS': 'PROSFINANCE',  # conflict with Prosper
                 'SIN': 'SINCITYTOKEN',
                 'SOUL': 'SOULSWAP',
+                'XBT': 'XBT',  # restore original mapping
             },
             'exceptions': {
                 'exact': {

ccxt/modetrade.py

@@ -1651,7 +1651,7 @@ class modetrade(Exchange, ImplicitAPI):
         #
         # {
         #     "success": True,
-        #     "timestamp": 1702989203989,
+        #     "timestamp": 1702989203988,
         #     "data": {
         #       "status": "CANCEL_SENT"
         #     }
@@ -1659,7 +1659,7 @@ class modetrade(Exchange, ImplicitAPI):
         #
         # {
         #     "success": True,
-        #     "timestamp": 1702989203989,
+        #     "timestamp": 1702989203988,
         #     "status": "CANCEL_SENT"
         # }
         #

ccxt/okx.py

@@ -4893,7 +4893,7 @@ class okx(Exchange, ImplicitAPI):
         fee = self.safe_string(params, 'fee')
         if fee is None:
             currencies = self.fetch_currencies()
-            self.currencies = self.deep_extend(self.currencies, currencies)
+            self.currencies = self.map_to_safe_map(self.deep_extend(self.currencies, currencies))
             targetNetwork = self.safe_dict(currency['networks'], self.network_id_to_code(network), {})
             fee = self.safe_string(targetNetwork, 'fee')
             if fee is None:
@@ -6843,7 +6843,7 @@ class okx(Exchange, ImplicitAPI):
 
     def fetch_borrow_interest(self, code: Str = None, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[BorrowInterest]:
         """
-        fetch the interest owed by the user for borrowing currency for margin trading
+        fetch the interest owed b the user for borrowing currency for margin trading
 
         https://www.okx.com/docs-v5/en/#rest-api-account-get-interest-accrued-data
 

ccxt/paradex.py

@@ -785,7 +785,7 @@ class paradex(Exchange, ImplicitAPI):
         #         "ask": "69578.2",
         #         "volume_24h": "5815541.397939004",
         #         "total_volume": "584031465.525259686",
-        #         "created_at": 1718170156580,
+        #         "created_at": 1718170156581,
         #         "underlying_price": "67367.37268422",
         #         "open_interest": "162.272",
         #         "funding_rate": "0.01629574927887",

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.90'
+__version__ = '4.4.92'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitstamp.py

@@ -502,7 +502,7 @@ class bitstamp(ccxt.async_support.bitstamp):
             #
             sessionToken = self.safe_string(response, 'token')
             if sessionToken is not None:
-                userId = self.safe_number(response, 'user_id')
+                userId = self.safe_string(response, 'user_id')
                 validity = self.safe_integer_product(response, 'valid_sec', 1000)
                 self.options['expiresIn'] = self.sum(time, validity)
                 self.options['userId'] = userId

ccxt/pro/bybit.py

@@ -14,6 +14,7 @@ from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
+from ccxt.base.errors import NotSupported
 
 
 class bybit(ccxt.async_support.bybit):
@@ -1235,8 +1236,7 @@ class bybit(ccxt.async_support.bybit):
         subHash = 'myTrades'
         await self.load_markets()
         if symbol is not None:
-            symbol = self.symbol(symbol)
-            subHash += ':' + symbol
+            raise NotSupported(self.id + ' unWatchMyTrades() does not support a symbol parameter, you must unwatch all my trades')
         url = await self.get_url_by_market_type(symbol, True, method, params)
         await self.authenticate(url)
         topicByMarket: dict = {
@@ -1652,8 +1652,7 @@ class bybit(ccxt.async_support.bybit):
         messageHash = 'unsubscribe:orders'
         subHash = 'orders'
         if symbol is not None:
-            symbol = self.symbol(symbol)
-            subHash += ':' + symbol
+            raise NotSupported(self.id + ' unWatchOrders() does not support a symbol parameter, you must unwatch all orders')
         url = await self.get_url_by_market_type(symbol, True, method, params)
         await self.authenticate(url)
         topicsByMarket: dict = {
@@ -1786,11 +1785,12 @@ class bybit(ccxt.async_support.bybit):
             rawOrders = self.safe_value(rawOrders, 'result', rawOrders)
         symbols: dict = {}
         for i in range(0, len(rawOrders)):
-            parsed = None
-            if isSpot:
-                parsed = self.parse_ws_spot_order(rawOrders[i])
-            else:
-                parsed = self.parse_order(rawOrders[i])
+            parsed = self.parse_order(rawOrders[i])
+            # if isSpot:
+            #     parsed = self.parseWsSpotOrder(rawOrders[i])
+            # else:
+            #     parsed = self.parse_order(rawOrders[i])
+            # }
             symbol = parsed['symbol']
             symbols[symbol] = True
             orders.append(parsed)
@@ -1801,137 +1801,6 @@ class bybit(ccxt.async_support.bybit):
         messageHash = 'orders'
         client.resolve(orders, messageHash)
 
-    def parse_ws_spot_order(self, order, market=None):
-        #
-        #    {
-        #        "e": "executionReport",
-        #        "E": "1653297251061",  # timestamp
-        #        "s": "LTCUSDT",  # symbol
-        #        "c": "1653297250740",  # user id
-        #        "S": "SELL",  # side
-        #        "o": "MARKET_OF_BASE",  # order type
-        #        "f": "GTC",  # time in force
-        #        "q": "0.16233",  # quantity
-        #        "p": "0",  # price
-        #        "X": "NEW",  # status
-        #        "i": "1162336018974750208",  # order id
-        #        "M": "0",
-        #        "l": "0",  # last filled
-        #        "z": "0",  # total filled
-        #        "L": "0",  # last traded price
-        #        "n": "0",  # trading fee
-        #        "N": '',  # fee asset
-        #        "u": True,
-        #        "w": True,
-        #        "m": False,  # is limit_maker
-        #        "O": "1653297251042",  # order creation
-        #        "Z": "0",  # total filled
-        #        "A": "0",  # account id
-        #        "C": False,  # is close
-        #        "v": "0",  # leverage
-        #        "d": "NO_LIQ"
-        #    }
-        # v5
-        #    {
-        #        "category":"spot",
-        #        "symbol":"LTCUSDT",
-        #        "orderId":"1474764674982492160",
-        #        "orderLinkId":"1690541649154749",
-        #        "blockTradeId":"",
-        #        "side":"Buy",
-        #        "positionIdx":0,
-        #        "orderStatus":"Cancelled",
-        #        "cancelType":"UNKNOWN",
-        #        "rejectReason":"EC_NoError",
-        #        "timeInForce":"GTC",
-        #        "isLeverage":"0",
-        #        "price":"0",
-        #        "qty":"5.00000",
-        #        "avgPrice":"0",
-        #        "leavesQty":"0.00000",
-        #        "leavesValue":"5.0000000",
-        #        "cumExecQty":"0.00000",
-        #        "cumExecValue":"0.0000000",
-        #        "cumExecFee":"",
-        #        "orderType":"Market",
-        #        "stopOrderType":"",
-        #        "orderIv":"",
-        #        "triggerPrice":"0.000",
-        #        "takeProfit":"",
-        #        "stopLoss":"",
-        #        "triggerBy":"",
-        #        "tpTriggerBy":"",
-        #        "slTriggerBy":"",
-        #        "triggerDirection":0,
-        #        "placeType":"",
-        #        "lastPriceOnCreated":"0.000",
-        #        "closeOnTrigger":false,
-        #        "reduceOnly":false,
-        #        "smpGroup":0,
-        #        "smpType":"None",
-        #        "smpOrderId":"",
-        #        "createdTime":"1690541649160",
-        #        "updatedTime":"1690541649168"
-        #     }
-        #
-        id = self.safe_string_2(order, 'i', 'orderId')
-        marketId = self.safe_string_2(order, 's', 'symbol')
-        symbol = self.safe_symbol(marketId, market, None, 'spot')
-        timestamp = self.safe_integer_2(order, 'O', 'createdTime')
-        price = self.safe_string_2(order, 'p', 'price')
-        if price == '0':
-            price = None  # market orders
-        filled = self.safe_string_2(order, 'z', 'cumExecQty')
-        status = self.parse_order_status(self.safe_string_2(order, 'X', 'orderStatus'))
-        side = self.safe_string_lower_2(order, 'S', 'side')
-        lastTradeTimestamp = self.safe_string_2(order, 'E', 'updatedTime')
-        timeInForce = self.safe_string_2(order, 'f', 'timeInForce')
-        amount = None
-        cost = self.safe_string_2(order, 'Z', 'cumExecValue')
-        type = self.safe_string_lower_2(order, 'o', 'orderType')
-        if (type is not None) and (type.find('market') >= 0):
-            type = 'market'
-        if type == 'market' and side == 'buy':
-            amount = filled
-        else:
-            amount = self.safe_string_2(order, 'orderQty', 'qty')
-        fee = None
-        feeCost = self.safe_string_2(order, 'n', 'cumExecFee')
-        if feeCost is not None and feeCost != '0':
-            feeCurrencyId = self.safe_string(order, 'N')
-            feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
-            fee = {
-                'cost': feeCost,
-                'currency': feeCurrencyCode,
-            }
-        triggerPrice = self.omit_zero(self.safe_string(order, 'triggerPrice'))
-        return self.safe_order({
-            'info': order,
-            'id': id,
-            'clientOrderId': self.safe_string_2(order, 'c', 'orderLinkId'),
-            'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
-            'lastTradeTimestamp': lastTradeTimestamp,
-            'symbol': symbol,
-            'type': type,
-            'timeInForce': timeInForce,
-            'postOnly': None,
-            'side': side,
-            'price': price,
-            'stopPrice': triggerPrice,
-            'triggerPrice': triggerPrice,
-            'takeProfitPrice': self.safe_string(order, 'takeProfit'),
-            'stopLossPrice': self.safe_string(order, 'stopLoss'),
-            'reduceOnly': self.safe_value(order, 'reduceOnly'),
-            'amount': amount,
-            'cost': cost,
-            'average': self.safe_string(order, 'avgPrice'),
-            'filled': filled,
-            'remaining': None,
-            'status': status,
-            'fee': fee,
-        }, market)
-
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders