Qubx 0.6.84__tar.gz → 0.6.85__tar.gz

{qubx-0.6.84 → qubx-0.6.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.84
+Version: 0.6.85
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko

{qubx-0.6.84 → qubx-0.6.85}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.84"
+version = "0.6.85"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/connectors/ccxt/account.py

@@ -130,6 +130,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
         if not self.exchange_manager.exchange.isSandboxModeEnabled:
             # - start polling tasks
+            self._loop.submit(self.exchange_manager.exchange.load_markets()).result()
             self._polling_tasks["balance"] = self._loop.submit(
                 self._poller("balance", self._update_balance, self.balance_interval)
             )

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/connectors/ccxt/exchanges/hyperliquid/broker.py

@@ -9,7 +9,7 @@ from qubx.core.exceptions import BadRequest
 class HyperliquidCcxtBroker(CcxtBroker):
     """
     HyperLiquid-specific broker that handles market order slippage requirements.
-    
+
     HyperLiquid requires a price even for market orders to calculate max slippage.
     This broker automatically calculates slippage-protected prices for market orders.
     """
@@ -17,7 +17,7 @@ class HyperliquidCcxtBroker(CcxtBroker):
     def __init__(
         self,
         *args,
-        market_order_slippage: float = 0.05,  # 5% default slippage
+        market_order_slippage: float = 0.01,  # 5% default slippage
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
@@ -38,21 +38,29 @@ class HyperliquidCcxtBroker(CcxtBroker):
         if order_type.lower() == "market" and price is None:
             quote = self.data_provider.get_quote(instrument)
             if quote is None:
-                logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for market order slippage calculation.")
-                raise BadRequest(f"Quote is not available for market order slippage calculation for {instrument.symbol}")
+                logger.warning(
+                    f"[<y>{instrument.symbol}</y>] :: Quote is not available for market order slippage calculation."
+                )
+                raise BadRequest(
+                    f"Quote is not available for market order slippage calculation for {instrument.symbol}"
+                )
 
             # Get slippage from options or use default
             slippage = options.get("slippage", self.market_order_slippage)
-            
+
             # Calculate slippage-protected price
             if order_side.upper() == "BUY":
                 # For buy orders, add slippage to ask price to ensure execution
                 price = quote.ask * (1 + slippage)
-                logger.debug(f"[<y>{instrument.symbol}</y>] :: Market BUY order: using slippage-protected price {price:.6f} (ask: {quote.ask:.6f}, slippage: {slippage:.1%})")
+                logger.debug(
+                    f"[<y>{instrument.symbol}</y>] :: Market BUY order: using slippage-protected price {price:.6f} (ask: {quote.ask:.6f}, slippage: {slippage:.1%})"
+                )
             else:  # SELL
                 # For sell orders, subtract slippage from bid price to ensure execution
                 price = quote.bid * (1 - slippage)
-                logger.debug(f"[<y>{instrument.symbol}</y>] :: Market SELL order: using slippage-protected price {price:.6f} (bid: {quote.bid:.6f}, slippage: {slippage:.1%})")
+                logger.debug(
+                    f"[<y>{instrument.symbol}</y>] :: Market SELL order: using slippage-protected price {price:.6f} (bid: {quote.bid:.6f}, slippage: {slippage:.1%})"
+                )
 
         # Call parent implementation with calculated price
         payload = super()._prepare_order_payload(
@@ -64,6 +72,6 @@ class HyperliquidCcxtBroker(CcxtBroker):
         if "slippage" in options:
             # HyperLiquid accepts slippage as a percentage (e.g., 0.05 for 5%)
             params["px"] = price  # Explicit price for slippage calculation
-            
+
         payload["params"] = params
-        return payload
+        return payload

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/connectors/ccxt/handlers/orderbook.py

@@ -65,7 +65,7 @@ class OrderBookDataHandler(BaseDataTypeHandler):
 
         # Notify all listeners
         self._data_provider.notify_data_arrival(sub_type, dt_64(ob.time, "ns"))
-        
+
         channel.send((instrument, sub_type, ob, False))
         return True
 
@@ -150,7 +150,7 @@ class OrderBookDataHandler(BaseDataTypeHandler):
     ) -> SubscriptionConfiguration:
         """
         Prepare subscription configuration for individual instruments.
-        
+
         Creates separate subscriber functions for each instrument to enable independent
         WebSocket streams without waiting for all instruments. This follows the same
         pattern as the OHLC handler for proper individual stream management.
@@ -169,10 +169,10 @@ class OrderBookDataHandler(BaseDataTypeHandler):
                     try:
                         # Watch orderbook for single instrument
                         ccxt_ob = await self._exchange_manager.exchange.watch_order_book(symbol)
-                        
+
                         # Use private processing method to avoid duplication
                         self._process_orderbook(ccxt_ob, inst, sub_type, channel, depth, tick_size_pct)
-                        
+
                     except Exception as e:
                         logger.error(
                             f"<yellow>{exchange_id}</yellow> Error in individual orderbook subscription for {inst.symbol}: {e}"
@@ -186,13 +186,15 @@ class OrderBookDataHandler(BaseDataTypeHandler):
             # Create individual unsubscriber if exchange supports it
             un_watch_method = getattr(self._exchange_manager.exchange, "un_watch_order_book", None)
             if un_watch_method is not None and callable(un_watch_method):
-                
+
                 def create_individual_unsubscriber(symbol=ccxt_symbol, exchange_id=self._exchange_id):
                     async def individual_unsubscriber():
                         try:
                             await self._exchange_manager.exchange.un_watch_order_book(symbol)
                         except Exception as e:
-                            logger.error(f"<yellow>{exchange_id}</yellow> Error unsubscribing orderbook for {symbol}: {e}")
+                            logger.error(
+                                f"<yellow>{exchange_id}</yellow> Error unsubscribing orderbook for {symbol}: {e}"
+                            )
 
                     return individual_unsubscriber
 

qubx-0.6.85/src/qubx/connectors/ccxt/handlers/trade.py

@@ -0,0 +1,207 @@
+"""
+Trade data type handler for CCXT data provider.
+
+Handles subscription and warmup for trade data.
+"""
+
+from typing import Set
+
+from qubx import logger
+from qubx.core.basics import CtrlChannel, DataType, Instrument, dt_64
+from qubx.core.series import Quote
+
+from ..subscription_config import SubscriptionConfiguration
+from ..utils import (
+    ccxt_convert_trade,
+    ccxt_find_instrument,
+    create_market_type_batched_subscriber,
+    instrument_to_ccxt_symbol,
+)
+from .base import BaseDataTypeHandler
+
+
+class TradeDataHandler(BaseDataTypeHandler):
+    """Handler for trade data subscription and processing."""
+
+    @property
+    def data_type(self) -> str:
+        return "trade"
+
+    def _process_trade(self, trades: list, instrument: Instrument, sub_type: str, channel: CtrlChannel):
+        """
+        Process trades with synthetic quote generation.
+
+        This method handles the common logic for processing trade data that's shared between
+        bulk and individual subscription approaches.
+
+        Args:
+            trades: List of CCXT trade dictionaries
+            instrument: Instrument these trades belong to
+            sub_type: Subscription type string
+            channel: Control channel to send data through
+        """
+        for trade in trades:
+            converted_trade = ccxt_convert_trade(trade)
+
+            # Notify all listeners
+            self._data_provider.notify_data_arrival(sub_type, dt_64(converted_trade.time, "ns"))
+
+            channel.send((instrument, sub_type, converted_trade, False))
+
+        # Generate synthetic quote if no quote/orderbook subscription exists
+        if len(trades) > 0 and not (
+            self._data_provider.has_subscription(instrument, DataType.ORDERBOOK)
+            or self._data_provider.has_subscription(instrument, DataType.QUOTE)
+        ):
+            last_trade = trades[-1]
+            converted_trade = ccxt_convert_trade(last_trade)
+            _price = converted_trade.price
+            _time = converted_trade.time
+            _s2 = instrument.tick_size / 2.0
+            _bid, _ask = _price - _s2, _price + _s2
+            self._data_provider._last_quotes[instrument] = Quote(_time, _bid, _ask, 0.0, 0.0)
+
+    def prepare_subscription(
+        self, name: str, sub_type: str, channel: CtrlChannel, instruments: Set[Instrument], **params
+    ) -> SubscriptionConfiguration:
+        """
+        Prepare trade subscription configuration.
+
+        Args:
+            name: Stream name for this subscription
+            sub_type: Parsed subscription type ("trade")
+            channel: Control channel for managing subscription lifecycle
+            instruments: Set of instruments to subscribe to
+
+        Returns:
+            SubscriptionConfiguration with subscriber and unsubscriber functions
+        """
+        # Use exchange-specific approach based on capabilities
+        if self._exchange_manager.exchange.has.get("watchTradesForSymbols", False):
+            return self._prepare_subscription_for_instruments(name, sub_type, channel, instruments)
+        else:
+            # Fall back to individual instrument subscriptions
+            return self._prepare_subscription_for_individual_instruments(name, sub_type, channel, instruments)
+
+    def _prepare_subscription_for_instruments(
+        self,
+        name: str,
+        sub_type: str,
+        channel: CtrlChannel,
+        instruments: Set[Instrument],
+    ) -> SubscriptionConfiguration:
+        """Prepare subscription configuration for multiple instruments using bulk API."""
+        _instr_to_ccxt_symbol = {i: instrument_to_ccxt_symbol(i) for i in instruments}
+        _symbol_to_instrument = {_instr_to_ccxt_symbol[i]: i for i in instruments}
+
+        async def watch_trades(instruments_batch: list[Instrument]):
+            symbols = [_instr_to_ccxt_symbol[i] for i in instruments_batch]
+            trades = await self._exchange_manager.exchange.watch_trades_for_symbols(symbols)
+
+            exch_symbol = trades[0]["symbol"]
+            instrument = ccxt_find_instrument(exch_symbol, self._exchange_manager.exchange, _symbol_to_instrument)
+
+            # Use private processing method to avoid duplication
+            self._process_trade(trades, instrument, sub_type, channel)
+
+        async def un_watch_trades(instruments_batch: list[Instrument]):
+            symbols = [_instr_to_ccxt_symbol[i] for i in instruments_batch]
+            await self._exchange_manager.exchange.un_watch_trades_for_symbols(symbols)
+
+        return SubscriptionConfiguration(
+            subscription_type=sub_type,
+            subscriber_func=create_market_type_batched_subscriber(watch_trades, instruments),
+            unsubscriber_func=create_market_type_batched_subscriber(un_watch_trades, instruments),
+            stream_name=name,
+            requires_market_type_batching=True,
+        )
+
+    def _prepare_subscription_for_individual_instruments(
+        self,
+        name: str,
+        sub_type: str,
+        channel: CtrlChannel,
+        instruments: Set[Instrument],
+    ) -> SubscriptionConfiguration:
+        """
+        Prepare subscription configuration for individual instruments.
+
+        Creates separate subscriber functions for each instrument to enable independent
+        WebSocket streams without waiting for all instruments. This follows the same
+        pattern as the orderbook handler for proper individual stream management.
+        """
+        _instr_to_ccxt_symbol = {i: instrument_to_ccxt_symbol(i) for i in instruments}
+
+        individual_subscribers = {}
+        individual_unsubscribers = {}
+
+        for instrument in instruments:
+            ccxt_symbol = _instr_to_ccxt_symbol[instrument]
+
+            # Create individual subscriber for this instrument using closure
+            def create_individual_subscriber(inst=instrument, symbol=ccxt_symbol, exchange_id=self._exchange_id):
+                async def individual_subscriber():
+                    try:
+                        # Watch trades for single instrument
+                        trades = await self._exchange_manager.exchange.watch_trades(symbol)
+
+                        # Use private processing method to avoid duplication
+                        self._process_trade(trades, inst, sub_type, channel)
+
+                    except Exception as e:
+                        logger.error(
+                            f"<yellow>{exchange_id}</yellow> Error in individual trade subscription for {inst.symbol}: {e}"
+                        )
+                        raise  # Let connection manager handle retries
+
+                return individual_subscriber
+
+            individual_subscribers[instrument] = create_individual_subscriber()
+
+            # Create individual unsubscriber if exchange supports it
+            un_watch_method = getattr(self._exchange_manager.exchange, "un_watch_trades", None)
+            if un_watch_method is not None and callable(un_watch_method):
+
+                def create_individual_unsubscriber(symbol=ccxt_symbol, exchange_id=self._exchange_id):
+                    async def individual_unsubscriber():
+                        try:
+                            await self._exchange_manager.exchange.un_watch_trades(symbol)
+                        except Exception as e:
+                            logger.error(f"<yellow>{exchange_id}</yellow> Error unsubscribing trades for {symbol}: {e}")
+
+                    return individual_unsubscriber
+
+                individual_unsubscribers[instrument] = create_individual_unsubscriber()
+
+        return SubscriptionConfiguration(
+            subscription_type=sub_type,
+            instrument_subscribers=individual_subscribers,
+            instrument_unsubscribers=individual_unsubscribers if individual_unsubscribers else None,
+            stream_name=name,
+            requires_market_type_batching=False,
+        )
+
+    async def warmup(self, instruments: Set[Instrument], channel: CtrlChannel, warmup_period: str, **params) -> None:
+        """
+        Fetch historical trade data for warmup during backtesting.
+
+        Args:
+            instruments: Set of instruments to warm up
+            channel: Control channel for sending warmup data
+            warmup_period: Period to warm up (e.g., "30d", "1000h")
+        """
+        for instrument in instruments:
+            trades = await self._exchange_manager.exchange.fetch_trades(
+                instrument.symbol, since=self._data_provider._time_msec_nbars_back(warmup_period)
+            )
+
+            logger.debug(f"<yellow>{self._exchange_id}</yellow> Loaded {len(trades)} trades for {instrument}")
+
+            channel.send(
+                (
+                    instrument,
+                    DataType.TRADE,
+                    [ccxt_convert_trade(trade) for trade in trades],
+                    True,  # historical data
+                )
+            )

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/core/helpers.py

@@ -233,10 +233,16 @@ class CachedMarketDataHolder:
         if series:
             total_vol = trade.size
             bought_vol = total_vol if trade.side == 1 else 0.0
+            volume_quote = trade.price * trade.size
+            bought_volume_quote = volume_quote if trade.side == 1 else 0.0
             for ser in series.values():
-                if len(ser) > 0 and ser[0].time > trade.time:
-                    continue
-                ser.update(trade.time, trade.price, total_vol, bought_vol)
+                if len(ser) > 0:
+                    current_bar_start = floor_t64(np.datetime64(ser[0].time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
+                    trade_bar_start = floor_t64(np.datetime64(trade.time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
+                    if trade_bar_start < current_bar_start:
+                        # Trade belongs to a previous bar - skip it
+                        continue
+                ser.update(trade.time, trade.price, total_vol, bought_vol, volume_quote, bought_volume_quote, 1)
 
     def finalize_ohlc_for_instruments(self, time: dt_64, instruments: list[Instrument]):
         """

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/core/mixins/subscription.py

@@ -235,10 +235,16 @@ class SubscriptionManager(ISubscriptionManager):
                     self._pending_warmups[(sub, instr)] = _warmup_period
 
             # TODO: think about appropriate handling of timeouts
-            _data_provider.warmup(self._pending_warmups.copy())
+            _warmup_configs = self._get_pending_warmups_for_exchange(_data_provider.exchange())
+            _data_provider.warmup(_warmup_configs)
 
         self._pending_warmups.clear()
 
+    def _get_pending_warmups_for_exchange(self, exchange: str) -> dict[tuple[str, Instrument], str]:
+        return {
+            (sub, instr): period for (sub, instr), period in self._pending_warmups.items() if instr.exchange == exchange
+        }
+
     def _get_data_provider(self, exchange: str) -> IDataProvider:
         if exchange in self._exchange_to_data_provider:
             return self._exchange_to_data_provider[exchange]

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/core/series.pxd

@@ -63,7 +63,7 @@ cdef class Bar:
     cdef public double bought_volume_quote  # volume bought (in quote asset) if presented
     cdef public int trade_count             # number of trades in this bar
 
-    cpdef Bar update(Bar self, double price, double volume, double volume_quote=*, double bought_volume=*, double bought_volume_quote=*, int trade_count=*)
+    cpdef Bar update(Bar self, double price, double volume, double bought_volume=*, double volume_quote=*, double bought_volume_quote=*, int trade_count=*)
 
     cpdef dict to_dict(Bar self, unsigned short skip_time=*)
 
@@ -78,8 +78,9 @@ cdef class OHLCV(TimeSeries):
     cdef public TimeSeries volume_quote
     cdef public TimeSeries bvolume_quote
     cdef public TimeSeries trade_count
+    cdef public dict columns 
 
-    cpdef short update(OHLCV self, long long time, double price, double volume=*, double bvolume=*)
+    cpdef short update(OHLCV self, long long time, double price, double volume=*, double bvolume=*, double volume_quote=*, double bought_volume_quote=*, int trade_count=*)
 
     cpdef short update_by_bar(
         OHLCV self, long long time, double open, double high, double low, double close, 

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/core/series.pyi

@@ -31,8 +31,8 @@ class Bar:
         self,
         price: float,
         volume: float,
-        volume_quote: float = 0,
         bought_volume: float = 0,
+        volume_quote: float = 0,
         bought_volume_quote: float = 0,
         trade_count: int = 0,
     ) -> "Bar": ...
@@ -127,7 +127,8 @@ class OHLCV(TimeSeries):
 
     def __init__(self, name, timeframe, max_series_length: int | float = np.inf) -> None: ...
     def __len__(self) -> int: ...
-    def update(self, time: int, price: float, volume: float = 0.0, bvolume: float = 0.0) -> bool: ...
+    def update(self, time: int, price: float, volume: float = 0.0, bvolume: float = 0.0,
+              volume_quote: float = 0.0, bought_volume_quote: float = 0.0, trade_count: int = 0) -> bool: ...
     def update_by_bar(
         self,
         time: int,

{qubx-0.6.84 → qubx-0.6.85}/src/qubx/core/series.pyx

@@ -773,7 +773,7 @@ cdef class Bar:
         self.bought_volume += bought_volume
         self.volume_quote += volume_quote
         self.bought_volume_quote += bought_volume_quote
-        self.trade_count = trade_count  # Use latest trade count (cumulative)
+        self.trade_count += trade_count  # Increment trade count
         return self
 
     cpdef dict to_dict(self, unsigned short skip_time=0):
@@ -1020,6 +1020,22 @@ cdef class OHLCV(TimeSeries):
         self.volume_quote = TimeSeries('volume_quote', timeframe, max_series_length)
         self.bvolume_quote = TimeSeries('bvolume_quote', timeframe, max_series_length)
         self.trade_count = TimeSeries('trade_count', timeframe, max_series_length)
+        self.columns = {
+            "open": self.open,
+            "high": self.high,
+            "low": self.low,
+            "close": self.close,
+            "volume": self.volume,
+            "bvolume": self.bvolume,
+            "volume_quote": self.volume_quote,
+            "bvolume_quote": self.bvolume_quote,
+            "trade_count": self.trade_count,
+        }
+
+    def __getitem__(self, idx):
+        if isinstance(idx, str):
+            return self.columns[idx]
+        return super().__getitem__(idx)
 
     cpdef object append_data(self, 
                     np.ndarray times, 
@@ -1114,18 +1130,25 @@ cdef class OHLCV(TimeSeries):
         self.trade_count._update_last_item(time, value.trade_count)
         self._is_new_item = False
 
-    cpdef short update(self, long long time, double price, double volume=0.0, double bvolume=0.0):
+    cpdef short update(self, long long time, double price, double volume=0.0, double bvolume=0.0,
+                      double volume_quote=0.0, double bought_volume_quote=0.0, int trade_count=0):
         cdef Bar b
         bar_start_time = floor_t64(time, self.timeframe)
 
         if not self.times:
-            self._add_new_item(bar_start_time, Bar(bar_start_time, price, price, price, price, volume=volume, bought_volume=bvolume))
+            self._add_new_item(bar_start_time, Bar(bar_start_time, price, price, price, price,
+                                                  volume=volume, bought_volume=bvolume,
+                                                  volume_quote=volume_quote, bought_volume_quote=bought_volume_quote,
+                                                  trade_count=trade_count))
 
             # Here we disable first notification because first item may be incomplete
             self._is_new_item = False
 
         elif (_dt := time - self.times[0]) >= self.timeframe:
-            b = Bar(bar_start_time, price, price, price, price, volume=volume, bought_volume=bvolume)
+            b = Bar(bar_start_time, price, price, price, price,
+                   volume=volume, bought_volume=bvolume,
+                   volume_quote=volume_quote, bought_volume_quote=bought_volume_quote,
+                   trade_count=trade_count)
 
             # - add new item
             self._add_new_item(bar_start_time, b)
@@ -1138,7 +1161,9 @@ cdef class OHLCV(TimeSeries):
             if _dt < 0:
                 raise ValueError(f"Attempt to update past data at {time_to_str(time)} !")
 
-            self._update_last_item(bar_start_time, self[0].update(price, volume, bvolume))
+            self._update_last_item(bar_start_time, self[0].update(price, volume, bvolume,
+                                                                  volume_quote, bought_volume_quote,
+                                                                  trade_count))
 
         # - update indicators by new data
         self._update_indicators(bar_start_time, self[0], False)

qubx-0.6.84/src/qubx/connectors/ccxt/handlers/trade.py

@@ -1,111 +0,0 @@
-"""
-Trade data type handler for CCXT data provider.
-
-Handles subscription and warmup for trade data.
-"""
-
-from typing import Set
-
-from qubx import logger
-from qubx.core.basics import CtrlChannel, DataType, Instrument, dt_64
-from qubx.core.series import Quote
-
-from ..subscription_config import SubscriptionConfiguration
-from ..utils import (
-    ccxt_convert_trade,
-    ccxt_find_instrument,
-    create_market_type_batched_subscriber,
-    instrument_to_ccxt_symbol,
-)
-from .base import BaseDataTypeHandler
-
-
-class TradeDataHandler(BaseDataTypeHandler):
-    """Handler for trade data subscription and processing."""
-
-    @property
-    def data_type(self) -> str:
-        return "trade"
-
-    def prepare_subscription(
-        self, name: str, sub_type: str, channel: CtrlChannel, instruments: Set[Instrument], **params
-    ) -> SubscriptionConfiguration:
-        """
-        Prepare trade subscription configuration.
-
-        Args:
-            name: Stream name for this subscription
-            sub_type: Parsed subscription type ("trade")
-            channel: Control channel for managing subscription lifecycle
-            instruments: Set of instruments to subscribe to
-
-        Returns:
-            SubscriptionConfiguration with subscriber and unsubscriber functions
-        """
-        _instr_to_ccxt_symbol = {i: instrument_to_ccxt_symbol(i) for i in instruments}
-        _symbol_to_instrument = {_instr_to_ccxt_symbol[i]: i for i in instruments}
-
-        async def watch_trades(instruments_batch: list[Instrument]):
-            symbols = [_instr_to_ccxt_symbol[i] for i in instruments_batch]
-            trades = await self._exchange_manager.exchange.watch_trades_for_symbols(symbols)
-
-            exch_symbol = trades[0]["symbol"]
-            instrument = ccxt_find_instrument(exch_symbol, self._exchange_manager.exchange, _symbol_to_instrument)
-
-            for trade in trades:
-                converted_trade = ccxt_convert_trade(trade)
-                
-                # Notify all listeners
-                self._data_provider.notify_data_arrival(sub_type, dt_64(converted_trade.time, "ns"))
-                
-                channel.send((instrument, sub_type, converted_trade, False))
-
-            if len(trades) > 0 and not (
-                self._data_provider.has_subscription(instrument, DataType.ORDERBOOK)
-                or self._data_provider.has_subscription(instrument, DataType.QUOTE)
-            ):
-                last_trade = trades[-1]
-                converted_trade = ccxt_convert_trade(last_trade)
-                _price = converted_trade.price
-                _time = converted_trade.time
-                _s2 = instrument.tick_size / 2.0
-                _bid, _ask = _price - _s2, _price + _s2
-                self._data_provider._last_quotes[instrument] = Quote(_time, _bid, _ask, 0.0, 0.0)
-
-        async def un_watch_trades(instruments_batch: list[Instrument]):
-            symbols = [_instr_to_ccxt_symbol[i] for i in instruments_batch]
-            await self._exchange_manager.exchange.un_watch_trades_for_symbols(symbols)
-
-        # Return subscription configuration instead of calling _listen_to_stream directly
-        return SubscriptionConfiguration(
-            subscription_type=sub_type,
-            subscriber_func=create_market_type_batched_subscriber(watch_trades, instruments),
-            unsubscriber_func=create_market_type_batched_subscriber(un_watch_trades, instruments),
-            stream_name=name,
-            requires_market_type_batching=True,
-        )
-
-    async def warmup(self, instruments: Set[Instrument], channel: CtrlChannel, warmup_period: str, **params) -> None:
-        """
-        Fetch historical trade data for warmup during backtesting.
-
-        Args:
-            instruments: Set of instruments to warm up
-            channel: Control channel for sending warmup data
-            warmup_period: Period to warm up (e.g., "30d", "1000h")
-        """
-        for instrument in instruments:
-            trades = await self._exchange_manager.exchange.fetch_trades(
-                instrument.symbol, since=self._data_provider._time_msec_nbars_back(warmup_period)
-            )
-
-            logger.debug(f"<yellow>{self._exchange_id}</yellow> Loaded {len(trades)} trades for {instrument}")
-
-            channel.send(
-                (
-                    instrument,
-                    DataType.TRADE,
-                    [ccxt_convert_trade(trade) for trade in trades],
-                    True,  # historical data
-                )
-            )