Add logs to ProcessedDataProvider

Removed greeks and IV columns.
Updated FOPs universe files: removed outdated columns.

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -49,7 +49,7 @@ namespace QuantConnect.Algorithm.CSharp
                 contractDepthOffset: 0
             );
 
-            _futureContract = AddFutureContract(FutureChainProvider.GetFutureContractList(_continuousContract.Symbol, Time).First());
+            _futureContract = AddFutureContract(FuturesChain(_continuousContract.Symbol).First());
         }
 
         /// <summary>
@@ -115,12 +115,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 76;
+        public long DataPoints => 61;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -169,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 2;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -93,12 +93,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 12172;
+        public long DataPoints => 9922;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 2;
 
         /// <summary>
         /// Final status of the algorithm
@@ -113,7 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "20"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "386219349.202%"},
+            {"Compounding Annual Return", "88398927.578%"},
             {"Drawdown", "5.200%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -108,7 +108,7 @@ namespace QuantConnect.Algorithm.CSharp
                 return;
             }
 
-            foreach (var chain in slice.OptionChains.Values)
+            foreach (var chain in slice.OptionChains.Values.OrderBy(x => x.Symbol.Underlying.ID.Date))
             {
                 var futureInvested = false;
                 var optionInvested = false;
@@ -220,7 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 608380;
+        public long DataPoints => 319494;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -240,7 +240,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "347.065%"},
+            {"Compounding Annual Return", "309.669%"},
             {"Drawdown", "0.900%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2013, 10, 10);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
-            _symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
+            _symbol = FuturesChain(SP500).First();
 
             // Test case: custom IndicatorBase<QuoteBar> indicator using Future unsubscribed symbol
             var indicator1 = new CustomIndicator();
@@ -151,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 84;
+        public int AlgorithmHistoryDataPoints => 85;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -18,7 +18,6 @@ using QuantConnect.Data;
 using QuantConnect.Orders;
 using QuantConnect.Interfaces;
 using System.Collections.Generic;
-using System.Linq;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Indicators;
 using QuantConnect.Securities;
@@ -118,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713375;
+        public long DataPoints => 162575;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -161,7 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$7100000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "2.33%"},
-            {"OrderListHash", "9c524830ffc7354327638142ae62acd2"}
+            {"OrderListHash", "04670183a0a4c9160167415aa5102499"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -123,7 +123,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 2217330;
+        public long DataPoints => 504530;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateEurexFuturesAlgorithm.cs

@@ -190,12 +190,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 133947;
+        public long DataPoints => 94326;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 26;
+        public int AlgorithmHistoryDataPoints => 0;
 
         /// <summary>
         /// Final status of the algorithm
@@ -233,7 +233,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "€2300000000.00"},
             {"Lowest Capacity Asset", "FESX YJHOAMPYKRS5"},
             {"Portfolio Turnover", "0.40%"},
-            {"OrderListHash", "54040d29a467becaedcf59d79323321b"}
+            {"OrderListHash", "ac9acc478ba1afe53993cdbb92f8ec6e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -176,7 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1185;
+        public long DataPoints => 727;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -221,5 +221,5 @@ namespace QuantConnect.Algorithm.CSharp
             {"Portfolio Turnover", "0.13%"},
             {"OrderListHash", "7c8700a9baa24f6f76d866e7d88cc19c"}
         };
-    }  
+    }
 }

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -149,7 +149,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 75403;
+        public long DataPoints => 40308;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -169,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "2700"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-99.777%"},
+            {"Compounding Annual Return", "-99.597%"},
             {"Drawdown", "4.400%"},
             {"Expectancy", "-0.724"},
             {"Start Equity", "1000000"},

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -18,8 +18,8 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
-using QuantConnect.Orders;
 using QuantConnect.Securities;
 using QuantConnect.Securities.Future;
 
@@ -104,6 +104,16 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
 
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (changes.RemovedSecurities.Count > 0 &&
+                Portfolio.Invested &&
+                Securities.Values.Where(x => x.Invested).All(x => x.Exchange.Hours.IsOpen(Time, true)))
+            {
+                Liquidate();
+            }
+        }
+
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
@@ -117,7 +127,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 12474;
+        public virtual long DataPoints => 5861;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -160,7 +170,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
             {"Portfolio Turnover", "0.92%"},
-            {"OrderListHash", "9507abc8348ff3cb1e2a9a5f48d128a7"}
+            {"OrderListHash", "c0713abdc4fb059c2be797fce36e4f36"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -136,7 +136,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 57759;
+        public virtual long DataPoints => 24883;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 163416;
+        public override long DataPoints => 70262;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -140,12 +140,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 48690;
+        public virtual long DataPoints => 25316;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 5305;
+        public virtual int AlgorithmHistoryDataPoints => 6075;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm.cs

@@ -47,7 +47,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 147771;
+        public override long DataPoints => 76063;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -14,12 +14,7 @@
  *
 */
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Securities;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -41,40 +36,40 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 87292;
+        public override long DataPoints => 25312;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "716"},
+            {"Total Orders", "718"},
             {"Average Win", "0.03%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-1.716%"},
