ccxt 3.1.14__py2.py3-none-any.whl → 3.1.15__py2.py3-none-any.whl

ccxt/pro/coinbasepro.py

@@ -99,7 +99,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         trades = await self.subscribe(name, symbol, name, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_my_trades(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
@@ -120,7 +120,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         trades = await self.subscribe(name, symbol, messageHash, self.extend(params, authentication))
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
@@ -141,7 +141,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         orders = await self.subscribe(name, symbol, messageHash, self.extend(params, authentication))
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
-        return self.filter_by_since_limit(orders, since, limit, 'timestamp')
+        return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """

ccxt/pro/coinex.py

@@ -438,7 +438,7 @@ class coinex(ccxt.async_support.coinex):
         self.options['watchTradesSubscriptions'] = subscribedSymbols
         request = self.deep_extend(message, params)
         trades = await self.watch(url, messageHash, request, subscriptionHash)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """

ccxt/pro/cryptocom.py

@@ -127,7 +127,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         trades = await self.watch_public(messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -189,7 +189,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         trades = await self.watch_private(messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     async def watch_ticker(self, symbol: str, params={}):
         """
@@ -259,7 +259,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         ohlcv = await self.watch_public(messageHash, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/currencycom.py

@@ -371,7 +371,7 @@ class currencycom(ccxt.async_support.currencycom):
         trades = await self.watch_public('trades.subscribe', symbol, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """
@@ -412,7 +412,7 @@ class currencycom(ccxt.async_support.currencycom):
         ohlcv = await self.watch_public(messageHash, symbol, self.extend(request, params))
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_deltas(self, bookside, deltas):
         prices = list(deltas.keys())

ccxt/pro/deribit.py

@@ -241,7 +241,7 @@ class deribit(ccxt.async_support.deribit):
         trades = await self.watch(url, channel, request, channel, request)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -313,7 +313,7 @@ class deribit(ccxt.async_support.deribit):
         }
         request = self.deep_extend(message, params)
         trades = await self.watch(url, channel, request, channel, request)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trades(self, client: Client, message):
         #
@@ -601,7 +601,7 @@ class deribit(ccxt.async_support.deribit):
         ohlcv = await self.watch(url, channel, request, channel, request)
         if self.newUpdates:
             limit = ohlcv.getLimit(market['symbol'], limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/exmo.py

@@ -273,7 +273,7 @@ class exmo(ccxt.async_support.exmo):
         }
         request = self.deep_extend(message, params)
         trades = await self.watch(url, messageHash, request, messageHash, request)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -339,7 +339,7 @@ class exmo(ccxt.async_support.exmo):
         }
         request = self.deep_extend(message, query)
         trades = await self.watch(url, messageHash, request, messageHash, request)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trades(self, client: Client, message):
         #

ccxt/pro/gate.py

@@ -367,7 +367,7 @@ class gate(ccxt.async_support.gate):
         trades = await self.subscribe_public(url, messageHash, payload, channel, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -425,7 +425,7 @@ class gate(ccxt.async_support.gate):
         ohlcv = await self.subscribe_public(url, messageHash, payload, channel, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #
@@ -515,7 +515,7 @@ class gate(ccxt.async_support.gate):
         trades = await self.subscribe_private(url, messageHash, payload, channel, params, requiresUid)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trades(self, client: Client, message):
         #
@@ -713,7 +713,7 @@ class gate(ccxt.async_support.gate):
         orders = await self.subscribe_private(url, messageHash, payload, channel, query, requiresUid)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
-        return self.filter_by_since_limit(orders, since, limit, 'timestamp')
+        return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
 
     def handle_order(self, client: Client, message):
         #

ccxt/pro/gemini.py

@@ -67,7 +67,7 @@ class gemini(ccxt.async_support.gemini):
         trades = await self.watch(url, messageHash, request, subscribeHash)
         if self.newUpdates:
             limit = trades.getLimit(market['symbol'], limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def parse_ws_trade(self, trade, market=None):
         #
@@ -211,7 +211,7 @@ class gemini(ccxt.async_support.gemini):
         ohlcv = await self.watch(url, messageHash, request, messageHash)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/hitbtc.py

@@ -206,7 +206,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         trades = await self.watch_public(symbol, 'trades', None, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -279,7 +279,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         ohlcv = await self.watch_public(symbol, 'ohlcv', period, requestParams)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/hollaex.py

@@ -127,7 +127,7 @@ class hollaex(ccxt.async_support.hollaex):
         trades = await self.watch_public(messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -181,7 +181,7 @@ class hollaex(ccxt.async_support.hollaex):
         trades = await self.watch_private(messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trades(self, client: Client, message, subscription=None):
         #

ccxt/pro/huobi.py

@@ -204,7 +204,7 @@ class huobi(ccxt.async_support.huobi):
         trades = await self.subscribe_public(url, symbol, messageHash, None, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -264,7 +264,7 @@ class huobi(ccxt.async_support.huobi):
         ohlcv = await self.subscribe_public(url, symbol, messageHash, None, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #
@@ -650,7 +650,7 @@ class huobi(ccxt.async_support.huobi):
         trades = await self.subscribe_private(channel, messageHash, type, subType, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def get_order_channel_and_message_hash(self, type, subType, market=None, params={}):
         messageHash = None
@@ -726,7 +726,7 @@ class huobi(ccxt.async_support.huobi):
         orders = await self.subscribe_private(channel, messageHash, type, subType, params)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
-        return self.filter_by_since_limit(orders, since, limit, 'timestamp')
+        return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
 
     def handle_order(self, client: Client, message):
         #

ccxt/pro/huobijp.py

@@ -139,7 +139,7 @@ class huobijp(ccxt.async_support.huobijp):
         trades = await self.watch(url, messageHash, self.extend(request, params), messageHash, subscription)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -213,7 +213,7 @@ class huobijp(ccxt.async_support.huobijp):
         ohlcv = await self.watch(url, messageHash, self.extend(request, params), messageHash, subscription)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/idex.py

@@ -155,7 +155,7 @@ class idex(ccxt.async_support.idex):
         trades = await self.subscribe(subscribeObject, messageHash)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trade(self, client: Client, message):
         type = self.safe_string(message, 'type')
@@ -248,7 +248,7 @@ class idex(ccxt.async_support.idex):
         ohlcv = await self.subscribe(subscribeObject, messageHash)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         # {type: 'candles',
@@ -494,7 +494,7 @@ class idex(ccxt.async_support.idex):
         orders = await self.subscribe_private(subscribeObject, messageHash)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
-        return self.filter_by_since_limit(orders, since, limit, 'timestamp')
+        return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
 
     def handle_order(self, client: Client, message):
         # {

ccxt/pro/independentreserve.py

@@ -55,7 +55,7 @@ class independentreserve(ccxt.async_support.independentreserve):
         url = self.urls['api']['ws'] + '?subscribe=ticker-' + market['base'] + '-' + market['quote']
         messageHash = 'trades:' + symbol
         trades = await self.watch(url, messageHash, None, messageHash)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #

ccxt/pro/kraken.py

@@ -251,7 +251,7 @@ class kraken(ccxt.async_support.kraken):
         trades = await self.watch_public(name, symbol, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """
@@ -306,7 +306,7 @@ class kraken(ccxt.async_support.kraken):
         ohlcv = await self.watch(url, messageHash, request, messageHash)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     async def load_markets(self, reload=False, params={}):
         markets = await super(kraken, self).load_markets(reload, params)

ccxt/pro/krakenfutures.py

@@ -176,7 +176,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         trades = await self.subscribe_public(name, [symbol], params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """
@@ -210,7 +210,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         orders = await self.subscribe_private(name, messageHash, params)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
-        return self.filter_by_since_limit(orders, since, limit, 'timestamp')
+        return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
 
     async def watch_my_trades(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
@@ -231,7 +231,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         trades = await self.subscribe_private(name, messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_balance(self, params={}):
         """
@@ -1191,7 +1191,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         if event == 'challenge':
             self.handle_authenticate(client, message)
         elif event == 'pong':
-            return client.onPong(message)
+            client.lastPong = self.milliseconds()
         elif event is None:
             feed = self.safe_string(message, 'feed')
             methods = {

ccxt/pro/kucoin.py

@@ -218,7 +218,7 @@ class kucoin(ccxt.async_support.kucoin):
         ohlcv = await self.subscribe(url, messageHash, topic, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #
@@ -280,7 +280,7 @@ class kucoin(ccxt.async_support.kucoin):
         trades = await self.subscribe(url, messageHash, topic, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trade(self, client: Client, message):
         #
@@ -603,7 +603,7 @@ class kucoin(ccxt.async_support.kucoin):
         trades = await self.subscribe(url, messageHash, topic, self.extend(request, params))
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trade(self, client: Client, message):
         trades = self.myTrades

ccxt/pro/kucoinfutures.py

@@ -192,7 +192,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         trades = await self.subscribe(url, messageHash, topic, None, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trade(self, client: Client, message):
         #

ccxt/pro/luno.py

@@ -63,7 +63,7 @@ class luno(ccxt.async_support.luno):
         trades = await self.watch(url, messageHash, request, subscriptionHash, subscription)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message, subscription):
         #

ccxt/pro/mexc.py

@@ -221,7 +221,7 @@ class mexc(ccxt.async_support.mexc):
             ohlcv = await self.watch_swap_public(channel, messageHash, requestParams, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #
@@ -508,7 +508,7 @@ class mexc(ccxt.async_support.mexc):
             trades = await self.watch_swap_public(channel, messageHash, requestParams, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -589,7 +589,7 @@ class mexc(ccxt.async_support.mexc):
             trades = await self.watch_swap_private(messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trade(self, client: Client, message, subscription=None):
         #

ccxt/pro/ndax.py

@@ -136,7 +136,7 @@ class ndax(ccxt.async_support.ndax):
         trades = await self.watch(url, messageHash, message, messageHash)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         payload = self.safe_value(message, 'o', [])
@@ -213,7 +213,7 @@ class ndax(ccxt.async_support.ndax):
         ohlcv = await self.watch(url, messageHash, message, messageHash)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/okcoin.py

@@ -82,7 +82,7 @@ class okcoin(ccxt.async_support.okcoin):
         trades = await self.subscribe('trade', symbol, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
@@ -101,7 +101,7 @@ class okcoin(ccxt.async_support.okcoin):
         trades = await self.subscribe(orderType, symbol, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_orders(self, client: Client, message, subscription=None):
         #
@@ -254,7 +254,7 @@ class okcoin(ccxt.async_support.okcoin):
         ohlcv = await self.subscribe(name, symbol, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/okx.py

@@ -114,7 +114,7 @@ class okx(ccxt.async_support.okx):
         trades = await self.subscribe('public', 'trades', symbol, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
         #
@@ -213,7 +213,7 @@ class okx(ccxt.async_support.okx):
         ohlcv = await self.subscribe('public', name, symbol, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #

ccxt/pro/phemex.py

@@ -531,7 +531,7 @@ class phemex(ccxt.async_support.phemex):
         trades = await self.watch(url, messageHash, request, messageHash)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp')
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_order_book(self, symbol: str, limit: Optional[int] = None, params={}):
         """
@@ -600,7 +600,7 @@ class phemex(ccxt.async_support.phemex):
         ohlcv = await self.watch(url, messageHash, request, messageHash)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_delta(self, bookside, delta, market=None):
         bidAsk = self.customParseBidAsk(delta, 0, 1, market)
@@ -711,7 +711,7 @@ class phemex(ccxt.async_support.phemex):
         trades = await self.subscribe_private(type, messageHash, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(trades, symbol, since, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trades(self, client: Client, message):
         #