ccxt 3.1.21__py2.py3-none-any.whl → 3.1.24__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '3.1.21'
+__version__ = '3.1.24'
 
 # ----------------------------------------------------------------------------
 

ccxt/abstract/bitstamp.py

@@ -4,16 +4,22 @@ from ccxt.base.types import Entry
 class ImplicitAPI:
     public_get_ohlc_pair = publicGetOhlcPair = Entry('ohlc/{pair}/', 'public', 'GET', {'cost': 1})
     public_get_order_book_pair = publicGetOrderBookPair = Entry('order_book/{pair}/', 'public', 'GET', {'cost': 1})
+    public_get_ticker = publicGetTicker = Entry('ticker/', 'public', 'GET', {'cost': 1})
     public_get_ticker_hour_pair = publicGetTickerHourPair = Entry('ticker_hour/{pair}/', 'public', 'GET', {'cost': 1})
     public_get_ticker_pair = publicGetTickerPair = Entry('ticker/{pair}/', 'public', 'GET', {'cost': 1})
     public_get_transactions_pair = publicGetTransactionsPair = Entry('transactions/{pair}/', 'public', 'GET', {'cost': 1})
     public_get_trading_pairs_info = publicGetTradingPairsInfo = Entry('trading-pairs-info/', 'public', 'GET', {'cost': 1})
+    public_get_currencies = publicGetCurrencies = Entry('currencies/', 'public', 'GET', {'cost': 1})
+    public_get_eur_usd = publicGetEurUsd = Entry('eur_usd/', 'public', 'GET', {'cost': 1})
+    private_post_account_balances = privatePostAccountBalances = Entry('account_balances/', 'private', 'POST', {'cost': 1})
+    private_post_account_balances_currency = privatePostAccountBalancesCurrency = Entry('account_balances/{currency}/', 'private', 'POST', {'cost': 1})
     private_post_balance = privatePostBalance = Entry('balance/', 'private', 'POST', {'cost': 1})
     private_post_balance_pair = privatePostBalancePair = Entry('balance/{pair}/', 'private', 'POST', {'cost': 1})
     private_post_bch_withdrawal = privatePostBchWithdrawal = Entry('bch_withdrawal/', 'private', 'POST', {'cost': 1})
     private_post_bch_address = privatePostBchAddress = Entry('bch_address/', 'private', 'POST', {'cost': 1})
     private_post_user_transactions = privatePostUserTransactions = Entry('user_transactions/', 'private', 'POST', {'cost': 1})
     private_post_user_transactions_pair = privatePostUserTransactionsPair = Entry('user_transactions/{pair}/', 'private', 'POST', {'cost': 1})
+    private_post_crypto_transactions = privatePostCryptoTransactions = Entry('crypto-transactions/', 'private', 'POST', {'cost': 1})
     private_post_open_orders_all = privatePostOpenOrdersAll = Entry('open_orders/all/', 'private', 'POST', {'cost': 1})
     private_post_open_orders_pair = privatePostOpenOrdersPair = Entry('open_orders/{pair}/', 'private', 'POST', {'cost': 1})
     private_post_order_status = privatePostOrderStatus = Entry('order_status/', 'private', 'POST', {'cost': 1})
@@ -28,6 +34,10 @@ class ImplicitAPI:
     private_post_sell_instant_pair = privatePostSellInstantPair = Entry('sell/instant/{pair}/', 'private', 'POST', {'cost': 1})
     private_post_transfer_to_main = privatePostTransferToMain = Entry('transfer-to-main/', 'private', 'POST', {'cost': 1})
     private_post_transfer_from_main = privatePostTransferFromMain = Entry('transfer-from-main/', 'private', 'POST', {'cost': 1})
