ccxt 4.0.112__py2.py3-none-any.whl → 4.1.2__py2.py3-none-any.whl

ccxt/bybit.py

@@ -3805,6 +3805,16 @@ class bybit(Exchange, ImplicitAPI):
         :param float amount: how much of currency you want to trade in units of base currency
         :param float price: the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
         :param dict [params]: extra parameters specific to the bybit api endpoint
+        :param float [params.triggerPrice]: The price that a trigger order is triggered at
+        :param float [params.stopLossPrice]: The price that a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: The price that a take profit order is triggered at
+        :param dict [params.takeProfit]: *takeProfit object in params* containing the triggerPrice that the attached take profit order will be triggered
+        :param float [params.takeProfit.triggerPrice]: take profit trigger price
+        :param dict [params.stopLoss]: *stopLoss object in params* containing the triggerPrice that the attached stop loss order will be triggered
+        :param float [params.stopLoss.triggerPrice]: stop loss trigger price
+        :param str [params.triggerBy]: 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for triggerPrice
+        :param str [params.slTriggerBy]: 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for stopLoss
+        :param str [params.tpTriggerby]: 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for takeProfit
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.check_required_symbol('editOrder', symbol)
@@ -3840,9 +3850,9 @@ class bybit(Exchange, ImplicitAPI):
             request['price'] = self.price_to_precision(symbol, price)
         if amount is not None:
             request['qty'] = self.amount_to_precision(symbol, amount)
-        triggerPrice = self.safe_value_2(params, 'triggerPrice', 'stopPrice')
-        stopLossTriggerPrice = self.safe_value(params, 'stopLossPrice')
-        takeProfitTriggerPrice = self.safe_value(params, 'takeProfitPrice')
+        triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
+        stopLossTriggerPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitTriggerPrice = self.safe_string(params, 'takeProfitPrice')
         stopLoss = self.safe_value(params, 'stopLoss')
         takeProfit = self.safe_value(params, 'takeProfit')
         isStopLossTriggerOrder = stopLossTriggerPrice is not None
@@ -3852,14 +3862,23 @@ class bybit(Exchange, ImplicitAPI):
         if isStopLossTriggerOrder or isTakeProfitTriggerOrder:
             triggerPrice = stopLossTriggerPrice if isStopLossTriggerOrder else takeProfitTriggerPrice
         if triggerPrice is not None:
-            request['triggerPrice'] = triggerPrice
+            triggerPriceRequest = triggerPrice if (triggerPrice == '0') else self.price_to_precision(symbol, triggerPrice)
+            request['triggerPrice'] = triggerPriceRequest
+            triggerBy = self.safe_string(params, 'triggerBy', 'LastPrice')
+            request['triggerBy'] = triggerBy
         if isStopLoss or isTakeProfit:
             if isStopLoss:
-                slTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
-                request['stopLoss'] = slTriggerPrice
+                slTriggerPrice = self.safe_string_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
+                stopLossRequest = slTriggerPrice if (slTriggerPrice == '0') else self.price_to_precision(symbol, slTriggerPrice)
+                request['stopLoss'] = stopLossRequest
+                slTriggerBy = self.safe_string(params, 'slTriggerBy', 'LastPrice')
+                request['slTriggerBy'] = slTriggerBy
             if isTakeProfit:
-                tpTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
-                request['takeProfit'] = tpTriggerPrice
+                tpTriggerPrice = self.safe_string_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
+                takeProfitRequest = tpTriggerPrice if (tpTriggerPrice == '0') else self.price_to_precision(symbol, tpTriggerPrice)
+                request['takeProfit'] = takeProfitRequest
+                tpTriggerBy = self.safe_string(params, 'tpTriggerBy', 'LastPrice')
+                request['tpTriggerBy'] = tpTriggerBy
         clientOrderId = self.safe_string(params, 'clientOrderId')
         if clientOrderId is not None:
             request['orderLinkId'] = clientOrderId

ccxt/coinbasepro.py

