Qubx 0.6.63__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.65__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/data.py

@@ -68,6 +68,10 @@ class SimulatedDataProvider(IDataProvider):
 
         # - provide historical data and last quote for subscribed instruments
         for i in _new_instr:
+            # Check if the instrument was actually subscribed (not filtered out)
+            if not self.has_subscription(i, subscription_type):
+                continue
+
             h_data = self._data_source.peek_historical_data(i, subscription_type)
             if h_data:
                 # _s_type = DataType.from_str(subscription_type)[0]
@@ -119,7 +123,7 @@ class SimulatedDataProvider(IDataProvider):
         end = start - nbarsback * (_timeframe := pd.Timedelta(timeframe))
         _spec = f"{instrument.exchange}:{instrument.symbol}"
         return self._convert_records_to_bars(
-            _reader.read(data_id=_spec, start=start, stop=end, transform=AsDict()),  # type: ignore
+            _reader.read(data_id=_spec, start=start, stop=end, timeframe=timeframe, transform=AsDict()),  # type: ignore
             time_as_nsec(self.time_provider.time()),
             _timeframe.asm8.item(),
         )

qubx/backtester/ome.py

@@ -6,17 +6,17 @@ from sortedcontainers import SortedDict
 
 from qubx import logger
 from qubx.core.basics import (
+    OPTION_AVOID_STOP_ORDER_PRICE_VALIDATION,
     OPTION_FILL_AT_SIGNAL_PRICE,
     OPTION_SIGNAL_PRICE,
     OPTION_SKIP_PRICE_CROSS_CONTROL,
-    OPTION_AVOID_STOP_ORDER_PRICE_VALIDATION,
     Deal,
     Instrument,
     ITimeProvider,
     Order,
     OrderSide,
-    OrderType,
     OrderStatus,
+    OrderType,
     TransactionCostsCalculator,
     dt_64,
 )
@@ -208,7 +208,9 @@ class OrdersManagementEngine:
         **options,
     ) -> SimulatedExecutionReport:
         if self.bbo is None:
-            raise ExchangeError(f"Simulator is not ready for order management - no quote for {self.instrument.symbol}")
+            raise SimulationError(
+                f"Simulator is not ready for order management - no quote for {self.instrument.symbol}"
+            )
 
         # - validate order parameters
         self._validate_order(order_side, order_type, amount, price, time_in_force, options)

qubx/backtester/runner.py

@@ -422,6 +422,10 @@ 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)
 
+        if self.setup.enable_funding:
+            logger.debug("[<y>simulator</y>] :: Enabling funding rate simulation")
+            ctx.subscribe(DataType.FUNDING_PAYMENT)
+
         self.logs_writer = logs_writer
         self.channel = channel
         self.time_provider = simulated_clock

qubx/backtester/simulated_data.py

@@ -3,11 +3,12 @@ from typing import Any, Iterator
 import pandas as pd
 
 from qubx import logger
-from qubx.core.basics import DataType, Instrument, Timestamped
+from qubx.core.basics import DataType, Instrument, MarketType, Timestamped
 from qubx.core.exceptions import SimulationError
 from qubx.data.composite import IteratedDataStreamsSlicer
 from qubx.data.readers import (
     AsDict,
+    AsFundingPayments,
     AsOrderBook,
     AsQuotes,
     AsTrades,
@@ -87,6 +88,11 @@ class DataFetcher:
                 self._producing_data_type = "orderbook"
                 self._transformer = AsOrderBook()
 
+            case DataType.FUNDING_PAYMENT:
+                self._requested_data_type = "funding_payment"
+                self._producing_data_type = "funding_payment"
+                self._transformer = AsFundingPayments()
+
             case _:
                 self._requested_data_type = subtype
                 self._producing_data_type = subtype
@@ -250,10 +256,48 @@ class IterableSimulationData(Iterator):
                 _access_key = f"{_subtype}"
         return _access_key, _subtype, _params
 
+    def _filter_instruments_for_subscription(self, data_type: str, instruments: list[Instrument]) -> list[Instrument]:
+        """
+        Filter instruments based on subscription type requirements.
+
+        For funding payment subscriptions, only SWAP instruments are supported since
+        funding payments are specific to perpetual swap contracts.
+
+        Args:
+            data_type: The data type being subscribed to
+            instruments: List of instruments to filter
+
+        Returns:
+            Filtered list of instruments appropriate for the subscription type
+        """
+        # Only funding payments require special filtering
+        if data_type == DataType.FUNDING_PAYMENT:
+            original_count = len(instruments)
+            filtered_instruments = [i for i in instruments if i.market_type == MarketType.SWAP]
+            filtered_count = len(filtered_instruments)
+
+            # Log if instruments were filtered out (debug info)
+            if filtered_count < original_count:
+                logger.debug(
+                    f"Filtered {original_count - filtered_count} non-SWAP instruments from funding payment subscription"
+                )
+
+            return filtered_instruments
+
+        # For all other subscription types, return instruments unchanged
+        return instruments
+
     def add_instruments_for_subscription(self, subscription: str, instruments: list[Instrument] | Instrument):
         instruments = instruments if isinstance(instruments, list) else [instruments]
         _subt_key, _data_type, _params = self._parse_subscription_spec(subscription)
 
+        # Filter instruments based on subscription type requirements
+        instruments = self._filter_instruments_for_subscription(_data_type, instruments)
+
+        # If no instruments remain after filtering, skip subscription
+        if not instruments:
+            return
+
         fetcher = self._subtyped_fetchers.get(_subt_key)
         if not fetcher:
             _reader = self._readers.get(_data_type)

qubx/backtester/simulator.py

@@ -4,12 +4,13 @@ import pandas as pd
 from joblib import delayed
 
 from qubx import QubxLogConfig, logger
+from qubx.backtester.utils import SetupTypes
+from qubx.core.basics import Instrument
 from qubx.core.exceptions import SimulationError
 from qubx.core.metrics import TradingSessionResult
 from qubx.data.readers import DataReader
+from qubx.emitters.inmemory import InMemoryMetricEmitter
 from qubx.utils.misc import ProgressParallel, Stopwatch, get_current_user
-from qubx.utils.runner.configs import EmissionConfig
-from qubx.utils.runner.factory import create_metric_emitters
 from qubx.utils.time import handle_start_stop
 
 from .runner import SimulationRunner
@@ -31,11 +32,11 @@ def simulate(
     strategies: StrategiesDecls_t,
     data: DataDecls_t,
     capital: float | dict[str, float],
-    instruments: list[SymbolOrInstrument_t] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
+    instruments: list[str] | list[Instrument] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
     commissions: str | dict[str, str | None] | None,
     start: str | pd.Timestamp,
     stop: str | pd.Timestamp | None = None,
-    exchange: ExchangeName_t | None = None,
+    exchange: ExchangeName_t | list[ExchangeName_t] | None = None,
     base_currency: str = "USDT",
     n_jobs: int = 1,
     silent: bool = False,
@@ -43,11 +44,13 @@ def simulate(
     accurate_stop_orders_execution: bool = False,
     signal_timeframe: str = "1Min",
     open_close_time_indent_secs=1,
+    enable_funding: bool = False,
     debug: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "WARNING",
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
-    emission: EmissionConfig | None = None,
+    enable_inmemory_emitter: bool = False,
+    emitter_stats_interval: str = "1h",
     run_separate_instruments: bool = False,
 ) -> list[TradingSessionResult]:
     """
@@ -69,11 +72,13 @@ def simulate(
         - accurate_stop_orders_execution (bool): If True, enables more accurate stop order execution simulation.
         - signal_timeframe (str): Timeframe for signals, default is "1Min".
         - open_close_time_indent_secs (int): Time indent in seconds for open/close times, default is 1.
+        - enable_funding (bool): If True, enables funding rate simulation, default is False.
         - debug (Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None): Logging level for debugging.
         - show_latency_report: If True, shows simulator's latency report.
         - portfolio_log_freq (str): Frequency for portfolio logging, default is "5Min".
         - parallel_backend (Literal["loky", "multiprocessing"]): Backend for parallel processing, default is "multiprocessing".
-        - emission (EmissionConfig | None): Configuration for metric emitters, default is None.
+        - enable_inmemory_emitter (bool): If True, attaches an in-memory metric emitter and returns its dataframe in TradingSessionResult.emitter_data.
+        - emitter_stats_interval (str): Interval for emitting stats in the in-memory emitter (default: "1h").
         - run_separate_instruments (bool): If True, creates separate simulation setups for each instrument, default is False.
 
     Returns:
@@ -112,6 +117,7 @@ def simulate(
         signal_timeframe=signal_timeframe,
         accurate_stop_orders_execution=accurate_stop_orders_execution,
         run_separate_instruments=run_separate_instruments,
+        enable_funding=enable_funding,
     )
     if not simulation_setups:
         logger.error(
@@ -143,7 +149,8 @@ def simulate(
         show_latency_report=show_latency_report,
         portfolio_log_freq=portfolio_log_freq,
         parallel_backend=parallel_backend,
-        emission=emission,
+        enable_inmemory_emitter=enable_inmemory_emitter,
+        emitter_stats_interval=emitter_stats_interval,
     )
 
 
@@ -157,7 +164,8 @@ def _run_setups(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
-    emission: EmissionConfig | None = None,
+    enable_inmemory_emitter: bool = False,
+    emitter_stats_interval: str = "1h",
 ) -> list[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -179,7 +187,8 @@ def _run_setups(
                 silent,
                 show_latency_report,
                 portfolio_log_freq,
-                emission,
+                enable_inmemory_emitter,
+                emitter_stats_interval,
             )
             for id, setup in enumerate(strategies_setups)
         ]
@@ -197,7 +206,9 @@ def _run_setups(
                 silent,
                 show_latency_report,
                 portfolio_log_freq,
-                emission,
+                enable_inmemory_emitter,
+                emitter_stats_interval,
+                close_data_readers=True,
             )
             for id, setup in enumerate(strategies_setups)
         )
@@ -213,6 +224,20 @@ def _run_setups(
     return successful_reports
 
 
+def _adjust_start_date_for_min_instrument_onboard(setup: SimulationSetup, start: pd.Timestamp) -> pd.Timestamp:
+    """
+    Adjust the start date for the simulation to the onboard date of the instrument with the minimum onboard date.
+    """
+    onboard_dates = [
+        pd.Timestamp(instrument.onboard_date).replace(tzinfo=None)
+        for instrument in setup.instruments
+        if instrument.onboard_date is not None
+    ]
+    if not onboard_dates:
+        return start
+    return max(start, min(onboard_dates))
+
+
 def _run_setup(
     setup_id: int,
     account_id: str,
@@ -223,13 +248,19 @@ def _run_setup(
     silent: bool,
     show_latency_report: bool,
     portfolio_log_freq: str,
-    emission: EmissionConfig | None = None,
+    enable_inmemory_emitter: bool = False,
+    emitter_stats_interval: str = "1h",
+    close_data_readers: bool = False,
 ) -> TradingSessionResult | None:
     try:
-        # Create metric emitter if configured
         emitter = None
-        if emission is not None:
-            emitter = create_metric_emitters(emission, setup.name)
+        emitter_data = None
+        if enable_inmemory_emitter:
+            emitter = InMemoryMetricEmitter(stats_interval=emitter_stats_interval)
+
+        # TODO: this can be removed once we add some artificial data stream to move the simulation
+        if setup.setup_type in [SetupTypes.SIGNAL, SetupTypes.SIGNAL_AND_TRACKER]:
+            start = _adjust_start_date_for_min_instrument_onboard(setup, start)
 
         runner = SimulationRunner(
             setup=setup,
@@ -246,7 +277,7 @@ def _run_setup(
             level=QubxLogConfig.get_log_level(), custom_formatter=SimulatedLogFormatter(runner.ctx).formatter
         )
 
-        runner.run(silent=silent)
+        runner.run(silent=silent, close_data_readers=close_data_readers)
 
         # - service latency report
         if show_latency_report:
@@ -258,6 +289,9 @@ def _run_setup(
             # Filter out None values to match TradingSessionResult expected type
             commissions_for_result = {k: v for k, v in commissions_for_result.items() if v is not None}
 
+        if enable_inmemory_emitter and emitter is not None:
+            emitter_data = emitter.get_dataframe()
+
         return TradingSessionResult(
             setup_id,
             setup.name,
@@ -276,6 +310,7 @@ def _run_setup(
             parameters=runner.strategy_params,
             is_simulation=True,
             author=get_current_user(),
+            emitter_data=emitter_data,
         )
     except Exception as e:
         logger.error(f"Simulation setup {setup_id} failed with error: {e}")

qubx/backtester/utils.py

@@ -90,6 +90,7 @@ class SimulationSetup:
     commissions: str | dict[str, str | None] | None = None
     signal_timeframe: str = "1Min"
     accurate_stop_orders_execution: bool = False
+    enable_funding: bool = False
 
     def __str__(self) -> str:
         return f"{self.name} {self.setup_type} capital {self.capital} {self.base_currency} for [{','.join(map(lambda x: x.symbol, self.instruments))}] @ {self.exchanges}[{self.commissions}]"
@@ -213,38 +214,81 @@ class SignalsProxy(IStrategy):
         return None
 
 
+def _process_single_symbol_or_instrument(
+    symbol_or_instrument: SymbolOrInstrument_t,
+    default_exchange: ExchangeName_t | None,
+    requested_exchange: ExchangeName_t | None,
+) -> tuple[Instrument | None, str | None]:
+    """
+    Process a single symbol or instrument and return the resolved instrument and exchange.
+
+    Returns:
+        tuple[Instrument | None, str | None]: (instrument, exchange) or (None, None) if processing failed
+    """
+    match symbol_or_instrument:
+        case str():
+            _e, _s = (
+                symbol_or_instrument.split(":")
+                if ":" in symbol_or_instrument
+                else (default_exchange, symbol_or_instrument)
+            )
+
+            if _e is None:
+                logger.warning(
+                    f"Can't extract exchange name from symbol's spec ({symbol_or_instrument}) and exact exchange name is not provided - skip this symbol !"
+                )
+                return None, None
+
+            if (
+                requested_exchange is not None
+                and isinstance(requested_exchange, str)
+                and _e.lower() != requested_exchange.lower()
+            ):
+                logger.warning(
+                    f"Exchange from symbol's spec ({_e}) is different from requested: {requested_exchange} !"
+                )
+
+            if (instrument := lookup.find_symbol(_e, _s)) is not None:
+                return instrument, _e.upper()
+            else:
+                logger.warning(f"Can't find instrument for specified symbol ({symbol_or_instrument}) - ignoring !")
+                return None, None
+
+        case Instrument():
+            return symbol_or_instrument, symbol_or_instrument.exchange
+
+        case _:
+            raise SimulationConfigError(
+                f"Unsupported type for {symbol_or_instrument} only str or Instrument instances are allowed!"
+            )
+
+
 def find_instruments_and_exchanges(
     instruments: list[SymbolOrInstrument_t] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
-    exchange: ExchangeName_t | None,
+    exchange: ExchangeName_t | list[ExchangeName_t] | None,
 ) -> tuple[list[Instrument], list[ExchangeName_t]]:
     _instrs: list[Instrument] = []
-    _exchanges = [] if exchange is None else [exchange]
-    for i in instruments:
-        match i:
-            case str():
-                _e, _s = i.split(":") if ":" in i else (exchange, i)
-                assert _e is not None
+    _exchanges = [] if exchange is None else [exchange] if isinstance(exchange, str) else exchange
 
-                if exchange is not None and _e.lower() != exchange.lower():
-                    logger.warning("Exchange from symbol's spec ({_e}) is different from requested: {exchange} !")
+    # Handle dictionary case where instruments is {exchange: [symbols]}
+    if isinstance(instruments, dict):
+        for exchange_name, symbol_list in instruments.items():
+            if exchange_name not in _exchanges:
+                _exchanges.append(exchange_name)
 
-                if _e is None:
-                    logger.warning(
-                        "Can't extract exchange name from symbol's spec ({_e}) and exact exchange name is not provided - skip this symbol !"
-                    )
-
-                if (ix := lookup.find_symbol(_e, _s)) is not None:
-                    _exchanges.append(_e.upper())
-                    _instrs.append(ix)
-                else:
-                    logger.warning(f"Can't find instrument for specified symbol ({i}) - ignoring !")
+            for symbol in symbol_list:
+                instrument, resolved_exchange = _process_single_symbol_or_instrument(symbol, exchange_name, exchange)
+                if instrument is not None and resolved_exchange is not None:
+                    _instrs.append(instrument)
+                    _exchanges.append(resolved_exchange)
 
-            case Instrument():
-                _exchanges.append(i.exchange)
-                _instrs.append(i)
-
-            case _:
-                raise SimulationConfigError(f"Unsupported type for {i} only str or Instrument instances are allowed!")
+    # Handle list case
+    else:
+        for symbol in instruments:
+            instrument, resolved_exchange = _process_single_symbol_or_instrument(symbol, exchange, exchange)
+            if instrument is not None and resolved_exchange is not None:
+                _instrs.append(instrument)
+                _exchanges.append(resolved_exchange)
 
     return _instrs, list(set(_exchanges))
 
@@ -420,6 +464,7 @@ def recognize_simulation_configuration(
     signal_timeframe: str,
     accurate_stop_orders_execution: bool,
     run_separate_instruments: bool = False,
+    enable_funding: bool = False,
 ) -> list[SimulationSetup]:
     """
     Recognize and create setups based on the provided simulation configuration.
@@ -440,6 +485,7 @@ def recognize_simulation_configuration(
     - signal_timeframe (str): Timeframe for generated signals.
     - accurate_stop_orders_execution (bool): If True, enables more accurate stop order execution simulation.
     - run_separate_instruments (bool): If True, creates separate setups for each instrument.
+    - enable_funding (bool): If True, enables funding rate simulation, default is False.
 
     Returns:
     - list[SimulationSetup]: A list of SimulationSetup objects, each representing a
@@ -460,7 +506,8 @@ def recognize_simulation_configuration(
             r.extend(
                 recognize_simulation_configuration(
                     _n + n, v, instruments, exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution, run_separate_instruments
+                    signal_timeframe, accurate_stop_orders_execution, run_separate_instruments,
+                    enable_funding
                 )
             )
 
@@ -481,12 +528,14 @@ def recognize_simulation_configuration(
             if run_separate_instruments:
                 # Create separate setups for each instrument
                 for instrument in setup_instruments:
+                    _s1 = c1[instrument.symbol] if isinstance(_s, pd.DataFrame) else _s
                     r.append(
                         SimulationSetup(
-                            _t, f"{name}/{instrument.symbol}", _s, c1,   # type: ignore
+                            _t, f"{name}/{instrument.symbol}", _s1, c1,   # type: ignore
                             [instrument],
                             exchanges, capital, basic_currency, commissions, 
-                            signal_timeframe, accurate_stop_orders_execution
+                            signal_timeframe, accurate_stop_orders_execution,
+                            enable_funding
                         )
                     )
             else:
@@ -495,7 +544,8 @@ def recognize_simulation_configuration(
                         _t, name, _s, c1,   # type: ignore
                         setup_instruments,
                         exchanges, capital, basic_currency, commissions, 
-                        signal_timeframe, accurate_stop_orders_execution
+                        signal_timeframe, accurate_stop_orders_execution,
+                        enable_funding
                     )
                 )
         else:
@@ -504,7 +554,8 @@ def recognize_simulation_configuration(
                     recognize_simulation_configuration(
                         # name + "/" + str(j), s, instruments, exchange, capital, basic_currency, commissions
                         name, s, instruments, exchanges, capital, basic_currency, commissions,  # type: ignore
-                        signal_timeframe, accurate_stop_orders_execution, run_separate_instruments
+                        signal_timeframe, accurate_stop_orders_execution, run_separate_instruments,
+                        enable_funding
                     )
                 )
 
@@ -517,7 +568,8 @@ def recognize_simulation_configuration(
                         SetupTypes.STRATEGY,
                         f"{name}/{instrument.symbol}", configs, None, [instrument],
                         exchanges, capital, basic_currency, commissions, 
-                        signal_timeframe, accurate_stop_orders_execution
+                        signal_timeframe, accurate_stop_orders_execution,
+                        enable_funding
                     )
                 )
         else:
@@ -526,7 +578,8 @@ def recognize_simulation_configuration(
                     SetupTypes.STRATEGY,
                     name, configs, None, instruments,
                     exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution
+                    signal_timeframe, accurate_stop_orders_execution,
+                    enable_funding
                 )
             )
 
@@ -538,12 +591,14 @@ def recognize_simulation_configuration(
         if run_separate_instruments:
             # Create separate setups for each instrument
             for instrument in setup_instruments:
+                _c1 = c1[instrument.symbol] if isinstance(c1, pd.DataFrame) else c1
                 r.append(
                     SimulationSetup(
                         SetupTypes.SIGNAL,
-                        f"{name}/{instrument.symbol}", c1, None, [instrument],
+                        f"{name}/{instrument.symbol}", _c1, None, [instrument],
                         exchanges, capital, basic_currency, commissions, 
-                        signal_timeframe, accurate_stop_orders_execution
+                        signal_timeframe, accurate_stop_orders_execution,
+                        enable_funding
                     )
                 )
         else:
@@ -552,7 +607,8 @@ def recognize_simulation_configuration(
                     SetupTypes.SIGNAL,
                     name, c1, None, setup_instruments,
                     exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution
+                    signal_timeframe, accurate_stop_orders_execution,
+                    enable_funding
                 )
             )
 

qubx/core/account.py

@@ -7,6 +7,7 @@ from qubx.core.basics import (
     ZERO_COSTS,
     AssetBalance,
     Deal,
+    FundingPayment,
     Instrument,
     ITimeProvider,
     Order,
@@ -104,8 +105,11 @@ class BasicAccountProcessor(IAccountProcessor):
     ########################################################
     def get_leverage(self, instrument: Instrument) -> float:
         pos = self._positions.get(instrument)
+        capital = self.get_total_capital()
+        if np.isclose(capital, 0):
+            return 0.0
         if pos is not None:
-            return pos.notional_value / self.get_total_capital()
+            return pos.notional_value / capital
         return 0.0
 
     def get_leverages(self, exchange: str | None = None) -> dict[Instrument, float]:
@@ -234,6 +238,36 @@ class BasicAccountProcessor(IAccountProcessor):
                         self._balances[self.base_currency] -= fee_in_base
                         self._balances[instrument.settle] += realized_pnl
 
+    def process_funding_payment(self, instrument: Instrument, funding_payment: FundingPayment) -> None:
+        """Process funding payment for an instrument.
+
+        Args:
+            instrument: Instrument the funding payment applies to
+            funding_payment: Funding payment event to process
+        """
+        pos = self._positions.get(instrument)
+
+        if pos is None or not instrument.is_futures():
+            return
+
+        # Get current market price for funding calculation
+        # We need to get the mark price from the market data, but since we don't have access
+        # to market data here, we'll use the current position price as a reasonable fallback
+        mark_price = pos.position_avg_price_funds if pos.position_avg_price_funds > 0 else 0.0
+
+        # Apply funding payment to position
+        funding_amount = pos.apply_funding_payment(funding_payment, mark_price)
+
+        # Update account balance with funding payment
+        # For futures contracts, funding affects the settlement currency balance
+        self._balances[instrument.settle] += funding_amount
+
+        logger.debug(
+            f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: "
+            f"funding payment {funding_amount:.6f} {instrument.settle} "
+            f"(rate: {funding_payment.funding_rate:.6f})"
+        )
+
     def _fill_missing_fee_info(self, instrument: Instrument, deals: list[Deal]) -> None:
         for d in deals:
             if d.fee_amount is None:
@@ -354,16 +388,48 @@ class CompositeAccountProcessor(IAccountProcessor):
         return self._account_processors[exch].get_capital()
 
     def get_total_capital(self, exchange: str | None = None) -> float:
-        exch = self._get_exchange(exchange)
-        return self._account_processors[exch].get_total_capital()
+        if exchange is not None:
+            # Return total capital from specific exchange
+            exch = self._get_exchange(exchange)
+            return self._account_processors[exch].get_total_capital()
+
+        # Return aggregated total capital from all exchanges when no exchange is specified
+        total_capital = 0.0
+        for exch_name, processor in self._account_processors.items():
+            total_capital += processor.get_total_capital()
+        return total_capital
 
     def get_balances(self, exchange: str | None = None) -> dict[str, AssetBalance]:
-        exch = self._get_exchange(exchange)
-        return self._account_processors[exch].get_balances()
+        if exchange is not None:
+            # Return balances from specific exchange
+            exch = self._get_exchange(exchange)
+            return self._account_processors[exch].get_balances()
+
+        # Return aggregated balances from all exchanges when no exchange is specified
+        all_balances: dict[str, AssetBalance] = defaultdict(lambda: AssetBalance())
+        for exch_name, processor in self._account_processors.items():
+            exch_balances = processor.get_balances()
+            for currency, balance in exch_balances.items():
+                if currency not in all_balances:
+                    all_balances[currency] = AssetBalance(balance.free, balance.locked, balance.total)
+                else:
+                    all_balances[currency].free += balance.free
+                    all_balances[currency].locked += balance.locked
+                    all_balances[currency].total += balance.total
+        return dict(all_balances)
 
     def get_positions(self, exchange: str | None = None) -> dict[Instrument, Position]:
-        exch = self._get_exchange(exchange)
-        return self._account_processors[exch].get_positions()
+        if exchange is not None:
+            # Return positions from specific exchange
+            exch = self._get_exchange(exchange)
+            return self._account_processors[exch].get_positions()
+
+        # Return positions from all exchanges when no exchange is specified
+        all_positions: dict[Instrument, Position] = {}
+        for exch_name, processor in self._account_processors.items():
+            exch_positions = processor.get_positions()
+            all_positions.update(exch_positions)
+        return all_positions
 
     def get_position(self, instrument: Instrument) -> Position:
         exch = self._get_exchange(instrument=instrument)
@@ -455,3 +521,7 @@ class CompositeAccountProcessor(IAccountProcessor):
     def process_deals(self, instrument: Instrument, deals: list[Deal]) -> None:
         exch = self._get_exchange(instrument=instrument)
         self._account_processors[exch].process_deals(instrument, deals)
+
+    def process_funding_payment(self, instrument: Instrument, funding_payment: FundingPayment) -> None:
+        exch = self._get_exchange(instrument=instrument)
+        self._account_processors[exch].process_funding_payment(instrument, funding_payment)