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

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.1.21'
+__version__ = '3.1.24'
 
 # -----------------------------------------------------------------------------
 
@@ -2406,21 +2406,10 @@ class Exchange(object):
         })
 
     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 = 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)
 
     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')
@@ -2887,13 +2876,6 @@ class Exchange(object):
                 ohlcvs[candle][i_count] = self.sum(ohlcvs[candle][i_count], 1)
         return ohlcvs
 
-    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')
-        self.load_markets()
-        trades = 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/bitget.py

@@ -2360,19 +2360,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
@@ -2434,6 +2437,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')
@@ -3307,7 +3326,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', [])
 
     def fetch_ledger(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """

ccxt/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/bybit.py

@@ -410,6 +410,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/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)
 
+    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)
+        self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'orderId': id,
+            'symbol': market['id'],
+        }
+        response = 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)
+
     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/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 = self.publicGetCurrencies(params)
+        response = 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
 
     def fetch_ticker(self, symbol: str, params={}):

ccxt/pro/__init__.py

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

ccxt/xt.py

@@ -4341,7 +4341,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

{ccxt-3.1.21.dist-info → ccxt-3.1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 3.1.21
+Version: 3.1.24
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 130+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -264,13 +264,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@3.1.21/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@3.1.21/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@3.1.24/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@3.1.24/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@3.1.21/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@3.1.24/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: