Qubx 0.6.23__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.24__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/data.py

@@ -1,9 +1,6 @@
 from collections import defaultdict
-from typing import Any
 
-import numpy as np
 import pandas as pd
-from tqdm.auto import tqdm
 
 from qubx import logger
 from qubx.backtester.simulated_data import IterableSimulationData
@@ -13,7 +10,6 @@ from qubx.core.basics import (
     Instrument,
     TimestampedDict,
 )
-from qubx.core.exceptions import SimulationError
 from qubx.core.helpers import BasicScheduler
 from qubx.core.interfaces import IDataProvider
 from qubx.core.series import Bar, Quote, time_as_nsec
@@ -32,8 +28,6 @@ class SimulatedDataProvider(IDataProvider):
     _account: SimulatedAccountProcessor
     _last_quotes: dict[Instrument, Quote | None]
     _readers: dict[str, DataReader]
-    _pregenerated_signals: dict[Instrument, pd.Series | pd.DataFrame]
-    _to_process: dict[Instrument, list]
     _data_source: IterableSimulationData
     _open_close_time_indent_ns: int
 
@@ -45,6 +39,7 @@ class SimulatedDataProvider(IDataProvider):
         time_provider: SimulatedTimeProvider,
         account: SimulatedAccountProcessor,
         readers: dict[str, DataReader],
+        data_source: IterableSimulationData,
         open_close_time_indent_secs=1,
     ):
         self.channel = channel
@@ -54,79 +49,14 @@ class SimulatedDataProvider(IDataProvider):
         self._account = account
         self._readers = readers
 
-        # - create exchange's instance
-        self._last_quotes = defaultdict(lambda: None)
-
-        # - pregenerated signals storage
-        self._pregenerated_signals = dict()
-        self._to_process = {}
-
         # - simulation data source
-        self._data_source = IterableSimulationData(
-            self._readers, open_close_time_indent_secs=open_close_time_indent_secs
-        )
+        self._data_source = data_source
         self._open_close_time_indent_ns = open_close_time_indent_secs * 1_000_000_000  # convert seconds to nanoseconds
 
-        logger.info(f"{self.__class__.__name__}.{exchange_id} is initialized")
-
-    def run(
-        self,
-        start: str | pd.Timestamp,
-        end: str | pd.Timestamp,
-        silent: bool = False,
-    ) -> None:
-        logger.info(f"{self.__class__.__name__} ::: Simulation started at {start} :::")
-
-        if self._pregenerated_signals:
-            self._prepare_generated_signals(start, end)
-            _run = self._process_generated_signals
-        else:
-            _run = self._process_strategy
-
-        start, end = pd.Timestamp(start), pd.Timestamp(end)
-        total_duration = end - start
-        update_delta = total_duration / 100
-        prev_dt = pd.Timestamp(start)
-
-        # - date iteration
-        qiter = self._data_source.create_iterable(start, end)
-        if silent:
-            for instrument, data_type, event, is_hist in qiter:
-                if not _run(instrument, data_type, event, is_hist):
-                    break
-        else:
-            _p = 0
-            with tqdm(total=100, desc="Simulating", unit="%", leave=False) as pbar:
-                for instrument, data_type, event, is_hist in qiter:
-                    if not _run(instrument, data_type, event, is_hist):
-                        break
-                    dt = pd.Timestamp(event.time)
-                    # update only if date has changed
-                    if dt - prev_dt > update_delta:
-                        _p += 1
-                        pbar.n = _p
-                        pbar.refresh()
-                        prev_dt = dt
-                pbar.n = 100
-                pbar.refresh()
-
-        logger.info(f"{self.__class__.__name__} ::: Simulation finished at {end} :::")
-
-    def set_generated_signals(self, signals: pd.Series | pd.DataFrame):
-        logger.debug(
-            f"[<y>{self.__class__.__name__}</y>] :: Using pre-generated signals:\n {str(signals.count()).strip('ndtype: int64')}"
-        )
-        # - sanity check
-        signals.index = pd.DatetimeIndex(signals.index)
-
-        if isinstance(signals, pd.Series):
-            self._pregenerated_signals[str(signals.name)] = signals  # type: ignore
+        # - create exchange's instance
+        self._last_quotes = defaultdict(lambda: None)
 
-        elif isinstance(signals, pd.DataFrame):
-            for col in signals.columns:
-                self._pregenerated_signals[col] = signals[col]  # type: ignore
-        else:
-            raise ValueError("Invalid signals or strategy configuration")
+        logger.info(f"{self.__class__.__name__}.{exchange_id} is initialized")
 
     @property
     def is_simulation(self) -> bool:
@@ -200,26 +130,6 @@ class SimulatedDataProvider(IDataProvider):
     def close(self):
         pass
 
-    def _prepare_generated_signals(self, start: str | pd.Timestamp, end: str | pd.Timestamp):
-        for s, v in self._pregenerated_signals.items():
-            _s_inst = None
-
-            for i in self.get_subscribed_instruments():
-                # - we can process series with variable id's if we can find some similar instrument
-                if s == i.symbol or s == str(i) or s == f"{i.exchange}:{i.symbol}" or str(s) == str(i):
-                    _start, _end = pd.Timestamp(start), pd.Timestamp(end)
-                    _start_idx, _end_idx = v.index.get_indexer([_start, _end], method="ffill")
-                    sel = v.iloc[max(_start_idx, 0) : _end_idx + 1]
-
-                    # TODO: check if data has exec_price - it means we have deals
-                    self._to_process[i] = list(zip(sel.index, sel.values))
-                    _s_inst = i
-                    break
-
-            if _s_inst is None:
-                logger.error(f"Can't find instrument for pregenerated signals with id '{s}'")
-                raise SimulationError(f"Can't find instrument for pregenerated signals with id '{s}'")
-
     def _convert_records_to_bars(
         self, records: list[TimestampedDict], cut_time_ns: int, timeframe_ns: int
     ) -> list[Bar]:
@@ -252,44 +162,5 @@ class SimulatedDataProvider(IDataProvider):
 
         return bars
 
