Futures Stale Price Execution

Here are the substantive bugs present in your current code, why rollovers are being filled at stale prices, and direct fixes to realize realistic futures rolling for Palladium in QuantConnect:

1. Incorrect use of on_symbol_changed_events (Handler is Not Invoked)

• Bug: The method on_symbol_changed_events is not automatically invoked by LEAN. The actual symbol change events are available inside on_data via data.symbol_changed_events.
• Fix: Move your rollover logic to the on_data method, triggered when data.symbol_changed_events is present.

2. Market Orders on Mapping Change Are Filled at Stale Prices

• Bug: Immediate market orders on contract mapping changes (market_order(new_symbol, quantity, tag=tag)) often execute at settlement prices, outside of market hours, or in illiquid periods, especially for commodities like Palladium.
• Fix: Upon observing a mapping change event, defer your order until both the expiring and new contract have live (non-zero) volume and the market is open (regular trading hours).

3. Data Mapping Mode Set to LAST_TRADING_DAY Is Not Realistic for Live Rollovers

• Bug: Using DataMappingMode.LAST_TRADING_DAY causes the rollover to occur very late, often after most liquidity has shifted to the next contract, increasing slippage and stale fills.
• Fix: Use DataMappingMode.OPEN_INTEREST, which triggers roll when front-month liquidity is still adequate, better approximating real-world practice.

4. No Check for Live/Regular Trading Hours or Contract Volume

• Bug: Rolling as soon as the mapped contract event occurs, regardless of whether the market is open or whether the contracts are actively traded, results in unrealistic fills.
• Fix: Before rolling (liquidate old, buy new), check that the current timestamp is during regular trading hours, and that both old and new contracts have non-zero volume for the given timebar in data.bars.

5. Rollover Execution is Not Deferred — Race Condition

• Bug: Immediate execution can cause orders to be filled at unintended times due to async data arrival (bar vs. symbol event).
• Fix: Store a “pending rollover” state upon contract change, and execute both close and open orders on the first bar where both contracts are actively trading during market hours.

Example Fix Implementation

from AlgorithmImports import *
class RobustPalladiumRollover(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2021, 1, 1)
        self.set_cash(1_000_000)
        self._pending_roll = None
        self._future = self.add_future(
            Futures.Metals.PALLADIUM,
            extended_market_hours=False,  # only live trading hours
            data_mapping_mode=DataMappingMode.OPEN_INTEREST,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            contract_depth_offset=0)
        self._future.set_filter(0, 62)

    def on_data(self, data):
        # Check for symbol mapping change
        for _, change in data.symbol_changed_events.items():
            qty = int(self.portfolio[change.old_symbol].quantity)
            if qty:
                self._pending_roll = (change.old_symbol, change.new_symbol, qty)
                self._pending_roll_tag = (f"Rollover {self.time}: "
                                          f"{change.old_symbol} -> {change.new_symbol}")

        # Execute pending roll only when both contracts are trading & RTH
        if self._pending_roll:
            old_sym, new_sym, qty = self._pending_roll
            if (self._is_ready(data, old_sym) and self._is_ready(data, new_sym)):
                self.market_order(old_sym, -qty, tag=self._pending_roll_tag)
                self.market_order(new_sym, qty, tag=self._pending_roll_tag)
                self._pending_roll = None
                return

        # Initial entry, only launch in RTH with live volume
        if not self.portfolio.invested:
            mapped = self._future.mapped
            if self._is_ready(data, mapped):
                self.market_order(mapped, 1, tag="Initial entry")

    def _is_ready(self, data, symbol):
        bar = data.bars.get(symbol)
        return (bar and bar.volume > 0 and self.securities[symbol].exchange.is_open(self.time, False))

In Summary

• Don't immediately order in contract change events; defer rollover until both contracts are active and trading in liquid, regular market hours.
• Switch data mapping mode to OPEN_INTEREST.
• Process symbol_changed_events inside on_data.
• Check bar volume + is_open before any initial or rollover trade for fill quality.

By addressing these bugs, your algo’s fills and the resulting equity curve will much more closely track the true, investable Palladium futures returns, and not exhibit the artifact of “stale price” rollercoastering.

Sources: docs writing algorithms securities asset classes futures handling data, Basic Template Future Rollover Algorithm, Basic Template Eurex Futures Algorithm, docs writing algorithms securities asset classes futures requesting data universes, Futures - QuantConnect.com