+            {"Compounding Annual Return", "-1.720%"},
             {"Drawdown", "1.700%"},
             {"Expectancy", "-0.770"},
             {"Start Equity", "1000000"},
-            {"End Equity", "982718.38"},
-            {"Net Profit", "-1.728%"},
-            {"Sharpe Ratio", "-8.845"},
-            {"Sortino Ratio", "-5.449"},
+            {"End Equity", "982676.58"},
+            {"Net Profit", "-1.732%"},
+            {"Sharpe Ratio", "-8.877"},
+            {"Sortino Ratio", "-5.476"},
             {"Probabilistic Sharpe Ratio", "0.000%"},
             {"Loss Rate", "96%"},
             {"Win Rate", "4%"},
-            {"Profit-Loss Ratio", "4.89"},
+            {"Profit-Loss Ratio", "4.90"},
             {"Alpha", "-0.018"},
             {"Beta", "-0.002"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.483"},
+            {"Information Ratio", "-1.484"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "9.102"},
-            {"Total Fees", "$1634.12"},
+            {"Treynor Ratio", "9.171"},
+            {"Total Fees", "$1638.42"},
             {"Estimated Strategy Capacity", "$8000.00"},
             {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
-            {"Portfolio Turnover", "20.10%"},
-            {"OrderListHash", "aa7e574f86b70428ca0afae381be80ba"}
+            {"Portfolio Turnover", "20.14%"},
+            {"OrderListHash", "dedcc487d64e2f601990fc70393c89ed"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketAlgorithm.cs

@@ -149,7 +149,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 224662;
+        public long DataPoints => 117079;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -36,7 +36,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 14182;
+        public override long DataPoints => 5965;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -69,7 +69,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
             {"Portfolio Turnover", "0.87%"},
-            {"OrderListHash", "ea6fdf3133bde7063e4fc0fa809ae260"}
+            {"OrderListHash", "8b8b733248a21fc717079be54b2e844c"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 228941;
+        public override long DataPoints => 67924;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/ConsolidateRegressionAlgorithm.cs

@@ -47,7 +47,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2020, 01, 20);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
-            var symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
+            var symbol = FuturesChain(SP500).First();
             _future = AddFutureContract(symbol);
 
             var tradableDatesCount = QuantConnect.Time.EachTradeableDayInTimeZone(_future.Exchange.Hours,
@@ -194,7 +194,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/ContinuousBackMonthRawFutureRegressionAlgorithm.cs

@@ -139,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713371;
+        public long DataPoints => 162571;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureBackMonthRegressionAlgorithm.cs

@@ -155,7 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 723498;
+        public long DataPoints => 172698;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureHistoryRegressionAlgorithm.cs

@@ -120,7 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 9953;
+        public virtual long DataPoints => 5469;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -160,7 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$2.15"},
-            {"Estimated Strategy Capacity", "$100000000.00"},
+            {"Estimated Strategy Capacity", "$130000000.00"},
             {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
             {"Portfolio Turnover", "41.23%"},
             {"OrderListHash", "b9f8e1a0704c086944e5df07e0ab04d6"}

Algorithm.CSharp/ContinuousFutureHistoryTimeSpanWarmupRegressionAlgorithm.cs

@@ -34,6 +34,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 15813;
+        public override long DataPoints => 9079;
     }
 }

Algorithm.CSharp/ContinuousFutureImmediateUniverseSelectionRegressionAlgorithm.cs

@@ -78,7 +78,7 @@ namespace QuantConnect.Algorithm.CSharp
 
                 }
 
-                return universe.Select(x => x);
+                return universe;
             });
 
             _milk.SetFilter(universe =>
@@ -94,7 +94,7 @@ namespace QuantConnect.Algorithm.CSharp
                     }
                 }
 
-                return universe.Select(x => x);
+                return universe;
             });
         }
 
@@ -184,7 +184,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 596358;
+        public long DataPoints => 445961;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureLimitIfTouchedOrderRegressionAlgorithm.cs

@@ -78,7 +78,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 19888;
+        public long DataPoints => 10883;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -98,7 +98,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-99.258%"},
+            {"Compounding Annual Return", "-99.012%"},
             {"Drawdown", "6.300%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},

Algorithm.CSharp/ContinuousFutureOpenPositionsLiquidationOnDelistingRegressionAlgorithm.cs

@@ -188,7 +188,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 396945;
+        public virtual long DataPoints => 159274;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureRegressionAlgorithm.cs

@@ -173,7 +173,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713375;
+        public long DataPoints => 162575;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureRolloverDailyExchangeTimeZoneAheadOfDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1014;
+        public override long DataPoints => 483;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverDailyExchangeTimeZoneBehindOfDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1004;
+        public override long DataPoints => 479;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverDailyExchangeTimeZoneSameAsDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1007;
+        public override long DataPoints => 483;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverHourExchangeTimeZoneAheadOfDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 18850;
+        public override long DataPoints => 7424;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverHourExchangeTimeZoneBehindOfDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 18844;
+        public override long DataPoints => 7440;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverHourExchangeTimeZoneSameAsDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 18846;
+        public override long DataPoints => 7434;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverMinuteExchangeTimeZoneAheadOfDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1127376;
+        public override long DataPoints => 444159;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverMinuteExchangeTimeZoneBehindOfDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1127374;
+        public override long DataPoints => 445123;
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverMinuteExchangeTimeZoneSameAsDataRegressionAlgorithm.cs

@@ -33,6 +33,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1127488;
+        public override long DataPoints => 444757;
     }
 }

