Wait for fresh data before filling market orders on stale data (#9563)

* Wait for first session bar before filling equity market orders at open

EquityFillModel.MarketFill could fill a market order placed right after
market open using data from the previous trading date, because the first
bar of the current session has not been emitted yet. ShouldWaitForFreshData
only covered hour/daily resolutions, so minute/second orders filled on stale
prices.

Add IsWithinFirstResolutionSpanAfterMarketOpen: when the order time is within
the lowest subscribed resolution span after the open and the price is stale,
wait for the first bar instead of filling on the previous date's price.

* Share opening-bar stale-fill wait across fill models

Move IsWithinFirstResolutionSpanAfterMarketOpen to the base FillModel and add
a ShouldWaitForFreshDataOnStale sibling helper that combines it with the
existing coarse-resolution ShouldWaitForFreshData check. The base FillModel,
FutureFillModel and EquityFillModel market fills now share this single wait
decision at their stale-data guards.

ShouldWaitForFreshData is intentionally left untouched at its GetMarketFillPrice
call site, which uses it to choose the bar open vs current price and is not
gated by staleness, so fill prices for finer resolutions are unchanged. The
opening-bar helper is guarded against always-open markets, which have no
session open to wait for.

* Add regression algorithm for stale fill at market open

Reproduces the opening-bar stale fill issue: a market order placed one second
after the open while subscribed to minute resolution. Without the fix the order
fills on the previous trading date's stale price; the algorithm asserts in
OnOrderEvent that a fill never happens within the first minute after the open,
so it errors without the fix and passes with it.

Uses SPY minute data over 2013-10-07 to 2013-10-11, which is available in the
repository Data folder.

* Add unit tests for stale fill wait at market open

Cover the opening-bar stale fill scenario directly at the fill model level:
a market order placed within the first bar after the session open, while only
the previous session's stale bar is available, must wait instead of filling on
the stale price, and fills once the first session bar arrives. EquityFillModel
also asserts the boundary (orders past the first bar still fill on stale data),
and FutureFillModel covers the shared base helper from the future path.

* Generalize stale market-order fill wait to any time of day

Replace the market-open-specific wait with a generic check: a market order
that would be filled on stale data waits for fresh data when the latest
available data is more than one subscribed resolution bar behind the current
time. This no longer considers the market open explicitly; it covers the
opening bar (the first session bar has not been emitted yet) and any intraday
data gap larger than the resolution.

ShouldWaitForFreshDataOnStale now takes the latest data end time and the
current time instead of the order time, and is shared by FillModel,
FutureFillModel and EquityFillModel. Coarse resolutions (hour/daily) still
always wait; tick never waits. Internal configurations are included when
sizing the resolution bar. EquityFillModel's best-effort price helpers now
report the stale data end time so the gap can be measured.

Tests: EquityFillModelTests and FutureFillModelTests cover the market-open and
mid-session stale cases (wait then fill on fresh data) plus the within-one-bar
boundary (fill on stale). The regression algorithm is generalized to assert no
fill happens on data staler than the resolution, with orders at the open and
mid-session. Pre-existing plumbing/data-selection tests that used degenerate
timestamps were given fresh timestamps so they still exercise their original
intent.

* Add sample data and adjust regression algorithms for stale-fill wait

Add minute/daily sample data so market orders that now wait for fresh data
can fill (ES futures gap days, TWX/GOOG equities and options, SPXW weeklies,
GC futures/options copy for 2020-01-06). Adjust a few regression algorithms
to the deferred-fill behavior: cap orders in the extended-market continuous
future test, ignore daily-resolution SPY in the automatic-seed data checks,
and refresh OptionAssignmentStatistics expected constants.

* Update regression expected statistics for stale-fill wait

Regenerate ExpectedStatistics, DataPoints and AlgorithmHistoryDataPoints for
the regression algorithms affected by the wait-for-fresh-data fill change and
the added sample data: futures/options fill-timing shifts, ES data-point count
increases, and GOOG 2015-12-28 outcome changes.

* Trim SPXW sample data to expiries within filter window

The two SPXW algorithms filter with Expiration(0,7), so contracts expiring
more than a week out are never subscribed. Drop those far-dated expiries from
the 2021-01-06/08 minute files (760KB->108KB and 776KB->108KB on the quote
files). Fills, DataPoints and statistics are unchanged; both regression tests
still pass.

* Trim ES minute and GOOG option sample data to order-fill minimum

The ES minute gap-day files source no order fills (daily-resolution algos fill
from es_daily); keep only the front contract used for execution and drop the
unused back-month contracts. Trim the GOOG 2015-12-28 option file (no fill
depends on it) to the morning chain window. Regenerate the back-month futures
statistics affected by the dropped back-month bars. Full CSharp regression
suite passes (722/722).

* Use SMA gap threshold in BasicTemplateContinuousFuture for C#/Python parity

At a fast/slow SMA cross the two averages can coincide to within rounding
noise, where the C# (decimal) and Python (double) comparisons disagree,
producing different orders between languages. Require a minimum gap before
acting on a cross so both languages stay in lockstep, and update the shared
expected statistics accordingly.

* Mirror order cap in Python algorithm and update future history counts

Apply the same pre-2013-11-12/3-order cap to the Python
BasicTemplateContinuousFutureWithExtendedMarket algorithm for C#/Python parity,
and update the QuantBook future-history expected counts to reflect the added ES
sample data.

* Use SMA gap threshold in BasicTemplateContinuousFutureWithExtendedMarket for C#/Python parity

This algorithm had the same fast/slow SMA cross divergence already fixed in
BasicTemplateContinuousFutureAlgorithm (ad8fc33): at the 2013-10-29 cross the two
averages coincide to within rounding noise (C# decimal diff -1e-25, Python double
diff exactly 0.0), so the raw `_fast > _slow` / `_fast < _slow` comparisons disagree
between languages. C# fired a liquidate+rebuild that Python skipped, producing 5
orders in C# vs 3 in Python. Require a minimum 0.001 gap before acting on a cross so
both languages stay in lockstep, and regenerate the shared expected statistics
(Total Orders 5 -> 3).

* Document SMA cross threshold as a C#/Python parity workaround

Add a short note before the fast/slow SMA comparisons in both continuous-future
template algorithms clarifying that the minimum-gap threshold exists only so the
C# and Python versions take the exact same trades on the limited sample data in
the repository, where decimal vs double rounding can disagree at a cross.

* Fetch subscription configs once per equity market fill

MarketFill resolved the subscription configs twice per fill: once via the
best-effort price helpers (GetSubscribedTypes) and again via
ShouldWaitForFreshDataOnStale. Fetch them once and thread them through both
paths via optional parameters, leaving existing callers unchanged.

* Measure stale-fill wait against order submission time

ShouldWaitForFreshDataOnStale compared the latest data end time against the
security current time. Compare against the order submission time instead so the
decision to wait for fresh data reflects how stale the data is relative to when
the order was placed. Realign the stale-price warning fill test accordingly.

* Fix stale market data in SendingNewOrderFromOnOrderEvent test

The market price tick was timestamped a day before the order submission time,
so under the order-time staleness check the market orders waited for fresh data
instead of filling. Use a reference time with the tick one minute before the
order so the data is fresh and the orders fill.

* Centralize internal-inclusive subscription config lookup in fill models

ShouldWaitForFreshDataOnStale re-resolved the subscription configs through
the ShouldWaitForFreshData call it makes first, and GetMarketFillPrice did
the same. Thread the already-fetched configs through ShouldWaitForFreshData
and GetMarketFillPrice so each market fill resolves them at most once.

Add a GetSubscriptionDataConfigs(Security) helper on the base FillModel that
returns the internal-inclusive configs, and route every fill-model call site
through it to remove the duplicated lookup and repeated comment.

* Avoid list allocation in ShouldWaitForFreshData

Replace the Where(...).ToList() + All(...) with a single foreach over the
subscription configs, short-circuiting on the first non-coarse resolution.

Author: jhonabreul

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -135,33 +135,33 @@ public override void OnData(Slice slice)
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Orders", "3"},
-            {"Average Win", "2.73%"},
+            {"Average Win", "2.67%"},
             {"Average Loss", "-2.98%"},
-            {"Compounding Annual Return", "-4.619%"},
-            {"Drawdown", "0.300%"},
-            {"Expectancy", "-0.042"},
+            {"Compounding Annual Return", "-5.432%"},
+            {"Drawdown", "0.400%"},
+            {"Expectancy", "-0.052"},
             {"Start Equity", "100000"},
-            {"End Equity", "99668"},
-            {"Net Profit", "-0.332%"},
-            {"Sharpe Ratio", "-4.614"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0.427%"},
+            {"End Equity", "99608"},
+            {"Net Profit", "-0.392%"},
+            {"Sharpe Ratio", "-5.487"},
+            {"Sortino Ratio", "-2.607"},
+            {"Probabilistic Sharpe Ratio", "0.016%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "0.92"},
-            {"Alpha", "-0.022"},
-            {"Beta", "-0.012"},
+            {"Profit-Loss Ratio", "0.90"},
+            {"Alpha", "-0.028"},
+            {"Beta", "-0.01"},
             {"Annual Standard Deviation", "0.005"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.823"},
+            {"Information Ratio", "-2.949"},
             {"Tracking Error", "0.049"},
-            {"Treynor Ratio", "2.01"},
+            {"Treynor Ratio", "3.063"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$5700000.00"},
             {"Lowest Capacity Asset", "AOL VRKS95ENPM9Y|AOL R735QTJ8XC9X"},
-            {"Portfolio Turnover", "0.55%"},
+            {"Portfolio Turnover", "0.54%"},
             {"Drawdown Recovery", "0"},
-            {"OrderListHash", "d314aef81752b6583fd58f9e49054cd4"}
+            {"OrderListHash", "65d9c6a5991648c8c54a23423a51340d"}
         };
     }
 }

Algorithm.CSharp/AutomaticSeedBaseRegressionAlgorithm.cs

@@ -31,14 +31,17 @@ public abstract class AutomaticSeedBaseRegressionAlgorithm : QCAlgorithm, IRegre
         protected virtual bool ShouldHaveTradeData { get; }
         protected virtual bool ShouldHaveQuoteData { get; }
         protected virtual bool ShouldHaveOpenInterestData { get; }
+        protected virtual List<string> SecuritiesToIgnoreForChecking => Enumerable.Empty<string>().ToList();
 
         public override void OnSecuritiesChanged(SecurityChanges changes)
         {
             var gotTrades = false;
             var gotQuotes = false;
             var gotOpenInterest = false;
 
-            foreach (var addedSecurity in changes.AddedSecurities.Where(x => !x.Symbol.IsCanonical() || x.Symbol.SecurityType == SecurityType.Future))
+            var securitiesToCheck = changes.AddedSecurities.Where(x => (!x.Symbol.IsCanonical() || x.Symbol.SecurityType == SecurityType.Future) && !SecuritiesToIgnoreForChecking.Contains(x.Symbol.Value)).ToList();
+
+            foreach (var addedSecurity in securitiesToCheck)
             {
                 if (addedSecurity.Price == 0)
                 {
@@ -55,7 +58,7 @@ public override void OnSecuritiesChanged(SecurityChanges changes)
                 gotOpenInterest |= addedSecurity.Cache.GetData<OpenInterest>() != null;
             }
 
-            if (changes.AddedSecurities.Count > 0)
+            if (securitiesToCheck.Count > 0)
             {
                 if (ShouldHaveTradeData && !gotTrades)
                 {

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -316,30 +316,30 @@ public override OrderEvent MarketFill(Security asset, MarketOrder order)
             {"Total Orders", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.40%"},
-            {"Compounding Annual Return", "-21.378%"},
-            {"Drawdown", "0.400%"},
+            {"Compounding Annual Return", "119.386%"},
+            {"Drawdown", "0.800%"},
             {"Expectancy", "-1"},
             {"Start Equity", "100000"},
-            {"End Equity", "99671.06"},
-            {"Net Profit", "-0.329%"},
-            {"Sharpe Ratio", "-14.095"},
+            {"End Equity", "101082.06"},
+            {"Net Profit", "1.082%"},
+            {"Sharpe Ratio", "12.594"},
             {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "1.216%"},
+            {"Probabilistic Sharpe Ratio", "95.977%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.01"},
-            {"Beta", "0.097"},
-            {"Annual Standard Deviation", "0.002"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "7.39"},
-            {"Tracking Error", "0.015"},
-            {"Treynor Ratio", "-0.234"},
+            {"Alpha", "0.504"},
+            {"Beta", "-6.672"},
+            {"Annual Standard Deviation", "0.111"},
+            {"Annual Variance", "0.012"},
+            {"Information Ratio", "12.001"},
+            {"Tracking Error", "0.127"},
+            {"Treynor Ratio", "-0.209"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "17.02%"},
-            {"Drawdown Recovery", "0"},
+            {"Drawdown Recovery", "4"},
             {"OrderListHash", "1be5073f2cf8802ffa163f7dab7d040e"}
         };
     }

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -36,6 +36,9 @@ public class BasicTemplateContinuousFutureAlgorithm : QCAlgorithm, IRegressionAl
         private SimpleMovingAverage _fast;
         private SimpleMovingAverage _slow;
 
+        // Minimum SMA gap required before acting on a cross; see the workaround note in OnData.
+        private const decimal CrossThreshold = 0.001m;
+
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
@@ -69,15 +72,17 @@ public override void OnData(Slice slice)
                 }
             }
 
+            // Workaround so the C# and Python versions take the exact same trades on the limited
+            // sample data in the repository (decimal vs double rounding can disagree at a cross).
             if (!Portfolio.Invested)
             {
-                if(_fast > _slow)
+                if(_fast.Current.Value - _slow.Current.Value > CrossThreshold)
                 {
                     _currentContract = Securities[_continuousContract.Mapped];
                     Buy(_currentContract.Symbol, 1);
                 }
             }
-            else if(_fast < _slow)
+            else if(_slow.Current.Value - _fast.Current.Value > CrossThreshold)
             {
                 Liquidate();
             }
@@ -134,34 +139,34 @@ public override void OnSecuritiesChanged(SecurityChanges changes)
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "5"},
-            {"Average Win", "2.48%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "11.325%"},
-            {"Drawdown", "1.500%"},
-            {"Expectancy", "0"},
+            {"Total Orders", "9"},
+            {"Average Win", "2.85%"},
+            {"Average Loss", "-0.43%"},
+            {"Compounding Annual Return", "11.019%"},
+            {"Drawdown", "0.900%"},
+            {"Expectancy", "2.818"},
             {"Start Equity", "100000"},
-            {"End Equity", "105549.6"},
-            {"Net Profit", "5.550%"},
-            {"Sharpe Ratio", "1.332"},
-            {"Sortino Ratio", "879.904"},
-            {"Probabilistic Sharpe Ratio", "79.894%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "100%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.075"},
-            {"Beta", "-0.017"},
-            {"Annual Standard Deviation", "0.053"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.48"},
-            {"Tracking Error", "0.099"},
-            {"Treynor Ratio", "-4.187"},
-            {"Total Fees", "$10.75"},
-            {"Estimated Strategy Capacity", "$7100000.00"},
+            {"End Equity", "105403.5"},
+            {"Net Profit", "5.404%"},
+            {"Sharpe Ratio", "1.531"},
+            {"Sortino Ratio", "2.106"},
+            {"Probabilistic Sharpe Ratio", "82.864%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "6.64"},
+            {"Alpha", "0.067"},
+            {"Beta", "0.009"},
+            {"Annual Standard Deviation", "0.045"},
+            {"Annual Variance", "0.002"},
+            {"Information Ratio", "-1.606"},
+            {"Tracking Error", "0.093"},
+            {"Treynor Ratio", "7.237"},
+            {"Total Fees", "$19.35"},
+            {"Estimated Strategy Capacity", "$1000000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "2.33%"},
-            {"Drawdown Recovery", "37"},
-            {"OrderListHash", "223735440010fcec5889bb7becacfa82"}
+            {"Portfolio Turnover", "4.18%"},
+            {"Drawdown Recovery", "19"},
+            {"OrderListHash", "eb3bed9886f79a56c631225a6445adb2"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -37,6 +37,9 @@ public class BasicTemplateContinuousFutureWithExtendedMarketAlgorithm : QCAlgori
         private SimpleMovingAverage _fast;
         private SimpleMovingAverage _slow;
 
+        // Minimum SMA gap required before acting on a cross; see the workaround note in OnData.
+        private const decimal CrossThreshold = 0.001m;
+
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
@@ -76,17 +79,24 @@ public override void OnData(Slice slice)
                 return;
             }
 
-            if (!Portfolio.Invested)
+            // This is just to limit the amount of orders done in this regression test, since data in the repo is limited.
+            // Also limit it to 3 orders so that the continuous contract rolls happens with an open position.
+            if (Time < new DateTime(2013, 11, 12) && Transactions.OrdersCount < 3)
             {
-                if(_fast > _slow)
+                // Workaround so the C# and Python versions take the exact same trades on the limited
+                // sample data in the repository (decimal vs double rounding can disagree at a cross).
+                if (!Portfolio.Invested)
                 {
-                    _currentContract = Securities[_continuousContract.Mapped];
-                    Buy(_currentContract.Symbol, 1);
+                    if (_fast.Current.Value - _slow.Current.Value > CrossThreshold)
+                    {
+                        _currentContract = Securities[_continuousContract.Mapped];
+                        Buy(_currentContract.Symbol, 1);
+                    }
+                }
+                else if (_slow.Current.Value - _fast.Current.Value > CrossThreshold)
+                {
+                    Liquidate();
                 }
-            }
-            else if(_fast < _slow)
-            {
-                Liquidate();
             }
 
             if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped)
@@ -140,34 +150,34 @@ public override void OnSecuritiesChanged(SecurityChanges changes)
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "5"},
-            {"Average Win", "2.86%"},
+            {"Total Orders", "3"},
+            {"Average Win", "6.15%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "12.959%"},
-            {"Drawdown", "1.100%"},
+            {"Compounding Annual Return", "13.813%"},
+            {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
-            {"End Equity", "106337.1"},
-            {"Net Profit", "6.337%"},
-            {"Sharpe Ratio", "1.41"},
-            {"Sortino Ratio", "1.242"},
-            {"Probabilistic Sharpe Ratio", "77.992%"},
+            {"End Equity", "106741.4"},
+            {"Net Profit", "6.741%"},
+            {"Sharpe Ratio", "2.003"},
+            {"Sortino Ratio", "2.845"},
+            {"Probabilistic Sharpe Ratio", "92.590%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.071"},
-            {"Beta", "0.054"},
-            {"Annual Standard Deviation", "0.059"},
-            {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.392"},
-            {"Tracking Error", "0.097"},
-            {"Treynor Ratio", "1.518"},
-            {"Total Fees", "$10.75"},
-            {"Estimated Strategy Capacity", "$890000000.00"},
+            {"Alpha", "0.069"},
+            {"Beta", "0.086"},
+            {"Annual Standard Deviation", "0.044"},
+            {"Annual Variance", "0.002"},
+            {"Information Ratio", "-1.506"},
+            {"Tracking Error", "0.086"},
+            {"Treynor Ratio", "1.023"},
+            {"Total Fees", "$6.45"},
+            {"Estimated Strategy Capacity", "$3700000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "2.32%"},
-            {"Drawdown Recovery", "34"},
-            {"OrderListHash", "1504a8892da8d8c0650018732f315753"}
+            {"Portfolio Turnover", "1.37%"},
+            {"Drawdown Recovery", "18"},
+            {"OrderListHash", "764ab9f6ea662a60e41daedb9613b246"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -193,34 +193,34 @@ public void Dispose()
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "1"},
-            {"Average Win", "0%"},
+            {"Total Orders", "3"},
+            {"Average Win", "0.14%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-0.010%"},
-            {"Drawdown", "0.000%"},
+            {"Compounding Annual Return", "0.770%"},
+            {"Drawdown", "0.100%"},
             {"Expectancy", "0"},
             {"Start Equity", "1000000"},
-            {"End Equity", "999983.2"},
-            {"Net Profit", "-0.002%"},
-            {"Sharpe Ratio", "-225.214"},
-            {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0.135%"},
+            {"End Equity", "1001341.4"},
+            {"Net Profit", "0.134%"},
+            {"Sharpe Ratio", "-0.494"},
+            {"Sortino Ratio", "-0.544"},
+            {"Probabilistic Sharpe Ratio", "55.093%"},
             {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
+            {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.008"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
+            {"Alpha", "-0.015"},
+            {"Beta", "0.03"},
+            {"Annual Standard Deviation", "0.004"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-5.146"},
-            {"Tracking Error", "0.083"},
-            {"Treynor Ratio", "-542.359"},
-            {"Total Fees", "$2.15"},
-            {"Estimated Strategy Capacity", "$0"},
+            {"Information Ratio", "-5.235"},
+            {"Tracking Error", "0.081"},
+            {"Treynor Ratio", "-0.069"},
+            {"Total Fees", "$6.45"},
+            {"Estimated Strategy Capacity", "$780000000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "0.13%"},
-            {"Drawdown Recovery", "0"},
-            {"OrderListHash", "a6ccce3a1a7f549f887d83e84bfa878d"}
+            {"Portfolio Turnover", "0.42%"},
+            {"Drawdown Recovery", "3"},
+            {"OrderListHash", "d17bbe62c86730e5178528a3153df0e6"}
         };
     }
 }