@@ -125,6 +125,7 @@ class coinbasepro(Exchange, ImplicitAPI):
                 },
                 'private': {
                     'get': [
+                        'address-book',
                         'accounts',
                         'accounts/{id}',
                         'accounts/{id}/holds',

ccxt/kucoin.py

@@ -826,6 +826,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_time(self, params={}):
         """
         fetches the current integer timestamp in milliseconds from the exchange server
+        see https://docs.kucoin.com/#server-time
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :returns int: the current integer timestamp in milliseconds from the exchange server
         """
@@ -842,6 +843,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_status(self, params={}):
         """
         the latest known information on the availability of the exchange API
+        see https://docs.kucoin.com/#service-status
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :returns dict: a `status structure <https://github.com/ccxt/ccxt/wiki/Manual#exchange-status-structure>`
         """
@@ -868,6 +870,8 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_markets(self, params={}):
         """
         retrieves data on all markets for kucoin
+        see https://docs.kucoin.com/#get-symbols-list-deprecated
+        see https://docs.kucoin.com/#get-all-tickers
         :param dict [params]: extra parameters specific to the exchange api endpoint
         :returns dict[]: an array of objects representing market data
         """
@@ -1002,6 +1006,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_currencies(self, params={}):
         """
         fetches all available currencies on an exchange
+        see https://docs.kucoin.com/#get-currencies
         :param dict params: extra parameters specific to the kucoin api endpoint
         :returns dict: an associative dictionary of currencies
         """
@@ -1098,7 +1103,7 @@ class kucoin(Exchange, ImplicitAPI):
                 isDepositEnabled = False
             for j in range(0, chainsLength):
                 chain = chains[j]
-                chainId = self.safe_string(chain, 'chain')
+                chainId = self.safe_string(chain, 'chainId')
                 networkCode = self.network_id_to_code(chainId)
                 chainWithdrawEnabled = self.safe_value(chain, 'isWithdrawEnabled', False)
                 if isWithdrawEnabled is None:
@@ -1153,6 +1158,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_accounts(self, params={}):
         """
         fetch all the accounts associated with a profile
+        see https://docs.kucoin.com/#list-accounts
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :returns dict: a dictionary of `account structures <https://github.com/ccxt/ccxt/wiki/Manual#account-structure>` indexed by the account type
         """
@@ -1417,6 +1423,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_tickers(self, symbols: Optional[List[str]] = None, params={}):
         """
         fetches price tickers for multiple markets, statistical calculations with the information calculated over the past 24 hours each market
+        see https://docs.kucoin.com/#get-all-tickers
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :returns dict: a dictionary of `ticker structures <https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure>`
@@ -1467,6 +1474,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_ticker(self, symbol: str, params={}):
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        see https://docs.kucoin.com/#get-24hr-stats
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :returns dict: a `ticker structure <https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure>`
@@ -1526,6 +1534,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        see https://docs.kucoin.com/#get-klines
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -1597,6 +1606,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_deposit_address(self, code: str, params={}):
         """
         fetch the deposit address for a currency associated with self account
+        see https://docs.kucoin.com/#get-deposit-addresses-v2
         :param str code: unified currency code
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :param str [params.network]: the blockchain network name
@@ -1685,6 +1695,8 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        see https://docs.kucoin.com/#get-part-order-book-aggregated
+        see https://docs.kucoin.com/#get-full-order-book-aggregated
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the kucoin api endpoint
@@ -2092,6 +2104,10 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_closed_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetches information on multiple closed orders made by the user
+        see https://docs.kucoin.com/spot#list-orders
+        see https://docs.kucoin.com/spot#list-stop-orders
+        see https://docs.kucoin.com/spot-hf/#obtain-list-of-active-hf-orders
+        see https://docs.kucoin.com/spot-hf/#obtain-list-of-filled-hf-orders
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of  orde structures to retrieve
@@ -2109,6 +2125,10 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_open_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all unfilled currently open orders
+        see https://docs.kucoin.com/spot#list-orders
+        see https://docs.kucoin.com/spot#list-stop-orders
+        see https://docs.kucoin.com/spot-hf/#obtain-list-of-active-hf-orders
+        see https://docs.kucoin.com/spot-hf/#obtain-list-of-filled-hf-orders
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of  open orders structures to retrieve
@@ -2361,6 +2381,8 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_order_trades(self, id: str, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all the trades made from a single order
+        see https://docs.kucoin.com/#list-fills
+        see https://docs.kucoin.com/spot-hf/#transaction-details
         :param str id: order id
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
@@ -2470,6 +2492,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_trades(self, symbol: str, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         get the list of most recent trades for a particular symbol
+        see https://docs.kucoin.com/#get-trade-histories
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -2634,6 +2657,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_trading_fee(self, symbol: str, params={}):
         """
         fetch the trading fees for a market
+        see https://docs.kucoin.com/#actual-fee-rate-of-the-trading-pair
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the kucoin api endpoint
         :returns dict: a `fee structure <https://github.com/ccxt/ccxt/wiki/Manual#fee-structure>`
@@ -2671,6 +2695,7 @@ class kucoin(Exchange, ImplicitAPI):
     def withdraw(self, code: str, amount, address, tag=None, params={}):
         """
         make a withdrawal
+        see https://docs.kucoin.com/#apply-withdraw-2
         :param str code: unified currency code
         :param float amount: the amount to withdraw
         :param str address: the address to withdraw to
@@ -2829,6 +2854,8 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_deposits(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all deposits made to an account
+        see https://docs.kucoin.com/#get-deposit-list
+        see https://docs.kucoin.com/#get-v1-historical-deposits-list
         :param str code: unified currency code
         :param int [since]: the earliest time in ms to fetch deposits for
         :param int [limit]: the maximum number of deposits structures to retrieve
@@ -2896,6 +2923,8 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_withdrawals(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch all withdrawals made from an account
+        see https://docs.kucoin.com/#get-withdrawals-list
+        see https://docs.kucoin.com/#get-v1-historical-withdrawals-list
         :param str code: unified currency code
         :param int [since]: the earliest time in ms to fetch withdrawals for
         :param int [limit]: the maximum number of withdrawals structures to retrieve
@@ -3372,6 +3401,7 @@ class kucoin(Exchange, ImplicitAPI):
     def fetch_ledger(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         fetch the history of changes, actions done by the user or operations that altered balance of the user
+        see https://docs.kucoin.com/#get-account-ledgers
         :param str code: unified currency code, default is None
         :param int [since]: timestamp in ms of the earliest ledger entry, default is None
         :param int [limit]: max number of ledger entrys to return, default is None

ccxt/okx.py

@@ -2040,13 +2040,23 @@ class okx(Exchange, ImplicitAPI):
         defaultType = self.safe_string(options, 'type', defaultType)  # Candles or HistoryCandles
         type = self.safe_string(params, 'type', defaultType)
         params = self.omit(params, 'type')
-        method = 'publicGetMarket' + type
         isHistoryCandles = (type == 'HistoryCandles')
+        response = None
         if price == 'mark':
-            method = 'publicGetMarketHistoryMarkPriceCandles' if (isHistoryCandles) else 'publicGetMarketMarkPriceCandles'
+            if isHistoryCandles:
+                response = self.publicGetMarketHistoryMarkPriceCandles(self.extend(request, params))
+            else:
+                response = self.publicGetMarketMarkPriceCandles(self.extend(request, params))
         elif price == 'index':
-            method = 'publicGetMarketHistoryIndexCandles' if (isHistoryCandles) else 'publicGetMarketIndexCandles'
-        response = getattr(self, method)(self.extend(request, params))
+            if isHistoryCandles:
+                response = self.publicGetMarketHistoryIndexCandles(self.extend(request, params))
+            else:
+                response = self.publicGetMarketIndexCandles(self.extend(request, params))
+        else:
+            if isHistoryCandles:
+                response = self.publicGetMarketHistoryCandles(self.extend(request, params))
+            else:
+                response = self.publicGetMarketCandles(self.extend(request, params))
         #
         #     {
         #         "code": "0",
@@ -2239,15 +2249,14 @@ class okx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         marketType, query = self.handle_market_type_and_params('fetchBalance', None, params)
-        method = None
-        if marketType == 'funding':
-            method = 'privateGetAssetBalances'
-        else:
-            method = 'privateGetAccountBalance'
         request = {
             # 'ccy': 'BTC,ETH',  # comma-separated list of currency ids
         }
-        response = getattr(self, method)(self.extend(request, query))
+        response = None
+        if marketType == 'funding':
+            response = self.privateGetAssetBalances(self.extend(request, query))
+        else:
+            response = self.privateGetAccountBalance(self.extend(request, query))
         #
         #     {
         #         "code": "0",

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.0.112'
+__version__ = '4.1.2'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/coinbasepro.py

@@ -28,9 +28,11 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                 'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
+                'watchMyTradesForSymbols': True,
                 'watchBalance': False,
                 'watchStatus': False,  # for now
                 'watchOrders': True,
+                'watchOrdersForSymbols': True,
                 'watchMyTrades': True,
             },
             'urls': {
@@ -198,6 +200,48 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def watch_my_trades_for_symbols(self, symbols: Optional[List[str]] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        watches information on multiple trades made by the user
+        :param str[] symbols: unified symbol of the market to fetch trades for
+        :param int [since]: the earliest time in ms to fetch trades for
+        :param int [limit]: the maximum number of trade structures to retrieve
+        :param dict [params]: extra parameters specific to the coinbasepro api endpoint
+        :returns dict[]: a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure
+        """
+        symbols = self.market_symbols(symbols, None, False)
+        await self.load_markets()
+        name = 'user'
+        messageHash = 'multipleMyTrades::'
+        authentication = self.authenticate()
+        trades = await self.subscribe_multiple(name, symbols, messageHash, self.extend(params, authentication))
+        if self.newUpdates:
+            first = self.safe_value(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
+    async def watch_orders_for_symbols(self, symbols: Optional[List[str]] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        watches information on multiple orders made by the user
+        :param str[] symbols: unified symbol of the market to fetch orders for
+        :param int [since]: the earliest time in ms to fetch orders for
+        :param int [limit]: the maximum number of trade structures to retrieve
+        :param dict [params]: extra parameters specific to the coinbasepro api endpoint
+        :returns dict[]: a list of `order structures <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
+        """
+        symbols = self.market_symbols(symbols, None, False)
+        await self.load_markets()
+        name = 'user'
+        messageHash = 'multipleOrders::'
+        authentication = self.authenticate()
+        orders = await self.subscribe_multiple(name, symbols, messageHash, self.extend(params, authentication))
+        if self.newUpdates:
+            first = self.safe_value(orders, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = orders.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
+
     async def watch_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
         watches information on multiple orders made by the user
@@ -326,6 +370,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         marketId = self.safe_string(message, 'product_id')
         if marketId is not None:
             trade = self.parse_ws_trade(message)
+            symbol = trade['symbol']
             type = 'myTrades'
             messageHash = type + ':' + marketId
             tradesArray = self.myTrades
@@ -335,6 +380,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                 self.myTrades = tradesArray
             tradesArray.append(trade)
             client.resolve(tradesArray, messageHash)
+            self.resolve_promise_if_messagehash_matches(client, 'multipleMyTrades::', symbol, tradesArray)
         return message
 
     def parse_ws_trade(self, trade, market=None):
@@ -390,12 +436,23 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         # }
         parsed = super(coinbasepro, self).parse_trade(trade)
         feeRate = None
+        isMaker = False
         if 'maker_fee_rate' in trade:
+            isMaker = True
             parsed['takerOrMaker'] = 'maker'
             feeRate = self.safe_number(trade, 'maker_fee_rate')
         else:
             parsed['takerOrMaker'] = 'taker'
             feeRate = self.safe_number(trade, 'taker_fee_rate')
+            # side always represents the maker side of the trade
+            # so if we're taker, we invert it
+            currentSide = parsed['side']
+            parsed['side'] = self.safe_string({
+                'buy': 'sell',
+                'sell': 'buy',
+            }, currentSide, currentSide)
+        idKey = 'maker_order_id' if isMaker else 'taker_order_id'
+        parsed['order'] = self.safe_string(trade, idKey)
         market = self.market(parsed['symbol'])
         feeCurrency = market['quote']
         feeCost = None
@@ -518,6 +575,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                 parsed = self.parse_ws_order(message)
                 orders.append(parsed)
                 client.resolve(orders, messageHash)
+                self.resolve_promise_if_messagehash_matches(client, 'multipleOrders::', symbol, orders)
             else:
                 sequence = self.safe_integer(message, 'sequence')
                 previousInfo = self.safe_value(previousOrder, 'info', {})
@@ -553,6 +611,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                         # update the newUpdates count
                         orders.append(previousOrder)
                         client.resolve(orders, messageHash)
+                        self.resolve_promise_if_messagehash_matches(client, 'multipleOrders::', symbol, orders)
                     elif (type == 'received') or (type == 'done'):
                         info = self.extend(previousOrder['info'], message)
                         order = self.parse_ws_order(info)
@@ -565,6 +624,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                         # update the newUpdates count
                         orders.append(previousOrder)
                         client.resolve(orders, messageHash)
+                        self.resolve_promise_if_messagehash_matches(client, 'multipleOrders::', symbol, orders)
 
     def parse_ws_order(self, order, market=None):
         id = self.safe_string(order, 'order_id')
@@ -588,10 +648,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             filled = 0
             if amount is not None:
                 remaining = amount - filled
-        cost = None
-        if (price is not None) and (amount is not None):
-            cost = price * amount
-        return {
+        return self.safe_order({
             'info': order,
             'symbol': symbol,
             'id': id,
@@ -607,14 +664,14 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             'stopPrice': None,
             'triggerPrice': None,
             'amount': amount,
-            'cost': cost,
+            'cost': None,
             'average': None,
             'filled': filled,
             'remaining': remaining,
             'status': status,
             'fee': None,
             'trades': None,
-        }
+        })
 
     def handle_ticker(self, client: Client, message):
         #

ccxt/pro/okx.py

@@ -978,8 +978,8 @@ class okx(ccxt.async_support.okx):
         # filter orders with no last trade id
         for i in range(0, len(rawOrders)):
             rawOrder = rawOrders[i]
-            tradeId = self.safe_string(rawOrder, 'tradeId')
-            if not self.is_empty(tradeId):
+            tradeId = self.safe_string(rawOrder, 'tradeId', '')
+            if len(tradeId) > 0:
                 order = self.parse_order(rawOrder)
                 filteredOrders.append(order)
         tradesLength = len(filteredOrders)

{ccxt-4.0.112.dist-info → ccxt-4.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.0.112
+Version: 4.1.2
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 130+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -258,13 +258,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@4.0.112/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.0.112/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.1.2/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.1.2/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@4.0.112/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.1.2/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: