Qubx 0.6.62__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.64__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/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,9 +256,45 @@ 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:

qubx/backtester/simulator.py

@@ -4,12 +4,12 @@ import pandas as pd
 from joblib import delayed
 
 from qubx import QubxLogConfig, logger
+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 +31,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,
@@ -47,7 +47,8 @@ def simulate(
     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]:
     """
@@ -73,7 +74,8 @@ def simulate(
         - 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:
@@ -143,7 +145,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 +160,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 +183,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 +202,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)
         )
@@ -223,14 +229,14 @@ 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",
 ) -> 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)
         runner = SimulationRunner(
             setup=setup,
             data_config=data_setup,
@@ -258,6 +264,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 +285,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

@@ -213,38 +213,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))
 

qubx/core/account.py

@@ -7,6 +7,7 @@ from qubx.core.basics import (
     ZERO_COSTS,
     AssetBalance,
     Deal,
+    FundingPayment,
     Instrument,
     ITimeProvider,
     Order,
@@ -104,18 +105,23 @@ 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]:
         return {s: self.get_leverage(s) for s in self._positions.keys()}
 
     def get_net_leverage(self, exchange: str | None = None) -> float:
-        return sum(self.get_leverages(exchange).values())
+        leverages = self.get_leverages(exchange).values()
+        return sum(lev for lev in leverages if lev is not None and not np.isnan(lev))
 
     def get_gross_leverage(self, exchange: str | None = None) -> float:
-        return sum(map(abs, self.get_leverages(exchange).values()))
+        leverages = self.get_leverages(exchange).values()
+        return sum(abs(lev) for lev in leverages if lev is not None and not np.isnan(lev))
 
     ########################################################
     # Margin information
@@ -232,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:
@@ -352,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)
@@ -453,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)

qubx/core/basics.py

@@ -44,6 +44,30 @@ class FundingRate:
     index_price: float | None = None
 
 
+@dataclass
+class FundingPayment:
+    """
+    Represents a funding payment for a perpetual swap position.
+    
+    Based on QuestDB schema: timestamp, symbol, funding_rate, funding_interval_hours
+    """
+    time: dt_64
+    symbol: str
+    funding_rate: float
+    funding_interval_hours: int
+    
+    def __post_init__(self):
+        # Validation logic
+        if not self.symbol or self.symbol.strip() == '':
+            raise ValueError("Symbol cannot be empty")
+        
+        if abs(self.funding_rate) > 1.0:
+            raise ValueError(f"Invalid funding rate: {self.funding_rate} (must be between -1.0 and 1.0)")
+        
+        if self.funding_interval_hours <= 0:
+            raise ValueError(f"Invalid funding interval: {self.funding_interval_hours} (must be positive)")
+
+
 @dataclass
 class TimestampedDict:
     """
@@ -69,7 +93,7 @@ class ITimeProvider:
 
 
 # Alias for timestamped data types used in Qubx
-Timestamped: TypeAlias = Quote | Trade | Bar | OrderBook | TimestampedDict | FundingRate | Liquidation
+Timestamped: TypeAlias = Quote | Trade | Bar | OrderBook | TimestampedDict | FundingRate | Liquidation | FundingPayment
 
 
 @dataclass
@@ -548,6 +572,11 @@ class Position:
     # margin requirements
     maint_margin: float = 0.0
 
+    # funding payment tracking
+    cumulative_funding: float = 0.0  # cumulative funding paid (negative) or received (positive)
+    funding_payments: list[FundingPayment]  # history of funding payments
+    last_funding_time: dt_64 = np.datetime64('NaT')  # last funding payment time
+
     # - helpers for position processing
     _qty_multiplier: float = 1.0
     __pos_incr_qty: float = 0
@@ -560,6 +589,7 @@ class Position:
         r_pnl: float = 0.0,
     ) -> None:
         self.instrument = instrument
+        self.funding_payments = []  # Initialize funding payments list
 
         self.reset()
         if quantity != 0.0 and pos_average_price > 0.0:
@@ -584,6 +614,9 @@ class Position:
         self.last_update_price = np.nan
         self.last_update_conversion_rate = np.nan
         self.maint_margin = 0.0
+        self.cumulative_funding = 0.0
+        self.funding_payments = []
+        self.last_funding_time = np.datetime64('NaT')  # type: ignore
         self.__pos_incr_qty = 0
         self._qty_multiplier = self.instrument.contract_size
 
@@ -600,6 +633,9 @@ class Position:
         self.last_update_price = pos.last_update_price
         self.last_update_conversion_rate = pos.last_update_conversion_rate
         self.maint_margin = pos.maint_margin
+        self.cumulative_funding = pos.cumulative_funding
+        self.funding_payments = pos.funding_payments.copy() if hasattr(pos, 'funding_payments') else []
+        self.last_funding_time = pos.last_funding_time if hasattr(pos, 'last_funding_time') else np.datetime64('NaT')
         self.__pos_incr_qty = pos.__pos_incr_qty
 
     @property
@@ -731,6 +767,51 @@ class Position:
             return self.quantity * (self.last_update_price - self.position_avg_price) / self.last_update_conversion_rate  # type: ignore
         return 0.0
 
+    def apply_funding_payment(self, funding_payment: FundingPayment, mark_price: float) -> float:
+        """
+        Apply a funding payment to this position.
+        
+        For perpetual swaps:
+        - Positive funding rate: longs pay shorts
+        - Negative funding rate: shorts pay longs
+        
+        Args:
+            funding_payment: The funding payment event
+            mark_price: The mark price at the time of funding
+            
+        Returns:
+            The funding amount (negative if paying, positive if receiving)
+        """
+        if abs(self.quantity) < self.instrument.min_size:
+            return 0.0
+            
+        # Calculate funding amount
+        # Funding = Position Size * Mark Price * Funding Rate
+        funding_amount = self.quantity * mark_price * funding_payment.funding_rate
+        
+        # For long positions with positive funding rate, amount is negative (paying)
+        # For short positions with positive funding rate, amount is positive (receiving)
+        funding_amount = -funding_amount
+        
+        # Update position state
+        self.cumulative_funding += funding_amount
+        self.r_pnl += funding_amount  # Funding affects realized PnL
+        self.pnl += funding_amount    # And total PnL
+        
+        # Track funding payment history (limit to last 100)
+        self.funding_payments.append(funding_payment)
+        if len(self.funding_payments) > 100:
+            self.funding_payments = self.funding_payments[-100:]
+            
+        self.last_funding_time = funding_payment.time
+        
+        return funding_amount
+
+    def get_funding_pnl(self) -> float:
+        """Get cumulative funding PnL for this position."""
+        return self.cumulative_funding
+
+
     def is_open(self) -> bool:
         return abs(self.quantity) > self.instrument.min_size
 
@@ -833,6 +914,7 @@ class DataType(StrEnum):
     ORDERBOOK = "orderbook"
     LIQUIDATION = "liquidation"
     FUNDING_RATE = "funding_rate"
+    FUNDING_PAYMENT = "funding_payment"
     OHLC_QUOTES = "ohlc_quotes"  # when we want to emulate quotes from OHLC data
     OHLC_TRADES = "ohlc_trades"  # when we want to emulate trades from OHLC data
     RECORD = "record"  # arbitrary timestamped data (actually liquidation and funding rates fall into this type)
@@ -966,14 +1048,20 @@ class InstrumentsLookup:
         self,
         exchange: str,
         base: str,
-        quote: str,
+        quote: str | None = None,
         settle: str | None = None,
         market_type: MarketType | None = None,
     ) -> Instrument | None:
         for i in self.get_lookup().values():
             if (
                 i.exchange == exchange
-                and ((i.base == base and i.quote == quote) or (i.base == quote and i.quote == base))
+                and (
+                    (
+                        quote is not None
+                        and ((i.base == base and i.quote == quote) or (i.base == quote and i.quote == base))
+                    )
+                    or (quote is None and i.base == base)
+                )
                 and (market_type is None or i.market_type == market_type)
             ):
                 if settle is not None and i.settle is not None:
@@ -997,6 +1085,7 @@ class InstrumentsLookup:
     def find_instruments(
         self,
         exchange: str,
+        base: str | None = None,
         quote: str | None = None,
         market_type: MarketType | None = None,
         as_of: str | pd.Timestamp | None = None,
@@ -1005,6 +1094,7 @@ class InstrumentsLookup:
         Find instruments by exchange, quote, market type and as of date.
         If as_of is not None, then only instruments that are not delisted after as_of date will be returned.
         - exchange: str - exchange name
+        - base: str | None - base currency
         - quote: str | None - quote currency
         - market_type: MarketType | None - market type
         - as_of is a string in format YYYY-MM-DD or pd.Timestamp or None
@@ -1014,8 +1104,12 @@ class InstrumentsLookup:
             i
             for i in self.get_lookup().values()
             if i.exchange == exchange
+            and (
+                base is None or (i.base == base or i.base == f"1000{base}")
+            )  # this is a hack to support 1000DOGEUSDT and others
             and (quote is None or i.quote == quote)
             and (market_type is None or i.market_type == market_type)
+            and (i.onboard_date is not None and pd.Timestamp(i.onboard_date).tz_localize(None) <= _limit_time)
             and (
                 _limit_time is None
                 or (i.delist_date is None)