+    private_post_my_trading_pairs = privatePostMyTradingPairs = Entry('my_trading_pairs/', 'private', 'POST', {'cost': 1})
+    private_post_fees_trading = privatePostFeesTrading = Entry('fees/trading/', 'private', 'POST', {'cost': 1})
+    private_post_fees_withdrawal = privatePostFeesWithdrawal = Entry('fees/withdrawal/', 'private', 'POST', {'cost': 1})
+    private_post_fees_withdrawal_currency = privatePostFeesWithdrawalCurrency = Entry('fees/withdrawal/{currency}/', 'private', 'POST', {'cost': 1})
     private_post_withdrawal_requests = privatePostWithdrawalRequests = Entry('withdrawal-requests/', 'private', 'POST', {'cost': 1})
     private_post_withdrawal_open = privatePostWithdrawalOpen = Entry('withdrawal/open/', 'private', 'POST', {'cost': 1})
     private_post_withdrawal_status = privatePostWithdrawalStatus = Entry('withdrawal/status/', 'private', 'POST', {'cost': 1})

ccxt/abstract/bybit.py

@@ -244,6 +244,7 @@ class ImplicitAPI:
     private_get_v5_asset_transfer_query_account_coins_balance = privateGetV5AssetTransferQueryAccountCoinsBalance = Entry('v5/asset/transfer/query-account-coins-balance', 'private', 'GET', {'cost': 2.5})
     private_get_v5_user_query_sub_members = privateGetV5UserQuerySubMembers = Entry('v5/user/query-sub-members', 'private', 'GET', {'cost': 10})
     private_get_v5_user_query_api = privateGetV5UserQueryApi = Entry('v5/user/query-api', 'private', 'GET', {'cost': 10})
+    private_get_v5_customer_info = privateGetV5CustomerInfo = Entry('v5/customer/info', 'private', 'GET', {'cost': 10})
     private_get_v5_spot_cross_margin_trade_loan_info = privateGetV5SpotCrossMarginTradeLoanInfo = Entry('v5/spot-cross-margin-trade/loan-info', 'private', 'GET', {'cost': 1})
     private_get_v5_spot_cross_margin_trade_account = privateGetV5SpotCrossMarginTradeAccount = Entry('v5/spot-cross-margin-trade/account', 'private', 'GET', {'cost': 1})
     private_get_v5_spot_cross_margin_trade_orders = privateGetV5SpotCrossMarginTradeOrders = Entry('v5/spot-cross-margin-trade/orders', 'private', 'GET', {'cost': 1})

ccxt/abstract/currencycom.py

@@ -55,6 +55,7 @@ class ImplicitAPI:
     private_get_v2_tradingpositionshistory = privateGetV2TradingPositionsHistory = Entry('v2/tradingPositionsHistory', 'private', 'GET', {'cost': 1})
     private_get_v2_transactions = privateGetV2Transactions = Entry('v2/transactions', 'private', 'GET', {'cost': 1})
     private_get_v2_withdrawals = privateGetV2Withdrawals = Entry('v2/withdrawals', 'private', 'GET', {'cost': 1})
+    private_get_v2_fetchorder = privateGetV2FetchOrder = Entry('v2/fetchOrder', 'private', 'GET', {'cost': 1})
     private_post_v1_order = privatePostV1Order = Entry('v1/order', 'private', 'POST', {'cost': 1})
     private_post_v1_updatetradingposition = privatePostV1UpdateTradingPosition = Entry('v1/updateTradingPosition', 'private', 'POST', {'cost': 1})
     private_post_v1_updatetradingorder = privatePostV1UpdateTradingOrder = Entry('v1/updateTradingOrder', 'private', 'POST', {'cost': 1})

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.1.21'
+__version__ = '3.1.24'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.1.21'
+__version__ = '3.1.24'
 
 # -----------------------------------------------------------------------------
 
