Liquidating distribution plus delisting liquidation double-counts the position in Raw-mode backtests

[AlexCatarino]

Expected Behavior

When an equity pays a cash distribution and is delisted without trading again afterwards (a dissolution's liquidating distribution, a cash-out at delisting), the backtest portfolio should recognise the position's value once: the distribution arrives as cash, and the engine's delisting liquidation releases only whatever residual value is left.

Actual Behavior

The position's value is counted twice. In Raw (and SplitAdjusted) mode the dividend is credited as cash while the holding's quantity and mark are left unchanged; because the security never prints another bar, the mark stays at the last pre-distribution trade. The Liquidate from delisting market order then fills at that stale security.Price on the delisting date, so the whole position value is realised a second time.

Reproduction (cloud LEAN v2.5.0.0.18122, master 7d534a1), one equity, no leverage, minute resolution, DataNormalizationMode.Raw, MACK (Merrimack Pharmaceuticals; last trading session 2024-05-17, dividend and map-file delisting date 2024-05-20):

2024-05-17 16:05 EOD      qty=56468 secprice=15.13 holdvalue=854360.84 cash=151003.62  tpv=1005364.46
2024-05-20 00:00 DIVIDEND dist=15.1 ref=15.13 qty=56468 secprice=15.13 holdvalue=854360.84 cash=1003670.42 tpv=1858031.26
2024-05-20 00:00 DELISTING type=WARNING
2024-05-21 00:00 FILL     qty=-56468 px=15.13 tag='Liquidate from delisting'            cash=1858031.26 tpv=1858031.26
2024-05-21 00:00 DELISTING type=DELISTED

The distribution (56,468 x 15.10 = 852,666.80) is added to cash on 05-20 while holdvalue stays 854,360.84; the liquidation on 05-21 then converts that unchanged holding value into cash at 15.13. Net effect: tpv goes from 1,005,364 to 1,858,031 on a position that was worth 854,361 and paid out 852,667. The economically correct end state is about 1,007,000 (cash 151,004 + distribution 852,667 + a residual of ~0.03/share).

Reproducing algorithm

Python, cloud backtest; the log lines above are its output.

from AlgorithmImports import *

class MackDelistingDistributionRepro(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2024, 5, 1)
        self.set_end_date(2024, 5, 31)
        self.set_cash(1_000_000)
        self._sym = self.add_equity("MACK", Resolution.MINUTE,
                                    data_normalization_mode=DataNormalizationMode.RAW).symbol
        self._entered = False
        self.schedule.on(self.date_rules.every_day(), self.time_rules.at(16, 5), self._eod)

    def _state(self):
        h = self.portfolio[self._sym]
        return (f"qty={h.quantity} avg={h.average_price} secprice={self.securities[self._sym].price} "
                f"holdvalue={h.holdings_value:.2f} cash={self.portfolio.cash:.2f} "
                f"tpv={self.portfolio.total_portfolio_value:.2f}")

    def on_data(self, slice):
        if not self._entered and self.time.date() >= date(2024, 5, 6) and self._sym in slice.bars:
            self.set_holdings(self._sym, 0.85)
            self._entered = True
        if slice.dividends.contains_key(self._sym):
            d = slice.dividends[self._sym]
            self.log(f"DIVIDEND {self.time} dist={d.distribution} ref={d.reference_price} {self._state()}")
        if slice.delistings.contains_key(self._sym):
            dl = slice.delistings[self._sym]
            self.log(f"DELISTING {self.time} type={dl.type} evprice={dl.price} {self._state()}")

    def on_order_event(self, e):
        if e.status == OrderStatus.FILLED:
            o = self.transactions.get_order_by_id(e.order_id)
            self.log(f"FILL {self.time} qty={e.fill_quantity} px={e.fill_price} tag='{o.tag}' {self._state()}")

    def _eod(self):
        self.log(f"EOD {self.time.date()} {self._state()}")

    def on_end_of_algorithm(self):
        for d in self.history[Dividend](self._sym, datetime(2024, 4, 1), datetime(2024, 6, 30)):
            self.log(f"HIST DIVIDEND end={d.end_time} dist={d.distribution} ref={d.reference_price}")
        for d in self.history[Delisting](self._sym, datetime(2024, 4, 1), datetime(2024, 6, 30)):
            self.log(f"HIST DELISTING end={d.end_time} type={d.type} price={d.price}")
        for b in self.history[TradeBar](self._sym, datetime(2024, 5, 13), datetime(2024, 5, 24), Resolution.DAILY):
            self.log(f"HIST DAILY end={b.end_time} o={b.open} h={b.high} l={b.low} c={b.close} v={b.volume}")
        self.log(f"FINAL {self._state()}")

Where it happens

• Common/Securities/SecurityPortfolioManager.cs#L789-L809 (ApplyDividend): credits Quantity * Distribution to cash and records the dividend on the holding, but does not touch the security's cached price. In Raw mode the price drop is expected to arrive with the next bar, which never comes for a security that stops trading at the same time.
• Engine/TransactionHandlers/BrokerageTransactionHandler.cs#L1566-L1605 (HandleDelistingNotification): fills the liquidation at security.Price (L1598), the last cached trade, with no awareness that a distribution has been paid on the same holding since that price was cached.
• Engine/DataFeeds/Enumerators/DelistingEventProvider.cs#L96-L104: the Delisted event is emitted on the tradable day after the delisting date, so the dividend (ex-date = delisting date) is always applied first.

Compare with splits, where the engine does keep the cached mark consistent: SecurityPortfolioManager.ApplySplit (L856) calls Security.ApplySplit -> SecurityCache.ApplySplit (Common/Securities/SecurityCache.cs#L623), which rescales Price/OHLC/bid/ask and the cached BaseData. There is no dividend counterpart.

Proposed change

Mirror the split handling for cash dividends in Raw/SplitAdjusted backtests: after crediting the cash in ApplyDividend, adjust the security's cached last data (Price, Open, High, Low, Close, BidPrice, AskPrice, and the cached BaseData instances) down by dividend.Distribution, floored at zero, e.g. a Security.ApplyDividend(Dividend) / SecurityCache.ApplyDividend(Dividend) pair. The next real bar overwrites the adjustment, so ordinary dividends are unaffected beyond the midnight-to-open window (where the current behaviour also briefly overstates TotalPortfolioValue by the dividend amount); for a security that never prints again, the delisting liquidation fills at the ex-distribution price and the double count disappears.

A narrower alternative is to have HandleDelistingNotification subtract the distributions applied since the last price update from the fill price, but that leaves the same stale mark visible in Portfolio.TotalPortfolioValue between the two events.

Open question: whether SplitAdjusted should receive the same cache adjustment (it receives the cash today).

Checklist

• I have completely filled out this template
• I have confirmed that this issue exists on the current master branch
• I have confirmed that this is not a duplicate issue by searching issues
• I have provided detailed steps to reproduce the issue

Support conversation: 215476063836125

[oyeong011]

I independently reproduced the stale-price liquidation path on current master b1337938bacbdcdf7327ba4c6a10ffa89ffac403 using a small synthetic C# component driver, built against the actual LEAN Engine project under .NET 10.0.401 / Linux arm64.

The fixture seeds cash 1000 and 10 shares priced at 100, then calls the real ApplyDividend with distribution 90. It invokes the real HandleDelistingNotification with a DelistingNotificationEventArgs and records the fill generated by that upstream handler and the resulting portfolio state.

Mode	Price refreshed before delisting	Dividend cash credited	Fill price	Final cash
Raw	No	900	100	2900
Raw	Yes, synthetic 10	900	10	2000
SplitAdjusted	No	900	100	2900
SplitAdjusted	Yes, synthetic 10	900	10	2000
Adjusted	No / Yes at unchanged normalized 100	0	100	2000

All scenarios start with portfolio value 2000 and finish with zero quantity. I invalidate total portfolio value before snapshots to exclude that cache as an explanation. This also corroborates the described behavior in SplitAdjusted at this component boundary.

Limitations: this does not replay the full data feed, factor/map files, original MACK data, or the scheduling that delivers the notification. The fresh price is an explicit contrastive input; the Adjusted row is a no-cash-dividend control, not a claim of economic equivalence between raw and adjusted histories. No fix or full upstream test suite was tested.

The complete dataset-free driver is included below. AI assisted the setup and analysis; the observations above come from executed upstream code. This is corroboration of your existing report, not a separate issue.

The portfolio value already increases at the dividend stage, while the cached holding mark remains 100. The delisting handler then turns that stale mark into cash; the fill itself does not produce a second increase in total portfolio value. The final 2900 is 900 above the synthetic price-10 comparison, not a universal residual-value claim.

Complete synthetic component driver and run setup

On a checkout of b1337938bacbdcdf7327ba4c6a10ffa89ffac403, save these two files together. The driver intentionally mounts the checkout at /lean and its own files at /evidence in a .NET 10 SDK container. It uses a null data feed and creates no brokerage connection or market-data request.

LeanAudit.csproj:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="/evidence/Program.cs" />
    <ProjectReference Include="/lean/Engine/QuantConnect.Lean.Engine.csproj" />
  </ItemGroup>
</Project>

Program.cs:

using System;
using System.Globalization;
using System.Reflection;
using QuantConnect;
using QuantConnect.Algorithm;
using QuantConnect.Brokerages;
using QuantConnect.Brokerages.Backtesting;
using QuantConnect.Configuration;
using QuantConnect.Data.Market;
using QuantConnect.Lean.Engine.DataFeeds;
using QuantConnect.Lean.Engine.Results;
using QuantConnect.Lean.Engine.TransactionHandlers;
using QuantConnect.Securities;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
Config.Set("data-folder", "/lean/Data");
Config.Set("transaction-handler-exit-timeout", "1");
foreach (var mode in new[] { DataNormalizationMode.Raw, DataNormalizationMode.SplitAdjusted, DataNormalizationMode.Adjusted })
foreach (var freshPrice in new[] { false, true })
{
    var algorithm = new QCAlgorithm();
    algorithm.SetCash(1000);
    algorithm.UniverseSettings.DataNormalizationMode = mode;
    var marketHours = MarketHoursDatabase.FromDataFolder();
    var securityService = new SecurityService(algorithm.Portfolio.CashBook, marketHours,
        SymbolPropertiesDatabase.FromDataFolder(), algorithm, RegisteredSecurityDataTypesProvider.Null,
        new SecurityCacheProvider(algorithm.Portfolio), algorithm: algorithm);
    var permission = new DataPermissionManager();
    using var provider = new DefaultDataProvider();
    var universe = new UniverseSelection(algorithm, securityService, permission, provider);
    var manager = new DataManager(new NullDataFeed(), universe, algorithm,
        new TimeKeeper(new DateTime(2024, 5, 17), TimeZones.NewYork), marketHours,
        false, RegisteredSecurityDataTypesProvider.Null, permission);
    algorithm.Securities.SetSecurityService(securityService);
    algorithm.SubscriptionManager.SetDataManager(manager);
    var symbol = new Symbol(SecurityIdentifier.GenerateEquity("SPY", Market.USA, mapSymbol: false), "SPY");
    var security = algorithm.AddSecurity(symbol, dataNormalizationMode: mode);
    var time = new DateTime(2024, 5, 17, 16, 0, 0);
    algorithm.SetDateTime(time);
    algorithm.SetFinishedWarmingUp();
    algorithm.SetStatus(AlgorithmStatus.Running);
    security.SetMarketPrice(new TradeBar(time, security.Symbol, 100, 100, 100, 100, 1));
    security.Holdings.SetHoldings(100, 10);
    using var brokerage = new BacktestingBrokerage(algorithm);
    var handler = new BrokerageTransactionHandler();
    handler.Initialize(algorithm, brokerage, new BacktestingResultHandler());
    algorithm.Transactions.SetOrderProcessor(handler);
    void Snapshot(string stage)
    {
        algorithm.Portfolio.InvalidateTotalPortfolioValue();
        Console.WriteLine($"OBS,{mode},{freshPrice},{stage},{algorithm.Portfolio.Cash},{security.Holdings.Quantity},{security.Price},{security.Holdings.HoldingsValue},{algorithm.Portfolio.TotalPortfolioValue}");
    }
    try
    {
        Snapshot("initial");
        algorithm.SetDateTime(time.AddDays(3));
        algorithm.Portfolio.ApplyDividend(new Dividend(security.Symbol, time.AddDays(3), 90, 100), false, mode);
        Snapshot("dividend");
        if (freshPrice)
        {
            var price = mode == DataNormalizationMode.Adjusted ? 100m : 10m;
            security.SetMarketPrice(new TradeBar(time.AddDays(3), security.Symbol, price, price, price, price, 1));
        }
        Snapshot("before_delist");
        algorithm.SetDateTime(time.AddDays(4));
        var method = typeof(BrokerageTransactionHandler).GetMethod("HandleDelistingNotification", BindingFlags.NonPublic | BindingFlags.Instance)
            ?? throw new InvalidOperationException("Upstream delisting method not found");
        method.Invoke(handler, new object[] { new DelistingNotificationEventArgs(security.Symbol) });
        Snapshot("after_delist");
        if (security.Holdings.Quantity != 0) throw new Exception("Delisting did not liquidate holdings");
        foreach (var fill in handler.OrderEvents)
            Console.WriteLine($"FILL,{mode},{freshPrice},{fill.FillQuantity},{fill.FillPrice},{fill.Status}");
    }
    finally { handler.Exit(); }
}

With Docker and the .NET 10 SDK available:

# Run from the checked-out LEAN root; the repro directory holds the two files above.
repro_dir=/absolute/path/to/repro-directory
docker run --rm \
  -v "$PWD:/lean" -v "$repro_dir:/evidence" \
  mcr.microsoft.com/dotnet/sdk:10.0 \
  sh -lc 'dotnet run --project /evidence/LeanAudit.csproj'

The actual validation used .NET 10.0.401 on Linux arm64 and repeated the six cases in an independent process with identical observations. A full Engine data feed and notification scheduling path were not run.

[oyeong011]

I extended my synthetic check from direct component calls to the real AlgorithmManager.Run dispatch path on master b1337938bacbdcdf7327ba4c6a10ffa89ffac403. A small ISynchronizer supplies the time slices (with the upstream test MockDataFeed for subscriptions); BacktestingTransactionHandler and BacktestingBrokerage handle the delisting. This version does not use reflection or call ApplyDividend directly.

In Raw mode, both runs receive one Dividend, Warning then Delisted, and one actual fill. Without a new bar, cash/TPV rises from 2000 to 2900 at the Dividend callback and the later liquidation fills 10 shares at cached price 100. With an explicit price-10 bar between those events, TPV returns to 2000 and the liquidation fills at 10. On the Delisted slice, OnOrderEvent(Filled) is delivered before OnDelistings(Delisted); the latter sees quantity zero. A second process reproduced both callback sequences and amounts.

This corroborates the reported timing at the manager/transaction boundary. The synthetic stream supplies the corporate-action dates and prices, so it does not validate map/factor-file scheduling, fill-forward, or the original MACK data. The optional post-backtest results analysis is disabled for this fixture. No fix or PR is proposed; AI assistance helped prepare the harness, and the observations are from executing the upstream components.