-    def _process_generated_signals(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
-        cc = self.channel
-        t = np.datetime64(data.time, "ns")
-
-        if not is_hist:
-            # - signals for this instrument
-            sigs = self._to_process[instrument]
-
-            while sigs and t >= (_signal_time := sigs[0][0].as_unit("ns").asm8):
-                self.time_provider.set_time(_signal_time)
-                cc.send((instrument, "event", {"order": sigs[0][1]}, False))
-                sigs.pop(0)
-
-            if q := self._account._exchange.emulate_quote_from_data(instrument, t, data):
-                self._last_quotes[instrument] = q
-
-        self.time_provider.set_time(t)
-        cc.send((instrument, data_type, data, is_hist))
-
-        return cc.control.is_set()
-
-    def _process_strategy(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
-        cc = self.channel
-        t = np.datetime64(data.time, "ns")
-
-        if not is_hist:
-            if t >= (_next_exp_time := self._scheduler.next_expected_event_time()):
-                # - we use exact event's time
-                self.time_provider.set_time(_next_exp_time)
-                self._scheduler.check_and_run_tasks()
-
-            if q := self._account._exchange.emulate_quote_from_data(instrument, t, data):
-                self._last_quotes[instrument] = q
-
-        self.time_provider.set_time(t)
-        cc.send((instrument, data_type, data, is_hist))
-
-        return cc.control.is_set()
-
     def exchange(self) -> str:
         return self._exchange_id.upper()

qubx/backtester/runner.py

@@ -2,14 +2,24 @@ from typing import Any
 
 import numpy as np
 import pandas as pd
+from tqdm.auto import tqdm
 
 from qubx import logger
-from qubx.core.basics import SW, DataType
+from qubx.backtester.simulated_data import IterableSimulationData
+from qubx.core.account import CompositeAccountProcessor
+from qubx.core.basics import SW, DataType, Instrument, TransactionCostsCalculator
 from qubx.core.context import StrategyContext
 from qubx.core.exceptions import SimulationConfigError, SimulationError
 from qubx.core.helpers import extract_parameters_from_object, full_qualified_class_name
 from qubx.core.initializer import BasicStrategyInitializer
-from qubx.core.interfaces import IMetricEmitter, IStrategy, IStrategyContext, StrategyState
+from qubx.core.interfaces import (
+    CtrlChannel,
+    IMetricEmitter,
+    IStrategy,
+    IStrategyContext,
+    ITimeProvider,
+    StrategyState,
+)
 from qubx.core.loggers import InMemoryLogsWriter, StrategyLogging
 from qubx.core.lookups import lookup
 from qubx.pandaz.utils import _frame_to_str
@@ -42,15 +52,22 @@ class SimulationRunner:
     account_id: str
     portfolio_log_freq: str
     ctx: IStrategyContext
-    data_provider: SimulatedDataProvider
     logs_writer: InMemoryLogsWriter
 
+    account: CompositeAccountProcessor
+    channel: CtrlChannel
+    time_provider: SimulatedTimeProvider
+    scheduler: SimulatedScheduler
     strategy_params: dict[str, Any]
     strategy_class: str
 
     # adjusted times
     _stop: pd.Timestamp | None = None
 
+    _data_source: IterableSimulationData
+    _data_providers: list[SimulatedDataProvider]
+    _exchange_to_data_provider: dict[str, SimulatedDataProvider]
+
     def __init__(
         self,
         setup: SimulationSetup,
@@ -84,7 +101,8 @@ class SimulationRunner:
         self.emitter = emitter
         self.strategy_state = strategy_state if strategy_state is not None else StrategyState()
         self.initializer = initializer
-        self.ctx = self._create_backtest_context()
+        self._pregenerated_signals = dict()
+        self._to_process = {}
 
         # - get strategy parameters BEFORE simulation start
         #   potentially strategy may change it's parameters during simulation
@@ -94,6 +112,8 @@ class SimulationRunner:
             self.strategy_params = extract_parameters_from_object(self.setup.generator)
             self.strategy_class = full_qualified_class_name(self.setup.generator)
 
+        self.ctx = self._create_backtest_context()
+
     def run(self, silent: bool = False, catch_keyboard_interrupt: bool = True, close_data_readers: bool = False):
         """
         Run the backtest from start to stop.
@@ -138,7 +158,7 @@ class SimulationRunner:
         stop = self._stop or self.stop
 
         try:
-            self.data_provider.run(self.start, stop, silent=silent)
+            self._run(self.start, stop, silent=silent)
         except KeyboardInterrupt:
             logger.error("Simulated trading interrupted by user!")
             if not catch_keyboard_interrupt:
@@ -147,10 +167,131 @@ class SimulationRunner:
             # Stop the context
             self.ctx.stop()
             if close_data_readers:
-                assert isinstance(self.data_provider, SimulatedDataProvider)
-                for reader in self.data_provider._readers.values():
-                    if hasattr(reader, "close"):
-                        reader.close()  # type: ignore
+                for dp in self._data_providers:
+                    for reader in dp._readers.values():
+                        if hasattr(reader, "close"):
+                            reader.close()  # type: ignore
+
+    def _set_generated_signals(self, signals: pd.Series | pd.DataFrame):
+        logger.debug(
+            f"[<y>{self.__class__.__name__}</y>] :: Using pre-generated signals:\n {str(signals.count()).strip('ndtype: int64')}"
+        )
+        # - sanity check
+        signals.index = pd.DatetimeIndex(signals.index)
+
+        if isinstance(signals, pd.Series):
+            self._pregenerated_signals[str(signals.name)] = signals  # type: ignore
+
+        elif isinstance(signals, pd.DataFrame):
+            for col in signals.columns:
+                self._pregenerated_signals[col] = signals[col]  # type: ignore
+        else:
+            raise ValueError("Invalid signals or strategy configuration")
+
+    def _prepare_generated_signals(self, start: str | pd.Timestamp, end: str | pd.Timestamp):
+        for s, v in self._pregenerated_signals.items():
+            _s_inst = None
+
+            for i in self._data_providers[0].get_subscribed_instruments():
+                # - we can process series with variable id's if we can find some similar instrument
+                if s == i.symbol or s == str(i) or s == f"{i.exchange}:{i.symbol}" or str(s) == str(i):
+                    _start, _end = pd.Timestamp(start), pd.Timestamp(end)
+                    _start_idx, _end_idx = v.index.get_indexer([_start, _end], method="ffill")
+                    sel = v.iloc[max(_start_idx, 0) : _end_idx + 1]
+
+                    # TODO: check if data has exec_price - it means we have deals
+                    self._to_process[i] = list(zip(sel.index, sel.values))
+                    _s_inst = i
+                    break
+
+            if _s_inst is None:
+                logger.error(f"Can't find instrument for pregenerated signals with id '{s}'")
+                raise SimulationError(f"Can't find instrument for pregenerated signals with id '{s}'")
+
+    def _process_generated_signals(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
+        cc = self.channel
+        t = np.datetime64(data.time, "ns")
+        _account = self.account.get_account_processor(instrument.exchange)
+        _data_provider = self._exchange_to_data_provider[instrument.exchange]
+        assert isinstance(_account, SimulatedAccountProcessor)
+        assert isinstance(_data_provider, SimulatedDataProvider)
+
+        if not is_hist:
+            # - signals for this instrument
+            sigs = self._to_process[instrument]
+
+            while sigs and t >= (_signal_time := sigs[0][0].as_unit("ns").asm8):
+                self.time_provider.set_time(_signal_time)
+                cc.send((instrument, "event", {"order": sigs[0][1]}, False))
+                sigs.pop(0)
+
+            if q := _account._exchange.emulate_quote_from_data(instrument, t, data):
+                _data_provider._last_quotes[instrument] = q
+
+        self.time_provider.set_time(t)
+        cc.send((instrument, data_type, data, is_hist))
+
+        return cc.control.is_set()
+
+    def _process_strategy(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
+        cc = self.channel
+        t = np.datetime64(data.time, "ns")
+        _account = self.account.get_account_processor(instrument.exchange)
+        _data_provider = self._exchange_to_data_provider[instrument.exchange]
+        assert isinstance(_account, SimulatedAccountProcessor)
+        assert isinstance(_data_provider, SimulatedDataProvider)
+
+        if not is_hist:
+            if t >= (_next_exp_time := self.scheduler.next_expected_event_time()):
+                # - we use exact event's time
+                self.time_provider.set_time(_next_exp_time)
+                self.scheduler.check_and_run_tasks()
+
+            if q := _account._exchange.emulate_quote_from_data(instrument, t, data):
+                _data_provider._last_quotes[instrument] = q
+
+        self.time_provider.set_time(t)
+        cc.send((instrument, data_type, data, is_hist))
+
+        return cc.control.is_set()
+
+    def _run(self, start: pd.Timestamp, stop: pd.Timestamp, silent: bool = False) -> None:
+        logger.info(f"{self.__class__.__name__} ::: Simulation started at {start} :::")
+
+        if self._pregenerated_signals:
+            self._prepare_generated_signals(start, stop)
+            _run = self._process_generated_signals
+        else:
+            _run = self._process_strategy
+
+        start, stop = pd.Timestamp(start), pd.Timestamp(stop)
+        total_duration = stop - start
+        update_delta = total_duration / 100
+        prev_dt = pd.Timestamp(start)
+
+        # - date iteration
+        qiter = self._data_source.create_iterable(start, stop)
+        if silent:
+            for instrument, data_type, event, is_hist in qiter:
+                if not _run(instrument, data_type, event, is_hist):
+                    break
+        else:
+            _p = 0
+            with tqdm(total=100, desc="Simulating", unit="%", leave=False) as pbar:
+                for instrument, data_type, event, is_hist in qiter:
+                    if not _run(instrument, data_type, event, is_hist):
+                        break
+                    dt = pd.Timestamp(event.time)
+                    # update only if date has changed
+                    if dt - prev_dt > update_delta:
+                        _p += 1
+                        pbar.n = _p
+                        pbar.refresh()
+                        prev_dt = dt
+                pbar.n = 100
+                pbar.refresh()
+
+        logger.info(f"{self.__class__.__name__} ::: Simulation finished at {stop} :::")
 
     def print_latency_report(self) -> None:
         _l_r = SW.latency_report()
@@ -164,47 +305,47 @@ class SimulationRunner:
             )
 
     def _create_backtest_context(self) -> IStrategyContext:
-        tcc = lookup.fees.find(self.setup.exchange.lower(), self.setup.commissions)
-        if tcc is None:
-            raise SimulationConfigError(
-                f"Can't find transaction costs calculator for '{self.setup.exchange}' for specification '{self.setup.commissions}' !"
-            )
-
-        channel = SimulatedCtrlChannel("databus", sentinel=(None, None, None, None))
-        simulated_clock = SimulatedTimeProvider(np.datetime64(self.start, "ns"))
-
         logger.debug(
-            f"[<y>simulator</y>] :: Preparing simulated trading on <g>{self.setup.exchange.upper()}</g> for {self.setup.capital} {self.setup.base_currency}..."
+            f"[<y>Simulator</y>] :: Preparing simulated trading on <g>{self.setup.exchanges}</g> "
+            f"for {self.setup.capital} {self.setup.base_currency}..."
         )
 
-        # - create simulated exchange:
-        #   - we can use different emulations of real exchanges features in future here: for Binance, Bybit, InteractiveBrokers, etc.
-        #   - for now we use simple basic simulated exchange implementation
-        simulated_exchange = get_simulated_exchange(
-            self.setup.exchange, simulated_clock, tcc, self.setup.accurate_stop_orders_execution
+        data_source = IterableSimulationData(
+            self.data_config.data_providers,
+            open_close_time_indent_secs=self.data_config.adjusted_open_close_time_indent_secs,
         )
 
-        account = SimulatedAccountProcessor(
-            account_id=self.account_id,
-            exchange=simulated_exchange,
-            channel=channel,
-            base_currency=self.setup.base_currency,
-            initial_capital=self.setup.capital,
+        channel = SimulatedCtrlChannel("databus", sentinel=(None, None, None, None))
+        simulated_clock = SimulatedTimeProvider(np.datetime64(self.start, "ns"))
+
+        account = self._construct_account_processor(
+            self.setup.exchanges, self.setup.commissions, simulated_clock, channel
         )
-        scheduler = SimulatedScheduler(channel, lambda: simulated_clock.time().item())
 
-        # - broker is order's interface to the exchange
-        broker = SimulatedBroker(channel, account, simulated_exchange)
+        scheduler = SimulatedScheduler(channel, lambda: simulated_clock.time().item())
 
-        data_provider = SimulatedDataProvider(
-            exchange_id=self.setup.exchange,
-            channel=channel,
-            scheduler=scheduler,
-            time_provider=simulated_clock,
-            account=account,
-            readers=self.data_config.data_providers,
-            open_close_time_indent_secs=self.data_config.adjusted_open_close_time_indent_secs,
-        )
+        brokers = []
+        for exchange in self.setup.exchanges:
+            _exchange_account = account.get_account_processor(exchange)
+            assert isinstance(_exchange_account, SimulatedAccountProcessor)
+            brokers.append(SimulatedBroker(channel, _exchange_account, _exchange_account._exchange))
+
+        data_providers = []
+        for exchange in self.setup.exchanges:
+            _exchange_account = account.get_account_processor(exchange)
+            assert isinstance(_exchange_account, SimulatedAccountProcessor)
+            data_providers.append(
+                SimulatedDataProvider(
+                    exchange_id=exchange,
+                    channel=channel,
+                    scheduler=scheduler,
+                    time_provider=simulated_clock,
+                    account=_exchange_account,
+                    readers=self.data_config.data_providers,
+                    data_source=data_source,
+                    open_close_time_indent_secs=self.data_config.adjusted_open_close_time_indent_secs,
+                )
+            )
 
         # - get aux data provider
         _aux_data = self.data_config.get_timeguarded_aux_reader(simulated_clock)
@@ -225,7 +366,10 @@ class SimulationRunner:
 
             case SetupTypes.SIGNAL:
                 strat = SignalsProxy(timeframe=self.setup.signal_timeframe)
-                data_provider.set_generated_signals(self.setup.generator)  # type: ignore
+                if len(data_providers) > 1:
+                    raise SimulationConfigError("Signal setup is not supported for multiple exchanges !")
+
+                self._set_generated_signals(self.setup.generator)  # type: ignore
 
                 # - we don't need any unexpected triggerings
                 self._stop = min(self.setup.generator.index[-1], self.stop)  # type: ignore
@@ -233,7 +377,10 @@ class SimulationRunner:
             case SetupTypes.SIGNAL_AND_TRACKER:
                 strat = SignalsProxy(timeframe=self.setup.signal_timeframe)
                 strat.tracker = lambda ctx: self.setup.tracker
-                data_provider.set_generated_signals(self.setup.generator)  # type: ignore
+                if len(data_providers) > 1:
+                    raise SimulationConfigError("Signal setup is not supported for multiple exchanges !")
+
+                self._set_generated_signals(self.setup.generator)  # type: ignore
 
                 # - we don't need any unexpected triggerings
                 self._stop = min(self.setup.generator.index[-1], self.stop)  # type: ignore
@@ -246,8 +393,8 @@ class SimulationRunner:
 
         ctx = StrategyContext(
             strategy=strat,
-            broker=broker,
-            data_provider=data_provider,
+            brokers=brokers,
+            data_providers=data_providers,
             account=account,
             scheduler=scheduler,
             time_provider=simulated_clock,
@@ -274,6 +421,64 @@ class SimulationRunner:
             logger.debug(f"[<y>simulator</y>] :: Setting default schedule: {self.data_config.default_trigger_schedule}")
             ctx.set_event_schedule(self.data_config.default_trigger_schedule)
 
-        self.data_provider = data_provider
         self.logs_writer = logs_writer
+        self.channel = channel
+        self.time_provider = simulated_clock
+        self.account = account
+        self.scheduler = scheduler
+        self._data_source = data_source
+        self._data_providers = data_providers
+        self._exchange_to_data_provider = {dp.exchange(): dp for dp in data_providers}
         return ctx
+
+    def _construct_tcc(
+        self, exchanges: list[str], commissions: str | dict[str, str | None] | None
+    ) -> dict[str, TransactionCostsCalculator]:
+        _exchange_to_tcc = {}
+        if isinstance(commissions, (str, type(None))):
+            commissions = {e: commissions for e in exchanges}
+        for exchange in exchanges:
+            _exchange_to_tcc[exchange] = lookup.fees.find(exchange.lower(), commissions.get(exchange))
+        return _exchange_to_tcc
+
+    def _construct_account_processor(
+        self,
+        exchanges: list[str],
+        commissions: str | dict[str, str | None] | None,
+        time_provider: ITimeProvider,
+        channel: CtrlChannel,
+    ) -> CompositeAccountProcessor:
+        _exchange_to_tcc = self._construct_tcc(exchanges, commissions)
+        for tcc in _exchange_to_tcc.values():
+            if tcc is None:
+                raise SimulationConfigError(
+                    f"Can't find transaction costs calculator for '{self.setup.exchanges}' for specification '{self.setup.commissions}' !"
+                )
+
+        _exchange_to_simulated_exchange = {}
+        for exchange in self.setup.exchanges:
+            # - create simulated exchange:
+            #   - we can use different emulations of real exchanges features in future here: for Binance, Bybit, InteractiveBrokers, etc.
+            #   - for now we use simple basic simulated exchange implementation
+            _exchange_to_simulated_exchange[exchange] = get_simulated_exchange(
+                exchange, time_provider, _exchange_to_tcc[exchange], self.setup.accurate_stop_orders_execution
+            )
+
+        _account_processors = {}
+        for exchange in self.setup.exchanges:
+            _initial_capital = self.setup.capital
+            if isinstance(_initial_capital, dict):
+                _initial_capital = _initial_capital[exchange]
+            assert isinstance(_initial_capital, (float, int))
+            _account_processors[exchange] = SimulatedAccountProcessor(
+                account_id=self.account_id,
+                exchange=_exchange_to_simulated_exchange[exchange],
+                channel=channel,
+                base_currency=self.setup.base_currency,
+                initial_capital=_initial_capital,
+            )
+
+        return CompositeAccountProcessor(
+            time_provider=time_provider,
+            account_processors=_account_processors,
+        )

qubx/backtester/simulator.py

@@ -30,9 +30,9 @@ from .utils import (
 def simulate(
     strategies: StrategiesDecls_t,
     data: DataDecls_t,
-    capital: float,
+    capital: float | dict[str, float],
     instruments: list[SymbolOrInstrument_t] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
-    commissions: str | None,
+    commissions: str | dict[str, str | None] | None,
     start: str | pd.Timestamp,
     stop: str | pd.Timestamp | None = None,
     exchange: ExchangeName_t | None = None,
@@ -95,29 +95,20 @@ def simulate(
         )
         raise SimulationError(_msg)
 
-    # - check if instruments are from the same exchange (mmulti-exchanges is not supported yet)
-    if len(_exchanges) > 1:
-        logger.error(
-            _msg := f"Multiple exchanges found: {', '.join(_exchanges)} - this mode is not supported yet in Qubx !"
-        )
-        raise SimulationError(_msg)
-
-    exchange = _exchanges[0]
-
     # - recognize provided data
-    data_setup = recognize_simulation_data_config(data, _instruments, exchange, open_close_time_indent_secs, aux_data)
+    data_setup = recognize_simulation_data_config(data, _instruments, open_close_time_indent_secs, aux_data)
 
     # - recognize setup: it can be either a strategy or set of signals
     simulation_setups = recognize_simulation_configuration(
-        "",
-        strategies,
-        _instruments,
-        exchange,
-        capital,
-        base_currency,
-        commissions,
-        signal_timeframe,
-        accurate_stop_orders_execution,
+        name="",
+        configs=strategies,
+        instruments=_instruments,
+        exchanges=_exchanges,
+        capital=capital,
+        basic_currency=base_currency,
+        commissions=commissions,
+        signal_timeframe=signal_timeframe,
+        accurate_stop_orders_execution=accurate_stop_orders_execution,
     )
     if not simulation_setups:
         logger.error(
@@ -232,7 +223,7 @@ def _run_setup(
         setup.name,
         start,
         stop,
-        setup.exchange,
+        setup.exchanges,
         setup.instruments,
         setup.capital,
         setup.base_currency,