@@ -1250,21 +1250,10 @@ class Exchange(BaseExchange):
         })
 
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None, params={}):
-        if not self.has['fetchTrades']:
-            raise NotSupported(self.id + ' fetchOHLCV() is not supported yet')
-        trades = await self.fetchTrades(symbol, since, limit, params)
-        ohlcvc = self.build_ohlcvc(trades, timeframe, since, limit)
-        result = []
-        for i in range(0, len(ohlcvc)):
-            result.append([
-                self.safe_integer(ohlcvc[i], 0),
-                self.safe_number(ohlcvc[i], 1),
-                self.safe_number(ohlcvc[i], 2),
-                self.safe_number(ohlcvc[i], 3),
-                self.safe_number(ohlcvc[i], 4),
-                self.safe_number(ohlcvc[i], 5),
-            ])
-        return result
+        message = ''
+        if self.has['fetchTrades']:
+            message = '. If you want to build OHLCV candles from trade executions data, visit https://github.com/ccxt/ccxt/tree/master/examples/ and see "build-ohlcv-bars" file'
+        raise NotSupported(self.id + ' fetchOHLCV() is not supported yet' + message)
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None, params={}):
         raise NotSupported(self.id + ' watchOHLCV() is not supported yet')
@@ -1731,13 +1720,6 @@ class Exchange(BaseExchange):
                 ohlcvs[candle][i_count] = self.sum(ohlcvs[candle][i_count], 1)
         return ohlcvs
 
-    async def fetch_ohlcvc(self, symbol, timeframe='1m', since: Optional[Any] = None, limit: Optional[int] = None, params={}):
-        if not self.has['fetchTrades']:
-            raise NotSupported(self.id + ' fetchOHLCV() is not supported yet')
-        await self.load_markets()
-        trades = await self.fetchTrades(symbol, since, limit, params)
-        return self.build_ohlcvc(trades, timeframe, since, limit)
-
     def parse_trading_view_ohlcv(self, ohlcvs, market=None, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None):
         result = self.convert_trading_view_to_ohlcv(ohlcvs)
         return self.parse_ohlcvs(result, market, timeframe, since, limit)

ccxt/async_support/bitget.py

@@ -2361,19 +2361,22 @@ class bitget(Exchange, ImplicitAPI):
         #
         # spot
         #     {
-        #       accountId: '6394957606',
-        #       symbol: 'BTCUSDT_SPBL',
-        #       orderId: '881623995442958336',
-        #       clientOrderId: '135335e9-b054-4e43-b00a-499f11d3a5cc',
-        #       price: '39000.000000000000',
-        #       quantity: '0.000700000000',
-        #       orderType: 'limit',
-        #       side: 'buy',
-        #       status: 'new',
-        #       fillPrice: '0.000000000000',
-        #       fillQuantity: '0.000000000000',
-        #       fillTotalAmount: '0.000000000000',
-        #       cTime: '1645921460972'
+        #         "accountId": "222222222",
+        #         "symbol": "TRXUSDT_SPBL",
+        #         "orderId": "1041901704004947968",
+        #         "clientOrderId": "c5e8a5e1-a07f-4202-8061-b88bd598b264",
+        #         "price": "0",
+        #         "quantity": "10.0000000000000000",
+        #         "orderType": "market",
+        #         "side": "buy",
+        #         "status": "full_fill",
+        #         "fillPrice": "0.0699782527055350",
+        #         "fillQuantity": "142.9015000000000000",
+        #         "fillTotalAmount": "9.9999972790000000",
+        #         "enterPointSource": "API",
+        #         "feeDetail": "{\"BGB\":{\"deduction\":true,\"feeCoinCode\":\"BGB\",\"totalDeductionFee\":-0.017118519726,\"totalFee\":-0.017118519726}}",
+        #         "orderSource": "market",
+        #         "cTime": "1684134644509"
         #     }
         #
         # swap
@@ -2435,6 +2438,22 @@ class bitget(Exchange, ImplicitAPI):
             side = 'sell'
         clientOrderId = self.safe_string_2(order, 'clientOrderId', 'clientOid')
         fee = None
+        feeCostString = self.safe_string(order, 'fee')
+        if feeCostString is not None:
+            # swap
+            fee = {
+                'cost': feeCostString,
+                'currency': market['settle'],
+            }
+        feeDetail = self.safe_value(order, 'feeDetail')
+        if feeDetail is not None:
+            parsedFeeDetail = json.loads(feeDetail)
+            feeValues = list(parsedFeeDetail.values())
+            first = self.safe_value(feeValues, 0)
+            fee = {
+                'cost': self.safe_string(first, 'totalFee'),
+                'currency': self.safe_currency_code(self.safe_string(first, 'feeCoinCode')),
+            }
         rawStatus = self.safe_string_2(order, 'status', 'state')
         status = self.parse_order_status(rawStatus)
         lastTradeTimestamp = self.safe_integer(order, 'uTime')
@@ -3308,7 +3327,10 @@ class bitget(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data')
-        return self.safe_value(data, 'orderList', [])
+        if data is not None:
+            return self.safe_value_2(data, 'orderList', 'data', [])
+        parsedData = json.loads(response)
+        return self.safe_value(parsedData, 'data', [])
 
     async def fetch_ledger(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """

ccxt/async_support/bitstamp.py

@@ -127,20 +127,26 @@ class bitstamp(Exchange, ImplicitAPI):
                     'get': {
                         'ohlc/{pair}/': 1,
                         'order_book/{pair}/': 1,
+                        'ticker/': 1,
                         'ticker_hour/{pair}/': 1,
                         'ticker/{pair}/': 1,
                         'transactions/{pair}/': 1,
                         'trading-pairs-info/': 1,
+                        'currencies/': 1,
+                        'eur_usd/': 1,
                     },
                 },
                 'private': {
                     'post': {
+                        'account_balances/': 1,
+                        'account_balances/{currency}/': 1,
                         'balance/': 1,
                         'balance/{pair}/': 1,
                         'bch_withdrawal/': 1,
                         'bch_address/': 1,
                         'user_transactions/': 1,
                         'user_transactions/{pair}/': 1,
+                        'crypto-transactions/': 1,
                         'open_orders/all/': 1,
                         'open_orders/{pair}/': 1,
                         'order_status/': 1,
@@ -155,6 +161,10 @@ class bitstamp(Exchange, ImplicitAPI):
                         'sell/instant/{pair}/': 1,
                         'transfer-to-main/': 1,
                         'transfer-from-main/': 1,
+                        'my_trading_pairs/': 1,
+                        'fees/trading/': 1,
+                        'fees/withdrawal/': 1,
+                        'fees/withdrawal/{currency}/': 1,
                         'withdrawal-requests/': 1,
                         'withdrawal/open/': 1,
                         'withdrawal/status/': 1,

ccxt/async_support/bybit.py

@@ -411,6 +411,7 @@ class bybit(Exchange, ImplicitAPI):
                         # user
                         'v5/user/query-sub-members': 10,
                         'v5/user/query-api': 10,
+                        'v5/customer/info': 10,
                         'v5/spot-cross-margin-trade/loan-info': 1,  # 50/s => cost = 50 / 50 = 1
                         'v5/spot-cross-margin-trade/account': 1,  # 50/s => cost = 50 / 50 = 1
                         'v5/spot-cross-margin-trade/orders': 1,  # 50/s => cost = 50 / 50 = 1

ccxt/async_support/currencycom.py

@@ -88,7 +88,7 @@ class currencycom(Exchange, ImplicitAPI):
                 'fetchOHLCV': True,
                 'fetchOpenOrder': None,
                 'fetchOpenOrders': True,
-                'fetchOrder': None,
+                'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrderBooks': None,
                 'fetchOrders': None,
@@ -214,6 +214,7 @@ class currencycom(Exchange, ImplicitAPI):
                         'v2/tradingPositionsHistory': 1,
                         'v2/transactions': 1,
                         'v2/withdrawals': 1,
+                        'v2/fetchOrder': 1,
                     },
                     'post': {
                         'v1/order': 1,
@@ -269,6 +270,8 @@ class currencycom(Exchange, ImplicitAPI):
                     'Only leverage symbol allowed here:': BadSymbol,  # when you fetchLeverage for non-leverage symbols, like 'BTC/USDT' instead of 'BTC/USDT_LEVERAGE': {"code":"-1128","msg":"Only leverage symbol allowed here: BTC/USDT"}
                     'market data service is not available': ExchangeNotAvailable,  # {"code":"-1021","msg":"market data service is not available"}
                     'your time is ahead of server': InvalidNonce,  # {"code":"-1021","msg":"your time is ahead of server"}
+                    'Can not find account': BadRequest,  # -1128
+                    'You mentioned an invalid value for the price parameter': BadRequest,  # -1030
                 },
                 'exact': {
                     '-1000': ExchangeNotAvailable,  # {"code":-1000,"msg":"An unknown error occured while processing the request."}
@@ -279,7 +282,7 @@ class currencycom(Exchange, ImplicitAPI):
                     '-1100': InvalidOrder,  # createOrder(symbol, 1, asdf) -> 'Illegal characters found in parameter 'price'
                     '-1104': ExchangeError,  # Not all sent parameters were read, read 8 parameters but was sent 9
                     '-1025': AuthenticationError,  # {"code":-1025,"msg":"Invalid API-key, IP, or permissions for action"}
-                    '-1128': BadRequest,  # {"code":-1128,"msg":"Combination of optional parameters invalid."} | {"code":"-1128","msg":"Combination of parameters invalid"} | {"code":"-1128","msg":"Invalid limit price"}
+                    '-1128': BadRequest,  # {"code":-1128,"msg":"Combination of optional parameters invalid."} | {"code":"-1128","msg":"Combination of parameters invalid"} | {"code":"-1128","msg":"Invalid limit price"} | {"code":"-1128","msg":"Can not find account: null"}
                     '-2010': ExchangeError,  # generic error code for createOrder -> 'Account has insufficient balance for requested action.', {"code":-2010,"msg":"Rest API trading is not enabled."}, etc...
                     '-2011': OrderNotFound,  # cancelOrder(1, 'BTC/USDT') -> 'UNKNOWN_ORDER'
                     '-2013': OrderNotFound,  # fetchOrder(1, 'BTC/USDT') -> 'Order does not exist'
@@ -607,7 +610,7 @@ class currencycom(Exchange, ImplicitAPI):
         result = []
         for i in range(0, len(accounts)):
             account = accounts[i]
-            accountId = self.safe_integer(account, 'accountId')
+            accountId = self.safe_string(account, 'accountId')  # must be string, because the numeric value is far too big for integer, and causes bugs
             currencyId = self.safe_string(account, 'asset')
             currencyCode = self.safe_currency_code(currencyId)
             result.append({
@@ -1077,28 +1080,14 @@ class currencycom(Exchange, ImplicitAPI):
         #         "orderId": "00000000-0000-0000-0000-000006eacaa0",
         #         "transactTime": "1645281669295",
         #         "price": "30000.00000000",
-        #         "origQty": "0.0002",
-        #         "executedQty": "0.0",  # positive for BUY, negative for SELL
-        #         "status": "NEW",
+        #         "origQty": "0.0002",     # might not be present for "market" order
+        #         "executedQty": "0.0",    # positive for BUY, negative for SELL. This property might not be present in Leverage markets
+        #         "margin": 0.1,           # present in leverage markets
+        #         "status": "NEW",         # NEW, FILLED, ...
         #         "timeInForce": "GTC",
-        #         "type": "LIMIT",
+        #         "type": "LIMIT",         # LIMIT, MARKET
         #         "side": "BUY",
-        #     }
-        #
-        # market
-        #
-        #     {
-        #         "symbol": "DOGE/USD",
-        #         "orderId": "00000000-0000-0000-0000-000006eab2ad",
-        #         "transactTime": "1645283022252",
-        #         "price": "0.14066000",
-        #         "origQty": "40",
-        #         "executedQty": "40.0",  # positive for BUY, negative for SELL
-        #         "status": "FILLED",
-        #         "timeInForce": "FOK",
-        #         "type": "MARKET",
-        #         "side": "SELL",
-        #         "fills": [
+        #         "fills": [              # self field might not be present if there were no fills
         #             {
         #                 "price": "0.14094",
         #                 "qty": "40.0",
@@ -1108,6 +1097,32 @@ class currencycom(Exchange, ImplicitAPI):
         #         ],
         #     }
         #
+        # fetchOrder(fetchOpenOrders is an array same structure, with some extra fields)
+        #
+        #    {
+        #        "symbol": "BTC/USD_LEVERAGE",
+        #        "accountId": "123456789012345678",
+        #        "orderId": "00a01234-0123-54c4-0000-123451234567",
+        #        "price": "25779.35",
+        #        "status": "MODIFIED",
+        #        "type": "LIMIT",
+        #        "timeInForceType": "GTC",
+        #        "side": "BUY",
+        #        "guaranteedStopLoss": False,
+        #        "trailingStopLoss": False,
+        #        "margin": "0.05",
+        #        "takeProfit": "27020.00",
+        #        "stopLoss": "24500.35",
+        #        "fills": [],  # might not be present
+        #        "timestamp": "1685958369623",  # "time" in "fetchOpenOrders"
+        #        "expireTime": "1686167960000",  # "expireTimestamp" in "fetchOpenOrders"
+        #        "quantity": "0.00040",  # "origQty" in "fetchOpenOrders"
+        #        "executedQty": "0.0",  # present in "fetchOpenOrders"
+        #        "updateTime": "1685958369542",  # present in "fetchOpenOrders"
+        #        "leverage": True,  # present in "fetchOpenOrders"
+        #        "working": True  # present in "fetchOpenOrders"
+        #    }
+        #
         # cancelOrder
         #
         #     {
@@ -1122,36 +1137,18 @@ class currencycom(Exchange, ImplicitAPI):
         #         "side": "BUY",
         #     }
         #
-        # fetchOpenOrders
-        #
-        #   {
-        #       "symbol": "DOGE/USD",
-        #       "orderId": "00000000-0000-0003-0000-000004bcc27a",
-        #       "price": "0.13",
-        #       "origQty": "39.0",
-        #       "executedQty": "0.0",
-        #       "status": "NEW",
-        #       "timeInForce": "GTC",
-        #       "type": "LIMIT",
-        #       "side": "BUY",
-        #       "time": "1645284216240",
-        #       "updateTime": "1645284216240",
-        #       "leverage": False,  # whether it's swap or not
-        #       "working": True,
-        #   }
-        #
         marketId = self.safe_string(order, 'symbol')
         symbol = self.safe_symbol(marketId, market, '/')
         id = self.safe_string(order, 'orderId')
         price = self.safe_string(order, 'price')
-        amount = self.safe_string(order, 'origQty')
+        amount = self.safe_string_2(order, 'origQty', 'quantity')
         filledRaw = self.safe_string(order, 'executedQty')
         filled = Precise.string_abs(filledRaw)
         status = self.parse_order_status(self.safe_string(order, 'status'))
-        timeInForce = self.parse_order_time_in_force(self.safe_string(order, 'timeInForce'))
+        timeInForce = self.parse_order_time_in_force(self.safe_string_2(order, 'timeInForce', 'timeInForceType'))
         type = self.parse_order_type(self.safe_string(order, 'type'))
         side = self.parse_order_side(self.safe_string(order, 'side'))
-        timestamp = self.safe_integer_2(order, 'time', 'transactTime')
+        timestamp = self.safe_integer_n(order, ['time', 'transactTime', 'timestamp'])
         fills = self.safe_value(order, 'fills')
         return self.safe_order({
             'info': order,
@@ -1179,6 +1176,8 @@ class currencycom(Exchange, ImplicitAPI):
     def parse_order_status(self, status):
         statuses = {
             'NEW': 'open',
+            'CREATED': 'open',
+            'MODIFIED': 'open',
             'PARTIALLY_FILLED': 'open',
             'FILLED': 'closed',
             'CANCELED': 'canceled',
@@ -1304,6 +1303,46 @@ class currencycom(Exchange, ImplicitAPI):
         #
         return self.parse_order(response, market)
 
+    async def fetch_order(self, id: str, symbol: Optional[str] = None, params={}):
+        """
+        fetches information on an order made by the user
+        see https://apitradedoc.currency.com/swagger-ui.html#/rest-api/getOrderUsingGET
+        :param str symbol: unified symbol of the market the order was made in
+        :param dict params: extra parameters specific to the currencycom api endpoint
+        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.check_required_symbol('fetchOrder', symbol)
+        await self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'orderId': id,
+            'symbol': market['id'],
+        }
+        response = await self.privateGetV2FetchOrder(self.extend(request, params))
+        #
+        #    {
+        #        "accountId": "109698017413125316",
+        #        "orderId": "2810f1c5-0079-54c4-0000-000080421601",
+        #        "quantity": "20.0",
+        #        "price": "0.06",
+        #        "timestamp": "1661157503788",
+        #        "status": "CREATED",
+        #        "type": "LIMIT",
+        #        "timeInForceType": "GTC",
+        #        "side": "BUY",
+        #        "margin": "0.1",
+        #        "fills": [ # might not be present
+        #             {
+        #                 "price": "0.14094",
+        #                 "qty": "40.0",
+        #                 "commission": "0",
+        #                 "commissionAsset": "dUSD"
+        #             }
+        #        ]
+        #    }
+        #
+        return self.parse_order(response)
+
     async def fetch_open_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all unfilled currently open orders

ccxt/async_support/poloniex.py

@@ -198,6 +198,7 @@ class poloniex(Exchange, ImplicitAPI):
                 'BDG': 'Badgercoin',
                 'BTM': 'Bitmark',
                 'CON': 'Coino',
+                'ETHTRON': 'ETH',
                 'GOLD': 'GoldEagles',
                 'GPUC': 'GPU',
                 'HOT': 'Hotcoin',
@@ -210,6 +211,7 @@ class poloniex(Exchange, ImplicitAPI):
                 'STR': 'XLM',
                 'SOC': 'SOCC',
                 'TRADE': 'Unitrade',
+                'TRXETH': 'TRX',
                 'XAP': 'API Coin',
                 # self is not documented in the API docs for Poloniex
                 # https://github.com/ccxt/ccxt/issues/7084
@@ -220,6 +222,7 @@ class poloniex(Exchange, ImplicitAPI):
                 # with a USDTTRON or a USDTETH currency id, respectfully
                 # therefore we have map them back to the original code USDT
                 # otherwise the returned withdrawals are filtered out
+                'USDTBSC': 'USDT',
                 'USDTTRON': 'USDT',
                 'USDTETH': 'USDT',
                 'UST': 'USTC',
@@ -234,6 +237,7 @@ class poloniex(Exchange, ImplicitAPI):
                     'BSC': 'BEP20',
                     'ETH': 'ERC20',
                     'TRON': 'TRC20',
+                    'TRX': 'TRC20',
                 },
                 'limits': {
                     'cost': {
@@ -643,7 +647,7 @@ class poloniex(Exchange, ImplicitAPI):
         :param dict params: extra parameters specific to the poloniex api endpoint
         :returns dict: an associative dictionary of currencies
         """
-        response = await self.publicGetCurrencies(params)
+        response = await self.publicGetCurrencies(self.extend(params, {'includeMultiChainCurrencies': True}))
         #
         #     [
         #         {
@@ -659,6 +663,8 @@ class poloniex(Exchange, ImplicitAPI):
         #                 "delisted": False,
         #                 "tradingState": "NORMAL",
         #                 "walletState": "DISABLED",
+        #                 "walletDepositState": 'DISABLED',
+        #                 "walletWithdrawalState": 'DISABLED',
         #                 "parentChain": null,
         #                 "isMultiChain": False,
         #                 "isChildChain": False,
@@ -674,36 +680,91 @@ class poloniex(Exchange, ImplicitAPI):
             id = self.safe_value(ids, 0)
             currency = self.safe_value(item, id)
             code = self.safe_currency_code(id)
+            name = self.safe_string(currency, 'name')
+            networkId = self.safe_string(currency, 'blockchain')
+            networkCode = self.network_id_to_code(networkId, code)
             delisted = self.safe_value(currency, 'delisted')
-            walletState = self.safe_string(currency, 'walletState')
-            enabled = walletState == 'ENABLED'
-            listed = not delisted
-            active = listed and enabled
+            walletEnabled = self.safe_string(currency, 'walletState') == 'ENABLED'
+            depositEnabled = self.safe_string(currency, 'walletDepositState') == 'ENABLED'
+            withdrawEnabled = self.safe_string(currency, 'walletWithdrawalState') == 'ENABLED'
+            active = not delisted and walletEnabled and depositEnabled and withdrawEnabled
             numericId = self.safe_integer(currency, 'id')
-            fee = self.safe_number(currency, 'withdrawalFee')
-            result[code] = {
-                'id': id,
-                'numericId': numericId,
-                'code': code,
+            feeString = self.safe_string(currency, 'withdrawalFee')
+            parentChain = self.safe_value(currency, 'parentChain')
+            noParentChain = parentChain is None
+            if self.safe_value(result, code) is None:
+                result[code] = {
+                    'id': id,
+                    'code': code,
+                    'info': None,
+                    'name': name,
+                    'active': active,
+                    'deposit': depositEnabled,
+                    'withdraw': withdrawEnabled,
+                    'fee': self.parse_number(feeString),
+                    'precision': None,
+                    'limits': {
+                        'amount': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                }
+            minFeeString = self.safe_string(result[code], 'fee')
+            if feeString is not None:
+                minFeeString = feeString if (minFeeString is None) else Precise.string_min(feeString, minFeeString)
+            depositAvailable = self.safe_value(result[code], 'deposit')
+            depositAvailable = depositEnabled if (depositEnabled) else depositAvailable
+            withdrawAvailable = self.safe_value(result[code], 'withdraw')
+            withdrawAvailable = withdrawEnabled if (withdrawEnabled) else withdrawAvailable
+            networks = self.safe_value(result[code], 'networks', {})
+            networks[networkCode] = {
                 'info': currency,
-                'name': currency['name'],
+                'id': networkId,
+                'network': networkCode,
+                'currencyId': id,
+                'numericId': numericId,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
                 'active': active,
-                'deposit': None,
-                'withdraw': None,
-                'fee': fee,
+                'fee': self.parse_number(feeString),
                 'precision': None,
-                'networks': {},
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': fee,
+                        'min': None,
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': None,
                         'max': None,
                     },
                 },
             }
+            result[code]['networks'] = networks
+            info = self.safe_value(result[code], 'info', [])
+            rawInfo = {}
+            rawInfo[id] = currency
+            info.append(rawInfo)
+            result[code]['info'] = info
+            if noParentChain:
+                result[code]['id'] = id
+                result[code]['name'] = name
+            result[code]['active'] = depositAvailable and withdrawAvailable
+            result[code]['deposit'] = depositAvailable
+            result[code]['withdraw'] = withdrawAvailable
+            result[code]['fee'] = self.parse_number(minFeeString)
         return result
 
     async def fetch_ticker(self, symbol: str, params={}):

ccxt/async_support/xt.py

@@ -4342,7 +4342,11 @@ class xt(Exchange, ImplicitAPI):
             timestamp = self.number_to_string(self.nonce())
             body = query
             if (payload == '/v4/order') or (payload == '/future/trade/v1/order/create') or (payload == '/future/trade/v1/entrust/create-plan') or (payload == '/future/trade/v1/entrust/create-profit') or (payload == '/future/trade/v1/order/create-batch'):
-                body['clientMedia'] = 'CCXT'
+                id = 'CCXT'
+                if payload.find('future') > -1:
+                    body['clientMedia'] = id
+                else:
+                    body['media'] = id
             isUndefinedBody = ((method == 'GET') or (path == 'order/{orderId}'))
             body = None if isUndefinedBody else self.json(body)
             payloadString = None