Algorithm.CSharp/ContinuousFuturesDailyRegressionAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1276;
+        public long DataPoints => 848;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/DefaultFutureChainRegressionAlgorithm.cs

@@ -62,7 +62,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 516622;
+        public long DataPoints => 70735;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/DelistedFutureLiquidateDailyRegressionAlgorithm.cs

@@ -28,7 +28,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1690;
+        public override long DataPoints => 1235;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -44,24 +44,24 @@ namespace QuantConnect.Algorithm.CSharp
             {"Start Equity", "100000"},
             {"End Equity", "107779.1"},
             {"Net Profit", "7.779%"},
-            {"Sharpe Ratio", "3.132"},
+            {"Sharpe Ratio", "3.128"},
             {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "99.474%"},
+            {"Probabilistic Sharpe Ratio", "99.450%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.145"},
             {"Beta", "0.271"},
             {"Annual Standard Deviation", "0.081"},
-            {"Annual Variance", "0.006"},
+            {"Annual Variance", "0.007"},
             {"Information Ratio", "-1.459"},
             {"Tracking Error", "0.099"},
-            {"Treynor Ratio", "0.932"},
+            {"Treynor Ratio", "0.931"},
             {"Total Fees", "$2.15"},
             {"Estimated Strategy Capacity", "$150000000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "1.98%"},
-            {"OrderListHash", "b337ac27f46a6298dd4e9f0f04b49427"}
+            {"OrderListHash", "6365adfc234509e390295a150f25c295"}
         };
     }
 }

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -92,7 +92,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 525811;
+        public virtual long DataPoints => 288140;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,18 +124,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.228"},
-            {"Beta", "0.108"},
+            {"Alpha", "0.227"},
+            {"Beta", "0.109"},
             {"Annual Standard Deviation", "0.084"},
             {"Annual Variance", "0.007"},
             {"Information Ratio", "-1.122"},
             {"Tracking Error", "0.112"},
-            {"Treynor Ratio", "2.501"},
+            {"Treynor Ratio", "2.49"},
             {"Total Fees", "$2.15"},
             {"Estimated Strategy Capacity", "$1700000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "2.01%"},
-            {"OrderListHash", "640ce720644ff0b580687e80105d0a92"}
+            {"OrderListHash", "de82efe4f019a5fa1fb79d111bf15811"}
         };
     }
 }

Algorithm.CSharp/DelistingFutureOptionDailyRegressionAlgorithm.cs

@@ -14,7 +14,6 @@
 */
 
 using System.Collections.Generic;
-using QuantConnect.Orders;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -29,7 +28,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 12251;
+        public override long DataPoints => 3918;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/DelistingFutureOptionRegressionAlgorithm.cs

@@ -13,13 +13,11 @@
  * limitations under the License.
 */
 
-using System;
 using QuantConnect.Data;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
 using System.Collections.Generic;
 using System.Linq;
-using QuantConnect.Orders;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -107,7 +105,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 4632655;
+        public virtual long DataPoints => 761073;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -131,10 +129,10 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.100%"},
             {"Expectancy", "-0.678"},
             {"Start Equity", "10000000"},
-            {"End Equity", "9988860.24"},
+            {"End Equity", "9988880.24"},
             {"Net Profit", "-0.111%"},
-            {"Sharpe Ratio", "-10.413"},
-            {"Sortino Ratio", "-0.961"},
+            {"Sharpe Ratio", "-10.416"},
+            {"Sortino Ratio", "-0.959"},
             {"Probabilistic Sharpe Ratio", "0.000%"},
             {"Loss Rate", "80%"},
             {"Win Rate", "20%"},
@@ -145,12 +143,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.076"},
             {"Tracking Error", "0.107"},
-            {"Treynor Ratio", "14.588"},
+            {"Treynor Ratio", "14.634"},
             {"Total Fees", "$19.76"},
-            {"Estimated Strategy Capacity", "$1300000000.00"},
+            {"Estimated Strategy Capacity", "$1400000000.00"},
             {"Lowest Capacity Asset", "DC V5E8PHPRCHJ8|DC V5E8P9SH0U0X"},
             {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "7f06f736e2f1294916fb2485519021a2"}
+            {"OrderListHash", "67b64c13cbc4aad88111503cf7b789bc"}
         };
     }
 }

Algorithm.CSharp/EqualWeightingPortfolioConstructionModelFutureRegressionAlgorithm.cs

@@ -130,7 +130,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 94731;
+        public long DataPoints => 36213;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -150,7 +150,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "8"},
             {"Average Win", "0.69%"},
             {"Average Loss", "-2.47%"},
-            {"Compounding Annual Return", "-99.966%"},
+            {"Compounding Annual Return", "-99.946%"},
             {"Drawdown", "28.600%"},
             {"Expectancy", "-0.680"},
             {"Start Equity", "100000"},

Algorithm.CSharp/FillForwardResolutionAdjustedOnRemovalRegressionAlgorithm.cs

@@ -91,7 +91,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 872;
+        public long DataPoints => 852;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureChainInternalSubscriptionsRegressionAlgorithm.cs

@@ -94,7 +94,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 54138;
+        public long DataPoints => 19043;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -114,7 +114,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-99.310%"},
+            {"Compounding Annual Return", "-98.880%"},
             {"Drawdown", "4.400%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},

Algorithm.CSharp/FutureMarketOpenAndCloseRegressionAlgorithm.cs

@@ -100,7 +100,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 13586;
+        public virtual long DataPoints => 91;
 
         /// </summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureMarketOpenAndCloseWithExtendedMarketRegressionAlgorithm.cs

@@ -54,7 +54,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 41467;
+        public override long DataPoints => 92;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/FutureMarketOpenConsolidatorRegressionAlgorithm.cs

@@ -94,7 +94,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 32073;
+        public virtual long DataPoints => 16313;
 
         /// </summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureMarketOpenConsolidatorWithExtendedMarketRegressionAlgorithm.cs

@@ -57,7 +57,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 103818;
+        public override long DataPoints => 51933;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/FutureNoTimeInUniverseRegressionAlgorithm.cs

@@ -90,7 +90,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 18492;
+        public long DataPoints => 11768;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -117,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 2;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs

@@ -205,7 +205,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -170,7 +170,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -181,7 +181,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionChainFullDataRegressionAlgorithm.cs

@@ -0,0 +1,127 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.OptionChain(Symbol)"/> method
+    /// to get a future option chain.
+    /// </summary>
+    public class FutureOptionChainFullDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _optionContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 6);
+            SetEndDate(2020, 1, 6);
+
+            var futureContract = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 3, 20)),
+                Resolution.Minute).Symbol;
+
+            _optionContract = OptionChain(futureContract)
+                // Get contracts expiring within 4 months
+                .Where(contractData => contractData.Expiry - Time <= TimeSpan.FromDays(120))
+                // Get the contract with the latest expiration date, highest strike and lowest price
+                .OrderByDescending(x => x.Expiry)
+                .ThenByDescending(x => x.Strike)
+                .ThenBy(x => x.LastPrice)
+                .First();
+
+            AddFutureOptionContract(_optionContract);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Do some trading with the selected contract for sample purposes
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_optionContract, 0.5);
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1817;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 1;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "450"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "65398.86"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$34601.14"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "ES XCZJLCGM383O|ES XCZJLC9NOB29"},
+            {"Portfolio Turnover", "112.25%"},
+            {"OrderListHash", "f18259d04c2d899e7162b88e10239eb8"}
+        };
+    }
+}

Algorithm.CSharp/FutureOptionChainsMultipleFullDataRegressionAlgorithm.cs

@@ -0,0 +1,147 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.OptionChains(IEnumerable{Symbol})"/> method
+    /// to get multiple future option chains.
+    /// </summary>
+    public class FutureOptionChainsMultipleFullDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _esOptionContract;
+        private Symbol _gcOptionContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 6);
+            SetEndDate(2020, 1, 6);
+            SetCash(100000);
+
+            var esFutureContract = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 3, 20)),
+                Resolution.Minute).Symbol;
+
+            var gcFutureContract = AddFutureContract(
+                QuantConnect.Symbol.CreateFuture(Futures.Metals.Gold, Market.COMEX, new DateTime(2020, 4, 28)),
+                Resolution.Minute).Symbol;
+
+            var chains = OptionChains([esFutureContract, gcFutureContract]);
+
+            _esOptionContract = GetContract(chains, esFutureContract);
+            _gcOptionContract = GetContract(chains, gcFutureContract);
+
+            AddFutureOptionContract(_esOptionContract);
+            AddFutureOptionContract(_gcOptionContract);
+        }
+
+        private Symbol GetContract(OptionChains chains, Symbol underlying)
+        {
+            return chains
+                .Where(kvp => kvp.Key.Underlying == underlying)
+                .Select(kvp => kvp.Value)
+                .Single()
+                // Get contracts expiring within 5 months
+                .Where(contractData => contractData.Expiry - Time <= TimeSpan.FromDays(120))
+                // Get the contract with the latest expiration date, highest strike and lowest price
+                .OrderByDescending(x => x.Expiry)
+                .ThenByDescending(x => x.Strike)
+                .ThenBy(x => x.LastPrice)
+                .First();
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Do some trading with the selected contract for sample purposes
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_esOptionContract, 0.25);
+                SetHoldings(_gcOptionContract, 0.25);
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1819;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 2;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "450"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "80983.36"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$19016.64"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "ES XCZJLCGM383O|ES XCZJLC9NOB29"},
+            {"Portfolio Turnover", "49.52%"},
+            {"OrderListHash", "9b39296a82d51d51fa1df02aad39d804"}
+        };
+    }
+}

Algorithm.CSharp/FutureOptionDailyRegressionAlgorithm.cs

@@ -124,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 0;
+        public virtual int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionHourlyRegressionAlgorithm.cs

@@ -73,7 +73,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public override int AlgorithmHistoryDataPoints => 0;
+        public override int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionIndicatorsRegressionAlgorithm.cs

@@ -51,6 +51,11 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override long DataPoints => 1817;
 
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 1;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 24379;
+        public long DataPoints => 13942;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureOptionPutITMExpiryRegressionAlgorithm.cs

@@ -206,7 +206,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionPutOTMExpiryRegressionAlgorithm.cs

@@ -179,7 +179,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionShortCallITMExpiryRegressionAlgorithm.cs

@@ -190,7 +190,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionShortCallOTMExpiryRegressionAlgorithm.cs

@@ -173,7 +173,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionShortPutITMExpiryRegressionAlgorithm.cs

@@ -187,7 +187,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureOptionShortPutOTMExpiryRegressionAlgorithm.cs

@@ -172,7 +172,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FutureSharingTickerRegressionAlgorithm.cs

@@ -80,7 +80,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 51429;
+        public long DataPoints => 23079;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureStopMarketOrderOnExtendedHoursRegressionAlgorithm.cs

@@ -26,8 +26,8 @@ using QuantConnect.Securities.Future;
 namespace QuantConnect.Algorithm.CSharp
 {
     /// <summary>
-    /// Continuous Futures Regression algorithm. 
-    /// Asserting the behavior of stop market order <see cref="StopMarketOrder"/> in extended market hours 
+    /// Continuous Futures Regression algorithm.
+    /// Asserting the behavior of stop market order <see cref="StopMarketOrder"/> in extended market hours
     /// <seealso cref="Data.UniverseSelection.UniverseSettings.ExtendedMarketHours"/>
     /// </summary>
     public class FutureStopMarketOrderOnExtendedHoursRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
@@ -43,6 +43,12 @@ namespace QuantConnect.Algorithm.CSharp
 
             Schedule.On(DateRules.EveryDay(), TimeRules.At(19, 0), () =>
             {
+                // Don't place orders at the end of the last date, the market-on-stop order won't have time to fill
+                if (Time.Date == EndDate.Date.AddDays(-1))
+                {
+                    return;
+                }
+
                 MarketOrder(_SP500EMini.Mapped, 1);
                 _ticket = StopMarketOrder(_SP500EMini.Mapped, -1, _SP500EMini.Price * 1.1m);
             });
@@ -113,7 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all time slices of algorithm
         /// </summary>
-        public long DataPoints => 75961;
+        public long DataPoints => 41486;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -133,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "10"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-6.736%"},
+            {"Compounding Annual Return", "-6.419%"},
             {"Drawdown", "0.100%"},
             {"Expectancy", "-1"},
             {"Start Equity", "100000"},

Algorithm.CSharp/FutureUniverseHistoryRegressionAlgorithm.cs

@@ -0,0 +1,131 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm testing history requests for <see cref="FutureUniverse"/> type work as expected
+    /// and return the same data as the futures chain provider.
+    /// </summary>
+    public class FutureUniverseHistoryRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 11);
+            SetEndDate(2013, 10, 11);
+
+            var future = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute).Symbol;
+
+            var historicalFuturesData = History<FutureUniverse>(future, 3, Resolution.Daily).ToList();
+
+            if (historicalFuturesData.Count != 3)
+            {
+                throw new RegressionTestException($"Expected 3 futures chains from history request, " +
+                    $"but got {historicalFuturesData.Count}");
+            }
+
+            foreach (var historyFutureUniverse in historicalFuturesData)
+            {
+                var date = historyFutureUniverse.EndTime;
+                var chain = FutureChainProvider.GetFutureContractList(future, date).ToList();
+
+                if (chain.Count == 0)
+                {
+                    throw new RegressionTestException($"No futures in chain on {date}");
+                }
+
+                if (chain.Count != historyFutureUniverse.Data.Count)
+                {
+                    throw new RegressionTestException($"Expected {chain.Count} futures in chain on {date}, " +
+                        $"but got {historyFutureUniverse.Data.Count}");
+                }
+
+                for (var i = 0; i < chain.Count; i++)
+                {
+                    if (historyFutureUniverse.Data[i].Symbol != chain[i])
+                    {
+                        throw new RegressionTestException($"Missing future contract {chain[i]} on {date}");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 2735;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 6;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/FuturesChainFullDataRegressionAlgorithm.cs

@@ -0,0 +1,133 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.FuturesChain(Symbol, bool)"/>
+    /// method to get a future chain.
+    /// </summary>
+    public class FuturesChainFullDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _futureContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 7);
+
+            var future = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute).Symbol;
+
+            var chain = FuturesChain(future);
+            foreach (var contract in chain)
+            {
+                if (contract.BidPrice == 0 && contract.AskPrice == 0 && contract.Volume == 0)
+                {
+                    throw new RegressionTestException("FuturesChain() returned contract with no data.");
+                }
+            }
+
+            _futureContract = chain
+                // Get contracts expiring within 6 months
+                .Where(contractData => contractData.Expiry - Time <= TimeSpan.FromDays(180))
+                // Get the contract with the latest expiration date, and lowest price
+                .OrderByDescending(x => x.Expiry)
+                .ThenBy(x => x.LastPrice)
+                .First();
+
+            AddFutureContract(_futureContract);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Do some trading with the selected contract for sample purposes
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_futureContract, 0.5);
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 4083;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 1;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "450"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "50272.1"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$8290.40"},
+            {"Estimated Strategy Capacity", "$13000.00"},
+            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
+            {"Portfolio Turnover", "639698.49%"},
+            {"OrderListHash", "312461917700d86df1b5c43e1e7ec0eb"}
+        };
+    }
+}

Algorithm.CSharp/FuturesChainsMultipleFullDataRegressionAlgorithm.cs

@@ -0,0 +1,140 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.FuturesChains(IEnumerable{Symbol}, bool)"/>
+    /// method to get multiple futures chains.
+    /// </summary>
+    public class FuturesChainsMultipleFullDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _esFutureContract;
+        private Symbol _gcFutureContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 7);
+
+            var esFuture= AddFuture(Futures.Indices.SP500EMini).Symbol;
+            var gcFuture = AddFuture(Futures.Metals.Gold).Symbol;
+
+            var chains = FuturesChains([esFuture, gcFuture]);
+
+            _esFutureContract = GetContract(chains, esFuture);
+            _gcFutureContract = GetContract(chains, gcFuture);
+
+            AddFutureContract(_esFutureContract);
+            AddFutureContract(_gcFutureContract);
+        }
+
+        private Symbol GetContract(FuturesChains chains, Symbol canonical)
+        {
+            return chains
+                .Where(kvp => kvp.Key == canonical)
+                .Select(kvp => kvp.Value)
+                .Single()
+                // Get contracts expiring within 6 months
+                .Where(contractData => contractData.Expiry - Time <= TimeSpan.FromDays(180))
+                // Get the contract with the latest expiration date, and lowest price
+                .OrderByDescending(x => x.Expiry)
+                .ThenBy(x => x.LastPrice)
+                .First();
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Do some trading with the selected contract for sample purposes
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_esFutureContract, 0.25);
+                SetHoldings(_gcFutureContract, 0.25);
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 8184;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 2;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "900"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "57108.26"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$5701.74"},
+            {"Estimated Strategy Capacity", "$19000.00"},
+            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
+            {"Portfolio Turnover", "432921.78%"},
+            {"OrderListHash", "c75de8eb115be82a0ec2afaec8d034ff"}
+        };
+    }
+}

Algorithm.CSharp/FuturesDailySettlementLongRegressionAlgorithm.cs

@@ -62,7 +62,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             var future = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
 
-            _contractSymbol = FutureChainProvider.GetFutureContractList(future, Time).OrderBy(x => x.ID.Date).FirstOrDefault();
+            _contractSymbol = FuturesChain(future).OrderBy(x => x.ID.Date).First();
             _future = AddFutureContract(_contractSymbol);
 
             _future.Holdings.SetHoldings(1600, 1 * OrderSide);
@@ -180,7 +180,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/FuturesExpiredContractRegression.cs

@@ -89,7 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 268275;
+        public long DataPoints => 24508;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FuturesExtendedMarketHoursRegressionAlgorithm.cs

@@ -113,7 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 3631;
+        public long DataPoints => 2197;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FuturesFrameworkRegressionAlgorithm.cs

@@ -185,7 +185,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 126811;
+        public virtual long DataPoints => 101119;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/HSIFutureDailyRegressionAlgorithm.cs

@@ -31,7 +31,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 177;
+        public override long DataPoints => 174;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -74,7 +74,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "HSI VL6DN7UV65S9"},
             {"Portfolio Turnover", "1590.77%"},
-            {"OrderListHash", "42cd8e3b58361b181c911a603f69d2f7"}
+            {"OrderListHash", "ca159879e35579b71717638fe2a6844c"}
         };
     }
 }

Algorithm.CSharp/HSIFutureHourRegressionAlgorithm.cs

@@ -161,7 +161,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 823;
+        public virtual long DataPoints => 652;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -204,7 +204,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$120000000.00"},
             {"Lowest Capacity Asset", "HSI VL6DN7UV65S9"},
             {"Portfolio Turnover", "7099.25%"},
-            {"OrderListHash", "174bdb031f17212dc9d92372f4fb75c2"}
+            {"OrderListHash", "da41f273d264b6b1fec2cfa106f3b446"}
         };
     }
 }

Algorithm.CSharp/HistoryWithDifferentContinuousContractDepthOffsetsRegressionAlgorithm.cs

@@ -129,7 +129,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1432;
+        public long DataPoints => 968;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/HistoryWithDifferentDataMappingModeRegressionAlgorithm.cs

@@ -101,7 +101,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1432;
+        public long DataPoints => 968;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/HistoryWithDifferentDataNormalizationModeRegressionAlgorithm.cs

@@ -93,7 +93,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1490;
+        public long DataPoints => 1026;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/IndicatorSelectorsWorkWithDifferentOptions.cs

@@ -186,7 +186,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1575349;
+        public long DataPoints => 454077;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/LimitOrdersAreFilledAfterHoursForFuturesRegressionAlgorithm.cs

@@ -48,7 +48,7 @@ namespace QuantConnect.Algorithm.CSharp
                 contractDepthOffset: 0,
                 extendedMarketHours: true
             );
-            _futureContract = AddFutureContract(FutureChainProvider.GetFutureContractList(_continuousContract.Symbol, Time).First(), extendedMarketHours: true);
+            _futureContract = AddFutureContract(FuturesChain(_continuousContract.Symbol).First(), extendedMarketHours: true);
         }
 
         public override void OnWarmupFinished()
@@ -113,12 +113,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 82372;
+        public long DataPoints => 52987;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/ManualContinuousFuturesPositionRolloverRegressionAlgorithm.cs

@@ -103,7 +103,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713375;
+        public long DataPoints => 162575;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/MarketOrdersAreSupportedOnExtendedHoursForFuturesRegressionAlgorithm.cs

@@ -43,7 +43,7 @@ namespace QuantConnect.Algorithm.CSharp
                 contractDepthOffset: 0,
                 extendedMarketHours: true
             );
-            _futureContract = AddFutureContract(FutureChainProvider.GetFutureContractList(_continuousContract.Symbol, Time).First(),
+            _futureContract = AddFutureContract(FuturesChain(_continuousContract.Symbol).First(),
                 extendedMarketHours: true);
         }
         public override void OnData(Slice slice)
@@ -90,12 +90,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 82372;
+        public long DataPoints => 52987;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/OpenInterestFuturesRegressionAlgorithm.cs

@@ -92,12 +92,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 2794076;
+        public long DataPoints => 526055;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 252;
+        public int AlgorithmHistoryDataPoints => 232;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/OptionIndicatorsRegressionAlgorithm.cs

@@ -90,7 +90,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public virtual int AlgorithmHistoryDataPoints => 0;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/OptionOTMExpiryOrderHasZeroPriceRegressionAlgorithm.cs

@@ -158,7 +158,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/RegisterIndicatorRegressionAlgorithm.cs

@@ -165,7 +165,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/SetDataNormalizationModeOnAddSecurityAlgorithm.cs

@@ -99,7 +99,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 7322;
+        public long DataPoints => 5072;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/SetHoldingsFutureRegressionAlgorithm.cs

@@ -151,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 21665;
+        public long DataPoints => 14920;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -171,7 +171,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "-1.34%"},
-            {"Compounding Annual Return", "-97.000%"},
+            {"Compounding Annual Return", "-95.782%"},
             {"Drawdown", "2.600%"},
             {"Expectancy", "-1"},
             {"Start Equity", "1000000"},

Algorithm.CSharp/StatisticsResultsAlgorithm.cs

@@ -229,8 +229,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$1100000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Portfolio Turnover", "549.26%"},
-            {"Most Traded Security", "IBM"},
             {"Most Traded Security Trade Count", "63"},
+            {"Most Traded Security", "IBM"},
             {"OrderListHash", "8dd77e35338a81410a5b68dc8345f402"}
         };
     }

Algorithm.CSharp/WarmupFutureRegressionAlgorithm.cs

@@ -137,7 +137,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 21683;
+        public virtual long DataPoints => 14938;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -157,7 +157,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "130.234%"},
+            {"Compounding Annual Return", "112.304%"},
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},

Algorithm.CSharp/WarmupFutureTimeSpanWarmupRegressionAlgorithm.cs

@@ -36,6 +36,6 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 28892;
+        public override long DataPoints => 19892;
     }
 }

Algorithm.Framework/Selection/OpenInterestFutureUniverseSelectionModel.cs

@@ -75,7 +75,8 @@ namespace QuantConnect.Algorithm.Framework.Selection
         protected override FutureFilterUniverse Filter(FutureFilterUniverse filter)
         {
             // Remove duplicated keys
-            return filter.Contracts(FilterByOpenInterest(filter.DistinctBy(x => x).ToDictionary(x => x, x => _marketHoursDatabase.GetEntry(x.ID.Market, x, x.ID.SecurityType))));
+            return filter.Contracts(FilterByOpenInterest(
+                filter.DistinctBy(x => x).ToDictionary(x => x.Symbol, x => _marketHoursDatabase.GetEntry(x.ID.Market, x, x.ID.SecurityType))));
         }
 
         /// <summary>

Algorithm.Python/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.py

@@ -46,9 +46,7 @@ class AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorith
         if expiry is None or symbol is None:
             raise AssertionError("Expected a single Option contract in the chain, found 0 contracts")
 
-        enumerator = option_contracts.get_enumerator()
-        while enumerator.move_next():
-            self.expected_symbols_received.append(enumerator.current.symbol)
+        self.expected_symbols_received.extend([x.symbol for x in option_contracts])
 
         return option_contracts
 
@@ -74,7 +72,7 @@ class AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorith
         if self.invested or not has_option_quote_bars:
             return
 
-        for chain in data.option_chains.values():
+        for chain in sorted(data.option_chains.values(), key=lambda chain: chain.symbol.underlying.id.date):
             future_invested = False
             option_invested = False
 

Algorithm.Python/BasicTemplateFuturesDailyAlgorithm.py

@@ -54,6 +54,12 @@ class BasicTemplateFuturesDailyAlgorithm(QCAlgorithm):
         elif all(x.exchange.hours.is_open(self.time, True) for x in self.securities.values() if x.invested):
             self.liquidate()
 
+    def on_securities_changed(self, changes: SecurityChanges) -> None:
+        if len(changes.removed_securities) > 0 and \
+            self.portfolio.invested and \
+            all(x.exchange.hours.is_open(self.time, True) for x in self.securities.values() if x.invested):
+            self.liquidate()
+
     def get_resolution(self):
         return Resolution.DAILY
 

Algorithm.Python/ConsolidateRegressionAlgorithm.py

@@ -25,7 +25,7 @@ class ConsolidateRegressionAlgorithm(QCAlgorithm):
         self.set_end_date(2020, 1, 20)
 
         SP500 = Symbol.create(Futures.Indices.SP_500_E_MINI, SecurityType.FUTURE, Market.CME)
-        symbol = self.future_chain_provider.get_future_contract_list(SP500, self.start_date)[0]
+        symbol = list(self.futures_chain(SP500))[0]
         self._future = self.add_future_contract(symbol)
 
         tradable_dates_count = len(list(Time.each_tradeable_day_in_time_zone(self._future.exchange.hours,

Algorithm.Python/FutureOptionChainFullDataRegressionAlgorithm.py

@@ -0,0 +1,46 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from AlgorithmImports import *
+
+### <summary>
+### Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.OptionChain(Symbol)"/> method
+### to get a future option chain.
+### </summary>
+class FutureOptionChainFullDataRegressionAlgorithm(QCAlgorithm):
+
+    def initialize(self):
+        self.set_start_date(2020, 1, 6)
+        self.set_end_date(2020, 1, 6)
+
+        future_contract = self.add_future_contract(
+            Symbol.create_future(Futures.Indices.SP_500_E_MINI, Market.CME, datetime(2020, 3, 20)),
+            Resolution.MINUTE).symbol
+
+        option_chain = self.option_chain(future_contract, flatten=True)
+
+        # Demonstration using data frame:
+        df = option_chain.data_frame
+        # Get contracts expiring within 4 months, with the latest expiration date, highest strike and lowest price
+        contracts = df.loc[(df.expiry <= self.time + timedelta(days=120))]
+        contracts = contracts.sort_values(['expiry', 'strike', 'lastprice'], ascending=[False, False, True])
+        self._option_contract = contracts.index[0]
+
+        self.add_future_option_contract(self._option_contract)
+
+    def on_data(self, data):
+        # Do some trading with the selected contract for sample purposes
+        if not self.portfolio.invested:
+            self.set_holdings(self._option_contract, 0.5)
+        else:
+            self.liquidate()

Algorithm.Python/FutureOptionChainsMultipleFullDataRegressionAlgorithm.py

@@ -0,0 +1,62 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from AlgorithmImports import *
+
+### <summary>
+### Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.OptionChains(IEnumerable{Symbol})"/> method
+### to get multiple future option chains.
+### </summary>
+class FutureOptionChainsMultipleFullDataRegressionAlgorithm(QCAlgorithm):
+
+    def initialize(self):
+        self.set_start_date(2020, 1, 6)
+        self.set_end_date(2020, 1, 6)
+
+        es_future_contract = self.add_future_contract(
+            Symbol.create_future(Futures.Indices.SP_500_E_MINI, Market.CME, datetime(2020, 3, 20)),
+            Resolution.MINUTE).symbol
+
+        gc_future_contract = self.add_future_contract(
+            Symbol.create_future(Futures.Metals.GOLD, Market.COMEX, datetime(2020, 4, 28)),
+            Resolution.MINUTE).symbol
+
+        chains = self.option_chains([es_future_contract, gc_future_contract], flatten=True)
+
+        self._es_option_contract = self.get_contract(chains, es_future_contract)
+        self._gc_option_contract = self.get_contract(chains, gc_future_contract)
+
+        self.add_future_option_contract(self._es_option_contract)
+        self.add_future_option_contract(self._gc_option_contract)
+
+    def get_contract(self, chains: OptionChains, underlying: Symbol) -> Symbol:
+        df = chains.data_frame
+
+        # Index by the requested underlying, by getting all data with canonicals which underlying is the requested underlying symbol:
+        canonicals = df.index.get_level_values('canonical')
+        condition = [canonical for canonical in canonicals if canonical.underlying == underlying]
+        contracts = df.loc[condition]
+
+        # Get contracts expiring within 4 months, with the latest expiration date, highest strike and lowest price
+        contracts = contracts.loc[(df.expiry <= self.time + timedelta(days=120))]
+        contracts = contracts.sort_values(['expiry', 'strike', 'lastprice'], ascending=[False, False, True])
+
+        return contracts.index[0][1]
+
+    def on_data(self, data):
+        # Do some trading with the selected contract for sample purposes
+        if not self.portfolio.invested:
+            self.set_holdings(self._es_option_contract, 0.25)
+            self.set_holdings(self._gc_option_contract, 0.25)
+        else:
+            self.liquidate()