Option universe resolution improvements (#8324)

* Option universe improvements

- Improvement for resolution handling of option universes, affecting
  performance in live mode. Adding regression algorithm

* Minor fix for research test

Algorithm.CSharp/AddAndRemoveOptionContractRegressionAlgorithm.cs

@@ -40,8 +40,8 @@ namespace QuantConnect.Algorithm.CSharp
 
             var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
 
-            _contract = OptionChainProvider.GetOptionContractList(aapl, Time)
-                .OrderBy(symbol => symbol.ID.Symbol)
+            _contract = OptionChain(aapl)
+                .OrderBy(x => x.ID.Symbol)
                 .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
                     && optionContract.ID.OptionStyle == OptionStyle.American);
             AddOptionContract(_contract);

Algorithm.CSharp/AddAndRemoveSecuritySameLoopRegressionAlgorithm.cs

@@ -39,8 +39,8 @@ namespace QuantConnect.Algorithm.CSharp
 
             var aapl = AddEquity("AAPL").Symbol;
 
-            _contract = OptionChainProvider.GetOptionContractList(aapl, Time)
-                .OrderBy(symbol => symbol.ID.Symbol)
+            _contract = OptionChain(aapl)
+                .OrderBy(x => x.ID.Symbol)
                 .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
                     && optionContract.ID.OptionStyle == OptionStyle.American);
         }

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -49,7 +49,7 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     foreach (var contract in futuresContracts)
                     {
-                        var option_contract_symbols = OptionChainProvider.GetOptionContractList(contract.Symbol, Time).ToList();
+                        var option_contract_symbols = OptionChain(contract.Symbol).ToList();
                         if(option_contract_symbols.Count == 0)
                         {
                             continue;

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -46,8 +46,8 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (_option == null)
             {
-                var option = OptionChainProvider.GetOptionContractList(_twx, Time)
-                    .OrderBy(symbol => symbol.ID.Symbol)
+                var option = OptionChain(_twx)
+                    .OrderBy(x => x.ID.Symbol)
                     .FirstOrDefault(optionContract => optionContract.ID.Date == _expiration
                                                       && optionContract.ID.OptionRight == OptionRight.Call
                                                       && optionContract.ID.OptionStyle == OptionStyle.American);

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -13,12 +13,12 @@
  * limitations under the License.
 */
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using QuantConnect.Data;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -110,14 +110,14 @@ namespace QuantConnect.Algorithm.CSharp
 
             foreach (var addedSecurity in changes.AddedSecurities)
             {
-                var option = OptionChainProvider.GetOptionContractList(addedSecurity.Symbol, Time)
-                    .OrderBy(symbol => symbol.ID.Symbol)
+                var option = OptionChain(addedSecurity.Symbol)
+                    .OrderBy(contractData => contractData.ID.Symbol)
                     .First(optionContract => optionContract.ID.Date == _expiration
                                                       && optionContract.ID.OptionRight == OptionRight.Call
                                                       && optionContract.ID.OptionStyle == OptionStyle.American);
                 AddOptionContract(option);
 
-                foreach (var symbol in new[] { option, option.Underlying })
+                foreach (var symbol in new[] { option.Symbol, option.Underlying.Symbol })
                 {
                     var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
 

Algorithm.CSharp/AddOptionContractTwiceRegressionAlgorithm.cs

@@ -43,8 +43,8 @@ namespace QuantConnect.Algorithm.CSharp
 
             var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
 
-            _contract = OptionChainProvider.GetOptionContractList(aapl, Time)
-                .OrderBy(symbol => symbol.ID.StrikePrice)
+            _contract = OptionChain(aapl)
+                .OrderBy(x => x.ID.StrikePrice)
                 .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
                     && optionContract.ID.OptionStyle == OptionStyle.American);
             AddOptionContract(_contract);

Algorithm.CSharp/AddTwoAndRemoveOneOptionContractRegressionAlgorithm.cs

@@ -41,8 +41,8 @@ namespace QuantConnect.Algorithm.CSharp
 
             var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
 
-            var contracts = OptionChainProvider.GetOptionContractList(aapl, Time)
-                .OrderBy(symbol => symbol.ID.StrikePrice)
+            var contracts = OptionChain(aapl)
+                .OrderBy(x => x.ID.StrikePrice)
                 .Where(optionContract => optionContract.ID.OptionRight == OptionRight.Call
                     && optionContract.ID.OptionStyle == OptionStyle.American)
                 .Take(2)

Algorithm.CSharp/BasicTemplateEurexFuturesAlgorithm.cs

@@ -0,0 +1,239 @@
+/*
+ * 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 QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This algorithm tests and demonstrates EUREX futures subscription and trading:
+    /// - It tests contracts rollover by adding a continuous future and asserting that mapping happens at some point.
+    /// - It tests basic trading by buying a contract and holding it until expiration.
+    /// - It tests delisting and asserts the holdings are liquidated after that.
+    /// </summary>
+    public class BasicTemplateEurexFuturesAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Future _continuousContract;
+        private Symbol _mappedSymbol;
+        private Symbol _contractToTrade;
+        private int _mappingsCount;
+        private decimal _boughtQuantity;
+        private decimal _liquidatedQuantity;
+        private bool _delisted;
+
+        public override void Initialize()
+        {
+            SetStartDate(2024, 5, 30);
+            SetEndDate(2024, 6, 23);
+
+            SetAccountCurrency(Currencies.EUR);
+            SetCash(1000000);
+
+            _continuousContract = AddFuture(Futures.Indices.EuroStoxx50, Resolution.Minute,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.FirstDayMonth,
+                contractDepthOffset: 0);
+            _continuousContract.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(180));
+            _mappedSymbol = _continuousContract.Mapped;
+
+            var benchmark = AddIndex("SX5E", market: Market.EUREX);
+            SetBenchmark(benchmark.Symbol);
+
+            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
+            SetSecurityInitializer(security => seeder.SeedSecurity(security));
+        }
+
+        public override void OnData(Slice slice)
+        {
+            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
+            {
+                if (++_mappingsCount > 1)
+                {
+                    throw new RegressionTestException($"{Time} - Unexpected number of symbol changed events (mappings): {_mappingsCount}. " +
+                        $"Expected only 1.");
+                }
+
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+
+                if (changedEvent.OldSymbol != _mappedSymbol.ID.ToString())
+                {
+                    throw new RegressionTestException($"{Time} - Unexpected symbol changed event old symbol: {changedEvent}");
+                }
+
+                if (changedEvent.NewSymbol != _continuousContract.Mapped.ID.ToString())
+                {
+                    throw new RegressionTestException($"{Time} - Unexpected symbol changed event new symbol: {changedEvent}");
+                }
+
+                // Let's trade the previous mapped contract, so we can hold it until expiration for testing
+                // (will be sooner than the new mapped contract)
+                _contractToTrade = _mappedSymbol;
+                _mappedSymbol = _continuousContract.Mapped;
+            }
+
+            // Let's trade after the mapping is done
+            if (_contractToTrade != null && _boughtQuantity == 0 && Securities[_contractToTrade].Exchange.ExchangeOpen)
+            {
+                Buy(_contractToTrade, 1);
+            }
+
+            if (_contractToTrade != null && slice.Delistings.TryGetValue(_contractToTrade, out var delisting))
+            {
+                if (delisting.Type == DelistingType.Delisted)
+                {
+                    _delisted = true;
+
+                    if (Portfolio.Invested)
+                    {
+                        throw new RegressionTestException($"{Time} - Portfolio should not be invested after the traded contract is delisted.");
+                    }
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Symbol != _contractToTrade)
+            {
+                throw new RegressionTestException($"{Time} - Unexpected order event symbol: {orderEvent.Symbol}. Expected {_contractToTrade}");
+            }
+
+            if (orderEvent.Direction == OrderDirection.Buy)
+            {
+                if (orderEvent.Status == OrderStatus.Filled)
+                {
+                    if (_boughtQuantity != 0 && _liquidatedQuantity != 0)
+                    {
+                        throw new RegressionTestException($"{Time} - Unexpected buy order event status: {orderEvent.Status}");
+                    }
+                    _boughtQuantity = orderEvent.Quantity;
+                }
+            }
+            else if (orderEvent.Direction == OrderDirection.Sell)
+            {
+                if (orderEvent.Status == OrderStatus.Filled)
+                {
+                    if (_boughtQuantity <= 0 && _liquidatedQuantity != 0)
+                    {
+                        throw new RegressionTestException($"{Time} - Unexpected sell order event status: {orderEvent.Status}");
+                    }
+                    _liquidatedQuantity = orderEvent.Quantity;
+
+                    if (_liquidatedQuantity != -_boughtQuantity)
+                    {
+                        throw new RegressionTestException($"{Time} - Unexpected liquidated quantity: {_liquidatedQuantity}. Expected: {-_boughtQuantity}");
+                    }
+                }
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            foreach (var addedSecurity in changes.AddedSecurities)
+            {
+                if (addedSecurity.Symbol.SecurityType == SecurityType.Future && addedSecurity.Symbol.IsCanonical())
+                {
+                    _mappedSymbol = _continuousContract.Mapped;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_mappingsCount == 0)
+            {
+                throw new RegressionTestException($"Unexpected number of symbol changed events (mappings): {_mappingsCount}. Expected 1.");
+            }
+
+            if (!_delisted)
+            {
+                throw new RegressionTestException("Contract was not delisted");
+            }
+
+            // Make sure we traded and that the position was liquidated on delisting
+            if (_boughtQuantity <= 0 || _liquidatedQuantity >= 0)
+            {
+                throw new RegressionTestException($"Unexpected sold quantity: {_boughtQuantity} and liquidated quantity: {_liquidatedQuantity}");
+            }
+        }
+
+        /// <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 => 133945;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 26;
+
+        /// <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", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.11%"},
+            {"Compounding Annual Return", "-1.667%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "-1"},
+            {"Start Equity", "1000000"},
+            {"End Equity", "998849.48"},
+            {"Net Profit", "-0.115%"},
+            {"Sharpe Ratio", "-34.455"},
+            {"Sortino Ratio", "-57.336"},
+            {"Probabilistic Sharpe Ratio", "0.002%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0.002"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-6.176"},
+            {"Tracking Error", "0.002"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "€1.02"},
+            {"Estimated Strategy Capacity", "€2300000000.00"},
+            {"Lowest Capacity Asset", "FESX YJHOAMPYKRS5"},
+            {"Portfolio Turnover", "0.40%"},
+            {"OrderListHash", "54040d29a467becaedcf59d79323321b"}
+        };
+    }
+}

Algorithm.CSharp/DelayedSettlementAfterManualSecurityRemovalAlgorithm.cs

@@ -37,9 +37,9 @@ namespace QuantConnect.Algorithm.CSharp
 
             var equity = AddEquity("GOOG");
 
-            _optionSymbol = OptionChainProvider.GetOptionContractList(equity.Symbol, Time)
-                .OrderBy(symbol => symbol.ID.StrikePrice)
-                .ThenByDescending(symbol => symbol.ID.Date)
+            _optionSymbol = OptionChain(equity.Symbol)
+                .OrderBy(x => x.ID.StrikePrice)
+                .ThenByDescending(x => x.ID.Date)
                 .First(optionContract => optionContract.ID.OptionRight == OptionRight.Call);
             var option = AddOptionContract(_optionSymbol);
 

Algorithm.CSharp/DelistedIndexOptionDivestedRegression.cs

@@ -51,10 +51,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             if (_addOption)
             {
-                var contracts = OptionChainProvider.GetOptionContractList(_spx, Time);
-                contracts = contracts.Where(x =>
-                    x.ID.OptionRight == OptionRight.Put &&
-                    x.ID.Date.Date == new DateTime(2021, 1, 15));
+                var contracts = OptionChain(_spx).Where(x => x.ID.OptionRight == OptionRight.Put && x.ID.Date.Date == new DateTime(2021, 1, 15));
 
                 var option = AddIndexOptionContract(contracts.First(), Resolution.Minute);
                 _optionExpiry = option.Expiry;

Algorithm.CSharp/FutureOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -58,10 +58,10 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            var esOptions = OptionChainProvider.GetOptionContractList(es20m20, Time)
-                .Concat(OptionChainProvider.GetOptionContractList(es20h20, Time))
-                .Where(x => x.ID.StrikePrice == 3200m && x.ID.OptionRight == OptionRight.Call)
-                .Select(x => AddFutureOptionContract(x, Resolution.Minute).Symbol)
+            var esOptions = OptionChain(es20m20)
+                .Concat(OptionChain(es20h20))
+                .Where(contractData => contractData.ID.StrikePrice == 3200m && contractData.ID.OptionRight == OptionRight.Call)
+                .Select(contractData => AddFutureOptionContract(contractData, Resolution.Minute).Symbol)
                 .ToList();
 
             var expectedContracts = new[]

Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs

@@ -53,7 +53,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -55,7 +55,7 @@ namespace QuantConnect.Algorithm.CSharp
                 TimeSpan.FromMinutes(1));
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20.Symbol, new DateTime(2020, 1, 5))
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20.Symbol)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -59,9 +59,9 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option call expiring OTM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
-                .Where(x => x.ID.StrikePrice >= 3300m && x.ID.OptionRight == OptionRight.Call)
-                .OrderBy(x => x.ID.StrikePrice)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
+                .Where(contractData => contractData.ID.StrikePrice >= 3300m && contractData.ID.OptionRight == OptionRight.Call)
+                .OrderBy(contractData => contractData.ID.StrikePrice)
                 .Take(1)
                 .Single(), Resolution.Minute).Symbol;
 

Algorithm.CSharp/FutureOptionDailyRegressionAlgorithm.cs

@@ -47,7 +47,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution).Symbol;
 
             // Attempt to fetch a specific future option contract
-            DcOption = OptionChainProvider.GetOptionContractList(dc, Time)
+            DcOption = OptionChain(dc)
                 .Where(x => x.ID.StrikePrice == 17m && x.ID.OptionRight == OptionRight.Call)
                 .Select(x => AddFutureOptionContract(x, Resolution).Symbol)
                 .FirstOrDefault();

Algorithm.CSharp/FutureOptionIndicatorsRegressionAlgorithm.cs

@@ -32,7 +32,7 @@ namespace QuantConnect.Algorithm.CSharp
             var underlying = AddFutureContract(QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 3, 20)),
                 Resolution.Minute).Symbol;
 
-            var option = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(underlying, Time)
+            var option = AddFutureOptionContract(OptionChain(underlying)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionPutITMExpiryRegressionAlgorithm.cs

@@ -54,7 +54,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice >= 3300m && x.ID.OptionRight == OptionRight.Put)
                 .OrderBy(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionPutOTMExpiryRegressionAlgorithm.cs

@@ -58,7 +58,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice <= 3150m && x.ID.OptionRight == OptionRight.Put)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionShortCallITMExpiryRegressionAlgorithm.cs

@@ -54,7 +54,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice <= 3100m && x.ID.OptionRight == OptionRight.Call)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionShortCallOTMExpiryRegressionAlgorithm.cs

@@ -55,7 +55,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice >= 3400m && x.ID.OptionRight == OptionRight.Call)
                 .OrderBy(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionShortPutITMExpiryRegressionAlgorithm.cs

@@ -54,7 +54,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice <= 3400m && x.ID.OptionRight == OptionRight.Put)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/FutureOptionShortPutOTMExpiryRegressionAlgorithm.cs

@@ -55,7 +55,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice <= 3000m && x.ID.OptionRight == OptionRight.Put)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -46,7 +46,7 @@ namespace QuantConnect.Algorithm.CSharp
             var spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            var spxOptions = OptionChainProvider.GetOptionContractList(spx, Time)
+            var spxOptions = OptionChain(spx)
                 .Where(x => (x.ID.StrikePrice == 3700m || x.ID.StrikePrice == 3800m) && x.ID.OptionRight == OptionRight.Call && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .Select(x => AddIndexOptionContract(x, Resolution.Minute).Symbol)
                 .OrderBy(x => x.ID.StrikePrice)

Algorithm.CSharp/IndexOptionCallITMExpiryRegressionAlgorithm.cs

@@ -51,7 +51,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution).Symbol;
 
             // Select an index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -45,7 +45,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = spx.Symbol;
 
             // Select an index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -56,7 +56,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution).Symbol;
 
             // Select a index option call expiring OTM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice >= 4250m && x.ID.OptionRight == OptionRight.Call && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderBy(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionPutITMExpiryRegressionAlgorithm.cs

@@ -48,7 +48,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice >= 4200m && x.ID.OptionRight == OptionRight.Put && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderBy(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionPutOTMExpiryRegressionAlgorithm.cs

@@ -53,7 +53,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Put && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionShortCallITMExpiryRegressionAlgorithm.cs

@@ -60,9 +60,9 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            _esOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
-                .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
-                .OrderByDescending(x => x.ID.StrikePrice)
+            _esOption = AddIndexOptionContract(OptionChain(_spx)
+                .Where(contractData => contractData.ID.StrikePrice <= 3200m && contractData.ID.OptionRight == OptionRight.Call && contractData.ID.Date.Year == 2021 && contractData.ID.Date.Month == 1)
+                .OrderByDescending(contractData => contractData.ID.StrikePrice)
                 .Take(1)
                 .Single(), Resolution.Minute).Symbol;
 

Algorithm.CSharp/IndexOptionShortCallOTMExpiryRegressionAlgorithm.cs

@@ -50,7 +50,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice >= 4250m && x.ID.OptionRight == OptionRight.Call && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderBy(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/IndexOptionShortPutITMExpiryRegressionAlgorithm.cs

@@ -59,9 +59,9 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
-                .Where(x => x.ID.StrikePrice <= 4200m && x.ID.OptionRight == OptionRight.Put && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
-                .OrderByDescending(x => x.ID.StrikePrice)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
+                .Where(contractData => contractData.ID.StrikePrice <= 4200m && contractData.ID.OptionRight == OptionRight.Put && contractData.ID.Date.Year == 2021 && contractData.ID.Date.Month == 1)
+                .OrderByDescending(contractData => contractData.ID.StrikePrice)
                 .Take(1)
                 .Single(), Resolution.Minute).Symbol;
 

Algorithm.CSharp/IndexOptionShortPutOTMExpiryRegressionAlgorithm.cs

@@ -50,7 +50,7 @@ namespace QuantConnect.Algorithm.CSharp
             _spx = AddIndex("SPX", Resolution.Minute).Symbol;
 
             // Select a index option expiring ITM, and adds it to the algorithm.
-            _spxOption = AddIndexOptionContract(OptionChainProvider.GetOptionContractList(_spx, Time)
+            _spxOption = AddIndexOptionContract(OptionChain(_spx)
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Put && x.ID.Date.Year == 2021 && x.ID.Date.Month == 1)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/InsufficientBuyingPowerForAutomaticExerciseRegressionAlgorithm.cs

@@ -44,7 +44,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             _stock = AddEquity("GOOG").Symbol;
 
-            var contracts = OptionChainProvider.GetOptionContractList(_stock, UtcTime).ToList();
+            var contracts = OptionChain(_stock).ToList();
             _option = contracts
                 .Where(c => c.ID.OptionRight == OptionRight.Put)
                 .OrderBy(c => c.ID.Date)

Algorithm.CSharp/LargeQuantityOptionStrategyAlgorithm.cs

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

Algorithm.CSharp/OptionAssignmentRegressionAlgorithm.cs

@@ -46,7 +46,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetCash(100000);
             Stock = AddEquity("GOOG", Resolution.Minute);
 
-            var contracts = OptionChainProvider.GetOptionContractList(Stock.Symbol, UtcTime).ToList();
+            var contracts = OptionChain(Stock.Symbol).ToList();
 
             PutOptionSymbol = contracts
                 .Where(c => c.ID.OptionRight == OptionRight.Put)

Algorithm.CSharp/OptionAssignmentStatisticsRegressionAlgorithm.cs

@@ -48,7 +48,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             _goog = AddEquity("GOOG", Resolution.Minute);
 
-            var contracts = OptionChainProvider.GetOptionContractList(_goog.Symbol, UtcTime).ToList();
+            var contracts = OptionChain(_goog.Symbol).ToList();
 
             _googCall600Symbol = contracts
                 .Where(c => c.ID.OptionRight == OptionRight.Call)

Algorithm.CSharp/OptionChainFullDataRegressionAlgorithm.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 an option chain, which contains additional data besides the symbols, including prices, implied volatility and greeks.
+    /// It also shows how this data can be used to filter the contracts based on certain criteria.
+    /// </summary>
+    public class OptionChainFullDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _optionContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+
+            var goog = AddEquity("GOOG").Symbol;
+
+            _optionContract = OptionChain(goog)
+                // Get contracts expiring within 10 days, with an implied volatility greater than 0.5 and a delta less than 0.5
+                .Where(contractData => contractData.ID.Date - Time <= TimeSpan.FromDays(10) &&
+                    contractData.ImpliedVolatility > 0.5m &&
+                    contractData.Greeks.Delta < 0.5m)
+                // Get the contract with the latest expiration date
+                .OrderByDescending(x => x.ID.Date)
+                .First();
+
+            AddOptionContract(_optionContract);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Do some trading with the selected contract for sample purposes
+            if (!Portfolio.Invested)
+            {
+                MarketOrder(_optionContract, 1);
+            }
+            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 => 1057;
+
+        /// <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", "210"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "96041"},
+            {"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", "$209.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "GOOCV W6U7PD1F2WYU|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "85.46%"},
+            {"OrderListHash", "a7ab1a9e64fe9ba76ea33a40a78a4e3b"}
+        };
+    }
+}

Algorithm.CSharp/OptionChainedAndUniverseSelectionRegressionAlgorithm.cs

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

Algorithm.CSharp/OptionOTMExpiryOrderHasZeroPriceRegressionAlgorithm.cs

@@ -58,7 +58,7 @@ namespace QuantConnect.Algorithm.CSharp
                 Resolution.Minute).Symbol;
 
             // Select a future option call expiring OTM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, Time)
+            _esOption = AddFutureOptionContract(OptionChain(_es19m20)
                 .Where(x => x.ID.StrikePrice >= 3300m && x.ID.OptionRight == OptionRight.Call)
                 .OrderBy(x => x.ID.StrikePrice)
                 .Take(1)

Algorithm.CSharp/OptionResolutionRegressionAlgorithm.cs

@@ -0,0 +1,137 @@
+/*
+ * 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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting the resolution being used for options universe and it's data respecting universe settings
+    /// </summary>
+    public class OptionResolutionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _optionSymbol;
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+
+            UniverseSettings.Resolution = Resolution.Daily;
+
+            var option = AddOption("GOOG");
+            option.SetFilter(u => u.Strikes(-2, +2).Expiration(0, 180));
+            _optionSymbol = option.Symbol;
+
+            if (UniverseManager.TryGetValue(option.Symbol, out var universe)
+                && (universe.Configuration.Resolution != Resolution.Daily || universe.UniverseSettings.Resolution != Resolution.Daily))
+            {
+                throw new RegressionTestException("Unexpected universe resolution configuration!");
+            }
+        }
+
+        /// <summary>
+        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
+        /// </summary>
+        /// <param name="slice">The current slice of data keyed by symbol string</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    // we find at the money (ATM) put contract with farthest expiration
+                    var atmContract = chain
+                        .OrderByDescending(x => x.Expiry)
+                        .ThenBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
+                        .ThenByDescending(x => x.Right)
+                        .FirstOrDefault();
+
+                    if (atmContract != null)
+                    {
+                        // if found, trade it
+                        MarketOrder(atmContract.Symbol, 1);
+                    }
+                }
+            }
+        }
+
+        /// <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 };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 4274;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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", "1"},
+            {"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", "ce4cdd4d05199b633559cd14bc6db237"}
+        };
+    }
+}

Algorithm.CSharp/OptionSymbolCanonicalRegressionAlgorithm.cs

@@ -36,7 +36,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2014, 06, 09);
 
             var equitySymbol = AddEquity("TWX").Symbol;
-            var contracts = OptionChainProvider.GetOptionContractList(equitySymbol, UtcTime).ToList();
+            var contracts = OptionChain(equitySymbol).ToList();
 
             var callOptionSymbol = contracts
                 .Where(c => c.ID.OptionRight == OptionRight.Call)

Algorithm.CSharp/OptionTimeSliceRegressionAlgorithm.cs

@@ -54,7 +54,7 @@ namespace QuantConnect.Algorithm.CSharp
             _lastSliceTime = Time;
 
             var underlyingPrice = Securities[_symbol].Price;
-            var contractSymbol = OptionChainProvider.GetOptionContractList(_symbol, Time)
+            var contractSymbol = OptionChain(_symbol)
                 .Where(x => x.ID.StrikePrice - underlyingPrice > 0)
                 .OrderBy(x => x.ID.Date)
                 .FirstOrDefault();
@@ -91,7 +91,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 3;
+        public int AlgorithmHistoryDataPoints => 787;
 
         /// <summary>
         /// Final status of the algorithm

Algorithm.CSharp/RegressionTests/CustomData/CustomDataIconicTypesDefaultResolutionRegressionAlgorithm.cs

@@ -71,9 +71,9 @@ namespace QuantConnect.Algorithm.CSharp
 
             var option = AddOption("AAPL");
             if (SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(option.Symbol)
-                .Any(config => config.Resolution != Resolution.Minute))
+                .Any(config => config.Resolution != Resolution.Daily))
             {
-                throw new RegressionTestException("Was expecting resolution to be set to Minute");
+                throw new RegressionTestException("Was expecting resolution to be set to Daily");
             }
         }
 

Algorithm.CSharp/UniverseSelectionSymbolCacheRemovalRegressionTest.cs

@@ -1,4 +1,4 @@
- 
+
 /*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
@@ -43,7 +43,7 @@ namespace QuantConnect.Algorithm.CSharp
             AddEquity("AAPL", Resolution.Daily);
             _equitySymbol = AddEquity("TWX", Resolution.Minute).Symbol;
 
-            var contracts = OptionChainProvider.GetOptionContractList(_equitySymbol, UtcTime).ToList();
+            var contracts = OptionChain(_equitySymbol).ToList();
 
             var callOptionSymbol = contracts
                 .Where(c => c.ID.OptionRight == OptionRight.Call)

Algorithm.CSharp/ZeroDTEOptionsRegressionAlgorithm.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.Interfaces;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm asserting that options are selected every day and that selection for 0DTE contracts works as expected,
+    /// always including the contracts that expire the same date the option chain belongs to.
+    /// </summary>
+    public class ZeroDTEOptionsRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private List<DateTime> _selectionDays;
+        private int _currentSelectionDayIndex;
+
+        private int _previouslyAddedContracts;
+
+        public override void Initialize()
+        {
+            SetStartDate(2024, 01, 01);
+            SetEndDate(2024, 01, 10);
+            SetCash(100000);
+
+            var equity = AddEquity("SPY");
+            var option = AddOption(equity.Symbol);
+
+            option.SetFilter(u => u.IncludeWeeklys().Expiration(0, 0));
+
+            // use the underlying equity as the benchmark
+            SetBenchmark(equity.Symbol);
+
+            _selectionDays = new List<DateTime>()
+            {
+                new DateTime(2024, 01, 01), // Sunday midnight, already Monday 1st, it's a holiday. Selection happens for Tuesday here
+                new DateTime(2024, 01, 03), // Wednesday, midnight
+                new DateTime(2024, 01, 04),
+                new DateTime(2024, 01, 05),
+                new DateTime(2024, 01, 06), // Friday midnight, selection happens for Monday here
+                new DateTime(2024, 01, 09), // Monday midnight, already Tuesday, selection happens for Tuesday here
+                new DateTime(2024, 01, 10),
+            };
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            // We expect selection every trading day
+            if (Time.Date != _selectionDays[_currentSelectionDayIndex++])
+            {
+                throw new RegressionTestException($"Unexpected date. Expected {_selectionDays[_currentSelectionDayIndex]} but was {Time.Date}");
+            }
+
+            var addedOptions = changes.AddedSecurities.Where(x => x.Symbol.SecurityType == SecurityType.Option && !x.Symbol.IsCanonical()).ToList();
+
+            if (addedOptions.Count == 0)
+            {
+                throw new RegressionTestException("No options were added");
+            }
+
+            var removedOptions = changes.RemovedSecurities.Where(x => x.Symbol.SecurityType == SecurityType.Option && !x.Symbol.IsCanonical()).ToList();
+
+            // Since we are selecting only 0DTE contracts, they must be deselected that same day
+            if (removedOptions.Count != _previouslyAddedContracts)
+            {
+                throw new RegressionTestException($"Unexpected number of removed contracts. Expected {_previouslyAddedContracts} but was {removedOptions.Count}");
+            }
+            _previouslyAddedContracts = addedOptions.Count;
+        }
+
+        /// <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 };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 227;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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.Python/AddOptionContractExpiresRegressionAlgorithm.py

@@ -43,7 +43,7 @@ class AddOptionContractExpiresRegressionAlgorithm(QCAlgorithm):
             data: Slice object keyed by symbol containing the stock data
         '''
         if self._option == None:
-            options = self.option_chain_provider.get_option_contract_list(self._twx, self.time)
+            options = self.option_chain(self._twx)
             options = sorted(options, key=lambda x: x.id.symbol)
 
             option = next((option

Algorithm.Python/AddOptionContractFromUniverseRegressionAlgorithm.py

@@ -67,7 +67,7 @@ class AddOptionContractFromUniverseRegressionAlgorithm(QCAlgorithm):
             return
 
         for addedSecurity in changes.added_securities:
-            options = self.option_chain_provider.get_option_contract_list(addedSecurity.symbol, self.time)
+            options = self.option_chain(addedSecurity.symbol)
             options = sorted(options, key=lambda x: x.id.symbol)
 
             option = next((option

Algorithm.Python/BasicTemplateEurexFuturesAlgorithm.py

@@ -0,0 +1,120 @@
+# 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>
+### This algorithm tests and demonstrates EUREX futures subscription and trading:
+### - It tests contracts rollover by adding a continuous future and asserting that mapping happens at some point.
+### - It tests basic trading by buying a contract and holding it until expiration.
+### - It tests delisting and asserts the holdings are liquidated after that.
+### </summary>
+class BasicTemplateEurexFuturesAlgorithm(QCAlgorithm):
+    def __init__(self):
+        super().__init__()
+        self._continuous_contract = None
+        self._mapped_symbol = None
+        self._contract_to_trade = None
+        self._mappings_count = 0
+        self._bought_quantity = 0
+        self._liquidated_quantity = 0
+        self._delisted = False
+
+    def initialize(self):
+        self.set_start_date(2024, 5, 30)
+        self.set_end_date(2024, 6, 23)
+
+        self.set_account_currency(Currencies.EUR);
+        self.set_cash(1000000)
+
+        self._continuous_contract = self.add_future(
+            Futures.Indices.EURO_STOXX_50,
+            Resolution.MINUTE,
+            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
+            data_mapping_mode=DataMappingMode.FIRST_DAY_MONTH,
+            contract_depth_offset=0,
+        )
+        self._continuous_contract.set_filter(timedelta(days=0), timedelta(days=180))
+        self._mapped_symbol = self._continuous_contract.mapped
+
+        benchmark = self.add_index("SX5E", market=Market.EUREX)
+        self.set_benchmark(benchmark.symbol)
+
+        func_seeder = FuncSecuritySeeder(self.get_last_known_prices)
+        self.set_security_initializer(lambda security: func_seeder.seed_security(security))
+
+    def on_data(self, slice):
+        for changed_event in slice.symbol_changed_events.values():
+            self._mappings_count += 1
+            if self._mappings_count > 1:
+                raise Exception(f"{self.time} - Unexpected number of symbol changed events (mappings): {self._mappings_count}. Expected only 1.")
+
+            self.debug(f"{self.time} - SymbolChanged event: {changed_event}")
+
+            if changed_event.old_symbol != str(self._mapped_symbol.id):
+                raise Exception(f"{self.time} - Unexpected symbol changed event old symbol: {changed_event}")
+
+            if changed_event.new_symbol != str(self._continuous_contract.mapped.id):
+                raise Exception(f"{self.time} - Unexpected symbol changed event new symbol: {changed_event}")
+
+            # Let's trade the previous mapped contract, so we can hold it until expiration for testing
+            # (will be sooner than the new mapped contract)
+            self._contract_to_trade = self._mapped_symbol
+            self._mapped_symbol = self._continuous_contract.mapped
+
+        # Let's trade after the mapping is done
+        if self._contract_to_trade is not None and self._bought_quantity == 0 and self.securities[self._contract_to_trade].exchange.exchange_open:
+            self.buy(self._contract_to_trade, 1)
+
+        if self._contract_to_trade is not None and slice.delistings.contains_key(self._contract_to_trade):
+            delisting = slice.delistings[self._contract_to_trade]
+            if delisting.type == DelistingType.DELISTED:
+                self._delisted = True
+
+                if self.portfolio.invested:
+                    raise Exception(f"{self.time} - Portfolio should not be invested after the traded contract is delisted.")
+
+    def on_order_event(self, order_event):
+        if order_event.symbol != self._contract_to_trade:
+            raise Exception(f"{self.time} - Unexpected order event symbol: {order_event.symbol}. Expected {self._contract_to_trade}")
+
+        if order_event.direction == OrderDirection.BUY:
+            if order_event.status == OrderStatus.FILLED:
+                if self._bought_quantity != 0 and self._liquidated_quantity != 0:
+                    raise Exception(f"{self.time} - Unexpected buy order event status: {order_event.status}")
+
+                self._bought_quantity = order_event.quantity
+        elif order_event.direction == OrderDirection.SELL:
+            if order_event.status == OrderStatus.FILLED:
+                if self._bought_quantity <= 0 and self._liquidated_quantity != 0:
+                    raise Exception(f"{self.time} - Unexpected sell order event status: {order_event.status}")
+
+                self._liquidated_quantity = order_event.quantity
+                if self._liquidated_quantity != -self._bought_quantity:
+                    raise Exception(f"{self.time} - Unexpected liquidated quantity: {self._liquidated_quantity}. Expected: {-self._bought_quantity}")
+
+    def on_securities_changed(self, changes):
+        for added_security in changes.added_securities:
+            if added_security.symbol.security_type == SecurityType.FUTURE and added_security.symbol.is_canonical():
+                self._mapped_symbol = self._continuous_contract.mapped
+
+    def on_end_of_algorithm(self):
+        if self._mappings_count == 0:
+            raise Exception(f"Unexpected number of symbol changed events (mappings): {self._mappings_count}. Expected 1.")
+
+        if not self._delisted:
+            raise Exception("Contract was not delisted")
+
+        # Make sure we traded and that the position was liquidated on delisting
+        if self._bought_quantity <= 0 or self._liquidated_quantity >= 0:
+            raise Exception(f"Unexpected sold quantity: {self._bought_quantity} and liquidated quantity: {self._liquidated_quantity}")

Algorithm.Python/FutureOptionBuySellCallIntradayRegressionAlgorithm.py

@@ -52,8 +52,7 @@ class FutureOptionBuySellCallIntradayRegressionAlgorithm(QCAlgorithm):
         # Select a future option expiring ITM, and adds it to the algorithm.
         self.es_options = [
             self.add_future_option_contract(i, Resolution.MINUTE).symbol
-            for i in (self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) +
-                self.option_chain_provider.get_option_contract_list(self.es20h20, self.time))
+            for i in (list(self.option_chain(self.es19m20)) + list(self.option_chain(self.es20h20)))
             if i.id.strike_price == 3200.0 and i.id.option_right == OptionRight.CALL
         ]
 

Algorithm.Python/FutureOptionCallITMExpiryRegressionAlgorithm.py

@@ -41,7 +41,8 @@ class FutureOptionCallITMExpiryRegressionAlgorithm(QCAlgorithm):
         # Select a future option expiring ITM, and adds it to the algorithm.
         self.es_option = self.add_future_option_contract(
             list(
-                sorted([x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price <= 3200.0 and x.id.option_right == OptionRight.CALL], key=lambda x: x.id.strike_price, reverse=True)
+                sorted([x for x in self.option_chain(self.es19m20) if x.id.strike_price <= 3200.0 and x.id.option_right == OptionRight.CALL],
+                       key=lambda x: x.id.strike_price, reverse=True)
             )[0], Resolution.MINUTE).symbol
 
         self.expected_contract = Symbol.create_option(self.es19m20, Market.CME, OptionStyle.AMERICAN, OptionRight.CALL, 3200.0, datetime(2020, 6, 19))

Algorithm.Python/FutureOptionCallOTMExpiryRegressionAlgorithm.py

@@ -45,7 +45,8 @@ class FutureOptionCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.es_option = self.add_future_option_contract(
             list(
                 sorted(
-                    [x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price >= 3300.0 and x.id.option_right == OptionRight.CALL],
+                    [x for x in self.option_chain(self.es19m20)
+                     if x.id.strike_price >= 3300.0 and x.id.option_right == OptionRight.CALL],
                     key=lambda x: x.id.strike_price
                 )
             )[0], Resolution.MINUTE).symbol

Algorithm.Python/FutureOptionDailyRegressionAlgorithm.py

@@ -34,7 +34,9 @@ class FutureOptionDailyRegressionAlgorithm(QCAlgorithm):
 
         # Attempt to fetch a specific ITM future option contract
         dc_options = [
-            self.add_future_option_contract(x, resolution).symbol for x in (self.option_chain_provider.get_option_contract_list(self.dc, self.time)) if x.id.strike_price == 17 and x.id.option_right == OptionRight.CALL
+            self.add_future_option_contract(x, resolution).symbol
+            for x in self.option_chain(self.dc)
+            if x.id.strike_price == 17 and x.id.option_right == OptionRight.CALL
         ]
         self.dc_option = dc_options[0]
 

Algorithm.Python/FutureOptionPutITMExpiryRegressionAlgorithm.py

@@ -40,7 +40,8 @@ class FutureOptionPutITMExpiryRegressionAlgorithm(QCAlgorithm):
         # Select a future option expiring ITM, and adds it to the algorithm.
         self.es_option = self.add_future_option_contract(
             list(
-                sorted([x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price >= 3300.0 and x.id.option_right == OptionRight.PUT], key=lambda x: x.id.strike_price)
+                sorted([x for x in self.option_chain(self.es19m20) if x.id.strike_price >= 3300.0 and x.id.option_right == OptionRight.PUT],
+                       key=lambda x: x.id.strike_price)
             )[0], Resolution.MINUTE).symbol
 
         self.expected_contract = Symbol.create_option(self.es19m20, Market.CME, OptionStyle.AMERICAN, OptionRight.PUT, 3300.0, datetime(2020, 6, 19))

Algorithm.Python/FutureOptionPutOTMExpiryRegressionAlgorithm.py

@@ -45,7 +45,7 @@ class FutureOptionPutOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.es_option = self.add_future_option_contract(
             list(
                 sorted(
-                    [x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price <= 3150.0 and x.id.option_right == OptionRight.PUT],
+                    [x for x in self.option_chain(self.es19m20) if x.id.strike_price <= 3150.0 and x.id.option_right == OptionRight.PUT],
                     key=lambda x: x.id.strike_price,
                     reverse=True
                 )
@@ -71,7 +71,7 @@ class FutureOptionPutOTMExpiryRegressionAlgorithm(QCAlgorithm):
             if delisting.type == DelistingType.DELISTED:
                 if delisting.time != datetime(2020, 6, 20):
                     raise AssertionError(f"Delisting happened at unexpected date: {delisting.time}")
-                
+
     def on_order_event(self, order_event: OrderEvent):
         if order_event.status != OrderStatus.FILLED:
             # There's lots of noise with OnOrderEvent, but we're only interested in fills.

Algorithm.Python/FutureOptionShortCallITMExpiryRegressionAlgorithm.py

@@ -41,7 +41,7 @@ class FutureOptionShortCallITMExpiryRegressionAlgorithm(QCAlgorithm):
         self.es_option = self.add_future_option_contract(
             list(
                 sorted(
-                    [x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price <= 3100.0 and x.id.option_right == OptionRight.CALL],
+                    [x for x in self.option_chain(self.es19m20) if x.id.strike_price <= 3100.0 and x.id.option_right == OptionRight.CALL],
                     key=lambda x: x.id.strike_price,
                     reverse=True
                 )

Algorithm.Python/FutureOptionShortCallOTMExpiryRegressionAlgorithm.py

@@ -42,7 +42,7 @@ class FutureOptionShortCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.es_option = self.add_future_option_contract(
             list(
                 sorted(
-                    [x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price >= 3400.0 and x.id.option_right == OptionRight.CALL],
+                    [x for x in self.option_chain(self.es19m20) if x.id.strike_price >= 3400.0 and x.id.option_right == OptionRight.CALL],
                     key=lambda x: x.id.strike_price
                 )
             )[0], Resolution.MINUTE).symbol

Algorithm.Python/FutureOptionShortPutITMExpiryRegressionAlgorithm.py

@@ -41,7 +41,7 @@ class FutureOptionShortPutITMExpiryRegressionAlgorithm(QCAlgorithm):
         self.es_option = self.add_future_option_contract(
             list(
                 sorted(
-                    [x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price <= 3400.0 and x.id.option_right == OptionRight.PUT],
+                    [x for x in self.option_chain(self.es19m20) if x.id.strike_price <= 3400.0 and x.id.option_right == OptionRight.PUT],
                     key=lambda x: x.id.strike_price,
                     reverse=True
                 )

Algorithm.Python/FutureOptionShortPutOTMExpiryRegressionAlgorithm.py

@@ -42,7 +42,7 @@ class FutureOptionShortPutOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.es_option = self.add_future_option_contract(
             list(
                 sorted(
-                    [x for x in self.option_chain_provider.get_option_contract_list(self.es19m20, self.time) if x.id.strike_price <= 3000.0 and x.id.option_right == OptionRight.PUT],
+                    [x for x in self.option_chain(self.es19m20) if x.id.strike_price <= 3000.0 and x.id.option_right == OptionRight.PUT],
                     key=lambda x: x.id.strike_price,
                     reverse=True
                 )

Algorithm.Python/IndexOptionBuySellCallIntradayRegressionAlgorithm.py

@@ -38,7 +38,7 @@ class IndexOptionBuySellCallIntradayRegressionAlgorithm(QCAlgorithm):
         # Select a index option expiring ITM, and adds it to the algorithm.
         spx_options = list(sorted([
             self.add_index_option_contract(i, Resolution.MINUTE).symbol \
-                for i in self.option_chain_provider.get_option_contract_list(spx, self.time)\
+                for i in self.option_chain(spx)\
                     if (i.id.strike_price == 3700 or i.id.strike_price == 3800) and i.id.option_right == OptionRight.CALL and i.id.date.year == 2021 and i.id.date.month == 1],
             key=lambda x: x.id.strike_price
         ))
@@ -66,7 +66,7 @@ class IndexOptionBuySellCallIntradayRegressionAlgorithm(QCAlgorithm):
 
         if spx_options[0] != expectedContract3700:
             raise Exception(f"Contract {expectedContract3700} was not found in the chain, found instead: {spx_options[0]}")
-        
+
         if spx_options[1] != expectedContract3800:
             raise Exception(f"Contract {expectedContract3800} was not found in the chain, found instead: {spx_options[1]}")
 

Algorithm.Python/IndexOptionCallITMExpiryRegressionAlgorithm.py

@@ -33,7 +33,7 @@ class IndexOptionCallITMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select an index option expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price <= 3200 and i.id.option_right == OptionRight.CALL and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price, reverse=True))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol
@@ -43,8 +43,8 @@ class IndexOptionCallITMExpiryRegressionAlgorithm(QCAlgorithm):
             raise Exception(f"Contract {self.expected_option_contract} was not found in the chain")
 
         self.schedule.on(
-            self.date_rules.tomorrow, 
-            self.time_rules.after_market_open(self.spx, 1), 
+            self.date_rules.tomorrow,
+            self.time_rules.after_market_open(self.spx, 1),
             lambda: self.market_order(self.spx_option, 1)
         )
 
@@ -55,7 +55,7 @@ class IndexOptionCallITMExpiryRegressionAlgorithm(QCAlgorithm):
             if delisting.type == DelistingType.WARNING:
                 if delisting.time != datetime(2021, 1, 15):
                     raise Exception(f"Delisting warning issued at unexpected date: {delisting.time}")
-            
+
             if delisting.type == DelistingType.DELISTED:
                 if delisting.time != datetime(2021, 1, 16):
                     raise Exception(f"Delisting happened at unexpected date: {delisting.time}")

Algorithm.Python/IndexOptionCallITMGreeksExpiryRegressionAlgorithm.py

@@ -30,7 +30,7 @@ class IndexOptionCallITMGreeksExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = spx.symbol
 
         # Select a index option call expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price <= 3200 and i.id.option_right == OptionRight.CALL and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price, reverse=True))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE)
@@ -81,7 +81,7 @@ class IndexOptionCallITMGreeksExpiryRegressionAlgorithm(QCAlgorithm):
 
         if any([i for i in rho if i == 0]):
             raise Exception("Option contract Rho was equal to zero")
-        
+
         if any([i for i in theta if i == 0]):
             raise Exception("Option contract Theta was equal to zero")
 

Algorithm.Python/IndexOptionCallOTMExpiryRegressionAlgorithm.py

@@ -38,17 +38,17 @@ class IndexOptionCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option call expiring OTM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price >= 4250 and i.id.option_right == OptionRight.CALL and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol
 
         self.expected_contract = Symbol.create_option(
-            self.spx, 
-            Market.USA, 
-            OptionStyle.EUROPEAN, 
-            OptionRight.CALL, 
-            4250, 
+            self.spx,
+            Market.USA,
+            OptionStyle.EUROPEAN,
+            OptionRight.CALL,
+            4250,
             datetime(2021, 1, 15)
         )
 
@@ -56,8 +56,8 @@ class IndexOptionCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
             raise Exception(f"Contract {self.expected_contract} was not found in the chain")
 
         self.schedule.on(
-            self.date_rules.tomorrow, 
-            self.time_rules.after_market_open(self.spx, 1), 
+            self.date_rules.tomorrow,
+            self.time_rules.after_market_open(self.spx, 1),
             lambda: self.market_order(self.spx_option, 1)
         )
 

Algorithm.Python/IndexOptionPutITMExpiryRegressionAlgorithm.py

@@ -32,7 +32,7 @@ class IndexOptionPutITMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price >= 4200 and i.id.option_right == OptionRight.PUT and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol

Algorithm.Python/IndexOptionPutOTMExpiryRegressionAlgorithm.py

@@ -38,17 +38,17 @@ class IndexOptionCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option call expiring OTM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price <= 3200 and i.id.option_right == OptionRight.PUT and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price, reverse=True))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol
 
         self.expected_contract = Symbol.create_option(
-            self.spx, 
-            Market.USA, 
-            OptionStyle.EUROPEAN, 
-            OptionRight.PUT, 
-            3200, 
+            self.spx,
+            Market.USA,
+            OptionStyle.EUROPEAN,
+            OptionRight.PUT,
+            3200,
             datetime(2021, 1, 15)
         )
 
@@ -56,8 +56,8 @@ class IndexOptionCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
             raise Exception(f"Contract {self.expected_contract} was not found in the chain")
 
         self.schedule.on(
-            self.date_rules.tomorrow, 
-            self.time_rules.after_market_open(self.spx, 1), 
+            self.date_rules.tomorrow,
+            self.time_rules.after_market_open(self.spx, 1),
             lambda: self.market_order(self.spx_option, 1)
         )
 

Algorithm.Python/IndexOptionShortCallITMExpiryRegressionAlgorithm.py

@@ -38,7 +38,7 @@ class IndexOptionShortCallITMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price <= 3200 and i.id.option_right == OptionRight.CALL and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price, reverse=True))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol

Algorithm.Python/IndexOptionShortCallOTMExpiryRegressionAlgorithm.py

@@ -34,7 +34,7 @@ class IndexOptionShortCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price >= 4250 and i.id.option_right == OptionRight.CALL and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol

Algorithm.Python/IndexOptionShortPutITMExpiryRegressionAlgorithm.py

@@ -38,7 +38,7 @@ class IndexOptionShortCallITMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price <= 4200 and i.id.option_right == OptionRight.PUT and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price, reverse=True))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol

Algorithm.Python/IndexOptionShortPutOTMExpiryRegressionAlgorithm.py

@@ -34,7 +34,7 @@ class IndexOptionShortCallOTMExpiryRegressionAlgorithm(QCAlgorithm):
         self.spx = self.add_index("SPX", Resolution.MINUTE).symbol
 
         # Select a index option expiring ITM, and adds it to the algorithm.
-        self.spx_option = list(self.option_chain_provider.get_option_contract_list(self.spx, self.time))
+        self.spx_option = list(self.option_chain(self.spx))
         self.spx_option = [i for i in self.spx_option if i.id.strike_price <= 3200 and i.id.option_right == OptionRight.PUT and i.id.date.year == 2021 and i.id.date.month == 1]
         self.spx_option = list(sorted(self.spx_option, key=lambda x: x.id.strike_price, reverse=True))[0]
         self.spx_option = self.add_index_option_contract(self.spx_option, Resolution.MINUTE).symbol

Algorithm.Python/IndicatorExtensionsSMAWithCustomIndicatorsRegressionAlgorithm.py

@@ -17,6 +17,7 @@ class IndicatorExtensionsSMAWithCustomIndicatorsRegressionAlgorithm(QCAlgorithm)
 
     def initialize(self):
         self.set_start_date(2020, 2, 20)
+        self.set_end_date(2020, 4, 20)
         self.qqq = self.add_equity("QQQ", Resolution.DAILY).symbol
         self.range_indicator = RangeIndicator("range1")
         self.range_sma = IndicatorExtensions.sma(self.range_indicator, 5)

Algorithm.Python/OptionChainFullDataRegressionAlgorithm.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 an option chain, which contains additional data besides the symbols, including prices, implied volatility and greeks.
+### It also shows how this data can be used to filter the contracts based on certain criteria.
+### </summary>
+class OptionChainFullDataRegressionAlgorithm(QCAlgorithm):
+
+    def initialize(self):
+        self.set_start_date(2015, 12, 24)
+        self.set_end_date(2015, 12, 24)
+        self.set_cash(100000)
+
+        goog = self.add_equity("GOOG").symbol
+
+        # Get contracts expiring within 10 days, with an implied volatility greater than 0.5 and a delta less than 0.5
+        contracts = [
+            contract_data
+            for contract_data in self.option_chain(goog)
+            if contract_data.id.date - self.time <= timedelta(days=10) and contract_data.implied_volatility > 0.5 and contract_data.greeks.delta < 0.5
+        ]
+        # Get the contract with the latest expiration date
+        self._option_contract = sorted(contracts, key=lambda x: x.id.date, reverse=True)[0]
+
+        self.add_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.market_order(self._option_contract, 1)
+        else:
+            self.liquidate()

Algorithm/QCAlgorithm.Universe.cs

@@ -92,7 +92,15 @@ namespace QuantConnect.Algorithm
                     {
                         Security underlyingSecurity;
                         var underlyingSymbol = security.Symbol.Underlying;
+
                         var resolution = configs.GetHighestResolution();
+                        var isFillForward = configs.IsFillForward();
+                        if (UniverseManager.TryGetValue(security.Symbol, out var universe))
+                        {
+                            // as if the universe had selected this asset, the configuration of the canonical can be different
+                            resolution = universe.UniverseSettings.Resolution;
+                            isFillForward = universe.UniverseSettings.FillForward;
+                        }
 
                         // create the underlying security object if it doesn't already exist
                         if (!Securities.TryGetValue(underlyingSymbol, out underlyingSecurity))
@@ -101,7 +109,7 @@ namespace QuantConnect.Algorithm
                                 underlyingSymbol.Value,
                                 resolution,
                                 underlyingSymbol.ID.Market,
-                                configs.IsFillForward(),
+                                isFillForward,
                                 Security.NullLeverage,
                                 configs.IsExtendedMarketHours(),
                                 dataNormalizationMode: DataNormalizationMode.Raw);

Algorithm/QCAlgorithm.cs

@@ -53,6 +53,7 @@ using Index = QuantConnect.Securities.Index.Index;
 using QuantConnect.Securities.CryptoFuture;
 using QuantConnect.Algorithm.Framework.Alphas.Analysis;
 using QuantConnect.Algorithm.Framework.Portfolio.SignalExports;
+using Python.Runtime;
 
 namespace QuantConnect.Algorithm
 {
@@ -467,6 +468,9 @@ namespace QuantConnect.Algorithm
         /// Gets the option chain provider, used to get the list of option contracts for an underlying symbol
         /// </summary>
         [DocumentationAttribute(AddingData)]
+        [Obsolete("OptionChainProvider property is will soon be deprecated. " +
+            "The new OptionChain() method should be used to fetch equity and index option chains, " +
+            "which will contain additional data per contract, like daily price data, implied volatility and greeks.")]
         public IOptionChainProvider OptionChainProvider { get; private set; }
 
         /// <summary>
@@ -1935,6 +1939,15 @@ namespace QuantConnect.Algorithm
                 return AddOptionContract(symbol, resolution, fillForward, leverage, extendedMarketHours);
             }
 
+            var securityResolution = resolution;
+            var securityFillForward = fillForward;
+            if (isCanonical && symbol.SecurityType.IsOption() && symbol.SecurityType != SecurityType.FutureOption)
+            {
+                // option is daily only, for now exclude FOPs
+                securityResolution = Resolution.Daily;
+                securityFillForward = false;
+            }
+
             var isFilteredSubscription = !isCanonical;
             List<SubscriptionDataConfig> configs;
             // we pass dataNormalizationMode to SubscriptionManager.SubscriptionDataConfigService.Add conditionally,
@@ -1942,8 +1955,8 @@ namespace QuantConnect.Algorithm
             if (dataNormalizationMode.HasValue)
             {
                 configs = SubscriptionManager.SubscriptionDataConfigService.Add(symbol,
-                    resolution,
-                    fillForward,
+                    securityResolution,
+                    securityFillForward,
                     extendedMarketHours,
                     isFilteredSubscription,
                     dataNormalizationMode: dataNormalizationMode.Value,
@@ -1952,8 +1965,8 @@ namespace QuantConnect.Algorithm
             else
             {
                 configs = SubscriptionManager.SubscriptionDataConfigService.Add(symbol,
-                   resolution,
-                   fillForward,
+                   securityResolution,
+                   securityFillForward,
                    extendedMarketHours,
                    isFilteredSubscription,
                    contractDepthOffset: (uint)contractDepthOffset);
@@ -1971,10 +1984,16 @@ namespace QuantConnect.Algorithm
                 if (!UniverseManager.ContainsKey(symbol))
                 {
                     var canonicalConfig = configs.First();
-                    var settings = new UniverseSettings(canonicalConfig.Resolution, leverage, fillForward, extendedMarketHours, UniverseSettings.MinimumTimeInUniverse)
+                    var universeSettingsResolution = canonicalConfig.Resolution;
+                    if (symbol.SecurityType.IsOption())
+                    {
+                        universeSettingsResolution = resolution ?? UniverseSettings.Resolution;
+                    }
+                    var settings = new UniverseSettings(universeSettingsResolution, leverage, fillForward, extendedMarketHours, UniverseSettings.MinimumTimeInUniverse)
                     {
                         Asynchronous = UniverseSettings.Asynchronous
                     };
+
                     if (symbol.SecurityType.IsOption())
                     {
                         universe = new OptionChainUniverse((Option)security, settings);
@@ -2281,7 +2300,7 @@ namespace QuantConnect.Algorithm
             {
                 throw new KeyNotFoundException($"No default market set for underlying security type: {SecurityType.Index}");
             }
-            
+
             return AddIndexOption(
                 QuantConnect.Symbol.Create(underlying, SecurityType.Index, market),
                 targetOption, resolution, fillForward);
@@ -3325,6 +3344,63 @@ namespace QuantConnect.Algorithm
             return symbols.Select(symbol => Fundamentals(symbol)).ToList();
         }
 
+        /// <summary>
+        /// Get the option chain for the specified symbol at the current time (<see cref="Time"/>)
+        /// </summary>
+        /// <param name="symbol">
+        /// The symbol for which the option chain is asked for.
+        /// It can be either the canonical option or the underlying symbol.
+        /// </param>
+        /// <returns>
+        /// The option chain as an enumerable of <see cref="OptionUniverse"/>,
+        /// each containing the contract symbol along with additional data, including daily price data,
+        /// implied volatility and greeks.
+        /// </returns>
+        /// <remarks>
+        /// As of 2024/09/11, future options chain will not contain any additional data (e.g. daily price data, implied volatility and greeks),
+        /// it will be populated with the contract symbol only. This is expected to change in the future.
+        /// </remarks>
+        [DocumentationAttribute(AddingData)]
+        public DataHistory<OptionUniverse> OptionChain(Symbol symbol)
+        {
+            var canonicalSymbol = GetCanonicalOptionSymbol(symbol);
+            IEnumerable<OptionUniverse> optionChain;
+
+            // TODO: Until future options are supported by OptionUniverse, we need to fall back to the OptionChainProvider for them
+            if (canonicalSymbol.SecurityType != SecurityType.FutureOption)
+            {
+                var history = History<OptionUniverse>(canonicalSymbol, 1);
+                optionChain = history?.SingleOrDefault()?.Data?.Cast<OptionUniverse>() ?? Enumerable.Empty<OptionUniverse>();
+            }
+            else
+            {
+                optionChain = OptionChainProvider.GetOptionContractList(canonicalSymbol, Time)
+                    .Select(contractSymbol => new OptionUniverse()
+                    {
+                        Symbol = contractSymbol,
+                        EndTime = Time.Date
+                    });
+            }
+
+            return new DataHistory<OptionUniverse>(optionChain, new Lazy<PyObject>(() => PandasConverter.GetDataFrame(optionChain)));
+        }
+
+        private static Symbol GetCanonicalOptionSymbol(Symbol symbol)
+        {
+            // We got the underlying
+            if (symbol.SecurityType.HasOptions())
+            {
+                return QuantConnect.Symbol.CreateCanonicalOption(symbol);
+            }
+
+            if (symbol.SecurityType.IsOption())
+            {
+                return symbol.Canonical;
+            }
+
+            throw new ArgumentException($"The symbol {symbol} is not an option or an underlying symbol.");
+        }
+
         /// <summary>
         /// Set the properties and exchange hours for a given key into our databases
         /// </summary>

Common/Data/UniverseSelection/OptionUniverse.cs

@@ -276,6 +276,16 @@ namespace QuantConnect.Data.UniverseSelection
             return new OptionUniverse(this);
         }
 
+        /// <summary>
+        /// Gets the default resolution for this data and security type
+        /// </summary>
+        /// <remarks>This is a method and not a property so that python
+        /// custom data types can override it</remarks>
+        public override Resolution DefaultResolution()
+        {
+            return Resolution.Daily;
+        }
+
         /// <summary>
         /// Gets the CSV string representation of this universe entry
         /// </summary>

Common/Exchange.cs

@@ -262,6 +262,14 @@ namespace QuantConnect
         public static Exchange CME { get; }
             = new("CME", "CME", "Futures and Options Chicago Mercantile Exchange", QuantConnect.Market.CME, SecurityType.Future, SecurityType.FutureOption);
 
+        /// <summary>
+        /// The European Derivatives Exchange (EUREX)
+        /// </summary>
+        public static Exchange EUREX { get; }
+            = new("EUREX", "EUREX", "European Derivatives Exchange", QuantConnect.Market.EUREX, SecurityType.Future, SecurityType.Index);
+
+        /// <summary>
+
         /// <summary>
         /// The Chicago Board of Trade (CBOT) is a commodity exchange
         /// </summary>

Common/Global.cs

@@ -950,6 +950,8 @@ namespace QuantConnect
                         return Exchange.COMEX;
                     case "NYSELIFFE":
                         return Exchange.NYSELIFFE;
+                    case "EUREX":
+                        return Exchange.EUREX;
                     default:
                         return Exchange.UNKNOWN;
                 }

Common/Market.cs

@@ -69,6 +69,7 @@ namespace QuantConnect
             Tuple.Create(Bybit, 37),
             Tuple.Create(Coinbase, 38),
             Tuple.Create(InteractiveBrokers, 39),
+            Tuple.Create(EUREX, 40)
         };
 
         static Market()
@@ -153,6 +154,11 @@ namespace QuantConnect
         /// </summary>
         public const string CME = "cme";
 
+        /// <summary>
+        /// EUREX
+        /// </summary>
+        public const string EUREX = "eurex";
+
         /// <summary>
         /// Singapore Exchange
         /// </summary>

Common/Messages/Messages.Orders.Fees.cs

@@ -112,6 +112,15 @@ namespace QuantConnect
                 return Invariant($"InteractiveBrokersFeeModel.UnitedStatesFutureFees(): Unsupported security type: {security.Type}");
             }
 
+            /// <summary>
+            /// Returns a string message saying the type of the given security was unsupported
+            /// </summary>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static string EUREXFutureFeesUnsupportedSecurityType(Securities.Security security)
+            {
+                return Invariant($"InteractiveBrokersFeeModel.EUREXFutureFees(): Unsupported security type: {security.Type}");
+            }
+
             /// <summary>
             /// Returns a string message saying the quote currency of the given security was 
             /// unexpected for Hong Kong futures exchange

Common/Orders/Fees/InteractiveBrokersFeeModel.cs

@@ -42,7 +42,8 @@ namespace QuantConnect.Orders.Fees
             new()
             {
                 { Market.USA, UnitedStatesFutureFees },
-                { Market.HKFE, HongKongFutureFees }
+                { Market.HKFE, HongKongFutureFees },
+                { Market.EUREX, EUREXFutureFees }
             };
 
         /// <summary>
@@ -377,6 +378,37 @@ namespace QuantConnect.Orders.Fees
             return new CashAmount(ibFeePerContract * 1.5m, security.QuoteCurrency.Symbol);
         }
 
+        private static CashAmount EUREXFutureFees(Security security)
+        {
+            IDictionary<string, decimal> fees, exchangeFees;
+            decimal ibFeePerContract, exchangeFeePerContract;
+            string symbol;
+
+            switch (security.Symbol.SecurityType)
+            {
+                case SecurityType.Future:
+                    fees = _eurexFuturesFees;
+                    exchangeFees = _eurexFuturesExchangeFees;
+                    symbol = security.Symbol.ID.Symbol;
+                    break;
+                default:
+                    throw new ArgumentException(Messages.InteractiveBrokersFeeModel.EUREXFutureFeesUnsupportedSecurityType(security));
+            }
+
+            if (!fees.TryGetValue(symbol, out ibFeePerContract))
+            {
+                ibFeePerContract = 1.00m;
+            }
+
+            if (!exchangeFees.TryGetValue(symbol, out exchangeFeePerContract))
+            {
+                exchangeFeePerContract = 0.00m;
+            }
+
+            // Add exchange fees + IBKR regulatory fee (0.02)
+            return new CashAmount(ibFeePerContract + exchangeFeePerContract + 0.02m, Currencies.EUR);
+        }
+
         /// <summary>
         /// Reference at https://www.interactivebrokers.com/en/pricing/commissions-futures.php?re=amer
         /// </summary>
@@ -394,6 +426,15 @@ namespace QuantConnect.Orders.Fees
             { "MIR", 0.15m }, { "M6C", 0.15m }, { "M6S", 0.15m }, { "MNH", 0.15m },
         };
 
+        /// <summary>
+        /// Reference at https://www.interactivebrokers.com/en/pricing/commissions-futures-europe.php?re=europe
+        /// </summary>
+        private static readonly Dictionary<string, decimal> _eurexFuturesFees = new()
+        {
+            // Futures
+            { "FESX", 1.00m },
+        };
+
         private static readonly Dictionary<string, decimal> _usaFutureOptionsFees = new()
         {
             // Micro E-mini Future Options
@@ -419,6 +460,12 @@ namespace QuantConnect.Orders.Fees
             { "MIR", 0.24m }, { "M6C", 0.24m }, { "M6S", 0.24m }, { "MNH", 0.24m },
         };
 
+        private static readonly Dictionary<string, decimal> _eurexFuturesExchangeFees = new()
+        {
+            // Futures
+            { "FESX", 0.00m },
+        };
+
         private static readonly Dictionary<string, decimal> _usaFutureOptionsExchangeFees = new()
         {
             // E-mini Future Options

Common/Scheduling/TimeRules.cs

@@ -153,6 +153,18 @@ namespace QuantConnect.Scheduling
             return new FuncTimeRule(name, applicator);
         }
 
+        /// <summary>
+        /// Specifies an event should fire at market open +- <paramref name="minutesBeforeOpen"/>
+        /// </summary>
+        /// <param name="symbol">The symbol whose market open we want an event for</param>
+        /// <param name="minutesBeforeOpen">The minutes before market open that the event should fire</param>
+        /// <param name="extendedMarketOpen">True to use extended market open, false to use regular market open</param>
+        /// <returns>A time rule that fires the specified number of minutes before the symbol's market open</returns>
+        public ITimeRule BeforeMarketOpen(Symbol symbol, double minutesBeforeOpen = 0, bool extendedMarketOpen = false)
+        {
+            return AfterMarketOpen(symbol, minutesBeforeOpen * (-1), extendedMarketOpen);
+        }
+
         /// <summary>
         /// Specifies an event should fire at market open +- <paramref name="minutesAfterOpen"/>
         /// </summary>
@@ -163,7 +175,8 @@ namespace QuantConnect.Scheduling
         public ITimeRule AfterMarketOpen(Symbol symbol, double minutesAfterOpen = 0, bool extendedMarketOpen = false)
         {
             var type = extendedMarketOpen ? "ExtendedMarketOpen" : "MarketOpen";
-            var name = Invariant($"{symbol}: {minutesAfterOpen:0.##} min after {type}");
+            var afterOrBefore = minutesAfterOpen > 0 ? "after" : "before";
+            var name = Invariant($"{symbol}: {Math.Abs(minutesAfterOpen):0.##} min {afterOrBefore} {type}");
             var exchangeHours = GetSecurityExchangeHours(symbol);
 
             var timeAfterOpen = TimeSpan.FromMinutes(minutesAfterOpen);
@@ -179,6 +192,18 @@ namespace QuantConnect.Scheduling
             return new FuncTimeRule(name, applicator);
         }
 
+        /// <summary>
+        /// Specifies an event should fire at the market close +- <paramref name="minutesAfterClose"/>
+        /// </summary>
+        /// <param name="symbol">The symbol whose market close we want an event for</param>
+        /// <param name="minutesAfterClose">The time after market close that the event should fire</param>
+        /// <param name="extendedMarketClose">True to use extended market close, false to use regular market close</param>
+        /// <returns>A time rule that fires the specified number of minutes after the symbol's market close</returns>
+        public ITimeRule AfterMarketClose(Symbol symbol, double minutesAfterClose = 0, bool extendedMarketClose = false)
+        {
+            return BeforeMarketClose(symbol, minutesAfterClose * (-1), extendedMarketClose);
+        }
+
         /// <summary>
         /// Specifies an event should fire at the market close +- <paramref name="minutesBeforeClose"/>
         /// </summary>
@@ -189,7 +214,8 @@ namespace QuantConnect.Scheduling
         public ITimeRule BeforeMarketClose(Symbol symbol, double minutesBeforeClose = 0, bool extendedMarketClose = false)
         {
             var type = extendedMarketClose ? "ExtendedMarketClose" : "MarketClose";
-            var name = Invariant($"{symbol}: {minutesBeforeClose:0.##} min before {type}");
+            var afterOrBefore = minutesBeforeClose > 0 ? "before" : "after";
+            var name = Invariant($"{symbol}: {Math.Abs(minutesBeforeClose):0.##} min {afterOrBefore} {type}");
             var exchangeHours = GetSecurityExchangeHours(symbol);
 
             var timeBeforeClose = TimeSpan.FromMinutes(minutesBeforeClose);

Common/Securities/ContractSecurityFilterUniverse.cs

@@ -282,6 +282,16 @@ namespace QuantConnect.Securities
             return BackMonths().FrontMonth();
         }
 
+        /// <summary>
+        /// Adjust the reference date used for expiration filtering. By default it just returns the same date.
+        /// </summary>
+        /// <param name="referenceDate">The reference date to be adjusted</param>
+        /// <returns>The adjusted date</returns>
+        protected virtual DateTime AdjustExpirationReferenceDate(DateTime referenceDate)
+        {
+            return referenceDate;
+        }
+
         /// <summary>
         /// Applies filter selecting options contracts based on a range of expiration dates relative to the current day
         /// </summary>
@@ -294,19 +304,21 @@ namespace QuantConnect.Securities
         {
             if (LocalTime == default)
             {
-                return (T) this;
+                return (T)this;
             }
 
             if (maxExpiry > Time.MaxTimeSpan) maxExpiry = Time.MaxTimeSpan;
 
-            var minExpiryToDate = LocalTime.Date + minExpiry;
-            var maxExpiryToDate = LocalTime.Date + maxExpiry;
+            var referenceDate = AdjustExpirationReferenceDate(LocalTime.Date);
+
+            var minExpiryToDate = referenceDate + minExpiry;
+            var maxExpiryToDate = referenceDate + maxExpiry;
 
             Data = Data
                 .Where(symbol => symbol.ID.Date.Date >= minExpiryToDate && symbol.ID.Date.Date <= maxExpiryToDate)
                 .ToList();
 
-            return (T) this;
+            return (T)this;
         }
 
         /// <summary>

Common/Securities/Future/Futures.cs

@@ -1596,6 +1596,12 @@ namespace QuantConnect.Securities
             /// MSCI USA Index Futures
             /// </summary>
             public const string MSCIUsaIndex = "MXUS";
+
+            /// <summary>
+            /// Euro Stoxx 50 Index Futures
+            /// </summary>
+            /// <returns>The symbol</returns>
+            public const string EuroStoxx50 = "FESX";
         }
 
         /// <summary>

Common/Securities/Future/FuturesExpiryFunctions.cs

@@ -291,7 +291,7 @@ namespace QuantConnect.Securities.Future
                     // Monthly contracts
                     // Trading terminates on the last business day of the contract month.
                     var lastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
-					
+
                     lastBusinessDay = FuturesExpiryUtilityFunctions.AddBusinessDaysIfHoliday(lastBusinessDay, -1, holidays);
 
                     return lastBusinessDay;
@@ -353,6 +353,20 @@ namespace QuantConnect.Securities.Future
                     return thirdFriday.Add(new TimeSpan(13,30,0));
                 })
             },
+            // EuroStoxx50 (FESX): https://www.xetra.com/resource/blob/63488/437afcd347fb020377873dd1ceac10ba/EURO-STOXX-50-Factsheet-data.pdf
+            {Symbol.Create(Futures.Indices.EuroStoxx50, SecurityType.Future, Market.EUREX), (time =>
+                {
+                    // Quarterly contracts (Mar/3, Jun/6 , Sep/9 , Dec/12) listed for 9 consecutive quarters and 3 additional December contract months.
+                    while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
+                    {
+                        time = time.AddMonths(1);
+                    }
+
+                    // Trading can occur up to 9:30 a.m. Eastern Time (ET) on the 3rd Friday of the contract month
+                    var thirdFriday = FuturesExpiryUtilityFunctions.ThirdFriday(time);
+                    return thirdFriday.Add(new TimeSpan(13,30,0));
+                })
+            },
             // NASDAQ100EMini (NQ): http://www.cmegroup.com/trading/equity-index/us-index/e-mini-nasdaq-100_contract_specifications.html
             {Symbol.Create(Futures.Indices.NASDAQ100EMini, SecurityType.Future, Market.CME), (time =>
                 {
@@ -465,7 +479,7 @@ namespace QuantConnect.Securities.Future
                     //Contracts listed for the  2 nearest serial and 4 quarterly months.
                     //Trading terminates on the second to last business day of the contract month at the end of trading on the Hong Kong Exchange Securities Market
                     var secondLastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(time,2, holidays);
-         
+
                     while (!FuturesExpiryUtilityFunctions.NotHoliday(secondLastBusinessDay, holidays))
                     {
                         secondLastBusinessDay = secondLastBusinessDay.AddDays(-1);
@@ -1143,7 +1157,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CBOT;
                     var symbol = Futures.Grains.BlackSeaCornFinanciallySettledPlatts;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 15 consecutive months.
                     // Trading terminates on the last business day of the contract month which is also a Platts publication date for the price assessment.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1348,7 +1362,7 @@ namespace QuantConnect.Securities.Future
                     var thirdWednesday = FuturesExpiryUtilityFunctions.ThirdWednesday(time);
                     var secondBusinessDayPrecedingThirdWednesday = FuturesExpiryUtilityFunctions.AddBusinessDays(thirdWednesday,-2, holidays);
                     secondBusinessDayPrecedingThirdWednesday = FuturesExpiryUtilityFunctions.AddBusinessDaysIfHoliday(secondBusinessDayPrecedingThirdWednesday, -1, holidays);
-					
+
                     return secondBusinessDayPrecedingThirdWednesday.Add(new TimeSpan(14,16,0));
                 })
             },
@@ -1363,7 +1377,7 @@ namespace QuantConnect.Securities.Future
                     var thirdWednesday = FuturesExpiryUtilityFunctions.ThirdWednesday(time);
                     var secondBusinessDayPrecedingThirdWednesday = FuturesExpiryUtilityFunctions.AddBusinessDays(thirdWednesday, -2, holidays);
                     secondBusinessDayPrecedingThirdWednesday = FuturesExpiryUtilityFunctions.AddBusinessDaysIfHoliday(secondBusinessDayPrecedingThirdWednesday, -1, holidays);
-					
+
                     return secondBusinessDayPrecedingThirdWednesday.Add(new TimeSpan(14,16,0));
                 })
             },
@@ -1481,7 +1495,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CME;
                     var symbol = Futures.Currencies.StandardSizeUSDOffshoreRMBCNH;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 13 consecutive months and quarterly contracts (Mar, Jun, Sep, Dec) listed for the next 8  quarters.
                     // Trading terminates on the second Hong Kong business day prior to the third Wednesday of the contract month at 11:00 a.m. Hong Kong local time.
                     var thirdWednesday = FuturesExpiryUtilityFunctions.ThirdWednesday(time);
@@ -1500,7 +1514,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CME;
                     var symbol = Futures.Currencies.EuroFXEmini;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 2 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1521,7 +1535,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CME;
                     var symbol = Futures.Currencies.EURAUD;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 6 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1542,7 +1556,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CME;
                     var symbol = Futures.Currencies.EURCAD;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 6 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1563,7 +1577,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CME;
                     var symbol = Futures.Currencies.EURSEK;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Six months in the March quarterly cycle (Mar, Jun, Sep, Dec)
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1605,7 +1619,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CBOT;
                     var symbol = Futures.Financials.Y30TreasuryBond;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 3 quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1624,7 +1638,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CBOT;
                     var symbol = Futures.Financials.Y10TreasuryNote;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 3 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1660,7 +1674,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CBOT;
                     var symbol = Futures.Financials.Y2TreasuryNote;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 3 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1678,7 +1692,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CME;
                     var symbol = Futures.Financials.EuroDollar;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 40 consecutive quarters and the nearest 4 serial contract months.
                     // List a new quarterly contract for trading on the last trading day of the nearby expiry.
 
@@ -1695,7 +1709,7 @@ namespace QuantConnect.Securities.Future
                 {
                     var market = Market.CBOT;
                     var symbol = Futures.Financials.FiveYearUSDMACSwap;
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 2 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1721,7 +1735,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CBOT;
                     var symbol = Futures.Financials.UltraUSTreasuryBond;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 3 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1740,7 +1754,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.CBOT;
                     var symbol = Futures.Financials.UltraTenYearUSTreasuryNote;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Quarterly contracts (Mar, Jun, Sep, Dec) listed for 3 consecutive quarters
                     while (!FutureExpirationCycles.HMUZ.Contains(time.Month))
                     {
@@ -1770,7 +1784,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.ArgusPropaneFarEastIndexBALMO;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly BALMO contracts listed for three cconsecutive months
                     // Trading shall cease on the last business day of the contract month. Business days are based on the Singapore Public Holiday calendar.
                     // TODO: Might need singapore calendar
@@ -1783,7 +1797,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MiniEuropeanThreePointPercentFiveFuelOilBargesPlatts;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for the current year and the next 4 calendar years.
                     // Trading shall cease on the last business day of the contract month.
                     var lastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1798,7 +1812,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MiniSingaporeFuelOil180CstPlatts;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for the current year and the next 5 calendar years.
                     // Trading shall cease on the last business day of the contract month.
                     // Special case exists where the last trade occurs on US holiday, but not an exchange holiday (markets closed)
@@ -1841,7 +1855,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.PropaneNonLDHMontBelvieuOPIS;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 48 consecutive months
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1864,7 +1878,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.PremiumUnleadedGasoline10ppmFOBMEDPlatts;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // 48 consecutive months
                     var lastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
                     lastBusinessDay = FuturesExpiryUtilityFunctions.AddBusinessDaysIfHoliday(lastBusinessDay, -1, holidays);
@@ -1878,7 +1892,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.ArgusPropaneFarEastIndex;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 48 consecutive months
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1890,7 +1904,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.GasolineEurobobOxyNWEBargesArgusCrackSpreadBALMO;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly BALMO contracts listed for 3 consecutive months
                     // Trading ceases on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1902,7 +1916,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MontBelvieuNaturalGasolineOPIS;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 56 consecutive months
                     // Trading shall cease on the last business day of the contract month
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1914,7 +1928,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MontBelvieuNormalButaneOPISBALMO;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly BALMO contracts listed for the current month and the following month listed 10 business days prior to the start of the contract month
                     // Trading terminates on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1926,7 +1940,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.ConwayPropaneOPIS;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for the current year and the next 4 calendar years.
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1938,7 +1952,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MontBelvieuLDHPropaneOPISBALMO;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly BALMO contracts listed for the current month and the following month listed 10 business days prior to the start of the contract month
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1950,7 +1964,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.ArgusPropaneFarEastIndexVsEuropeanPropaneCIFARAArgus;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 36 consecutive months
                     // Trading shall cease on the last business day of the contract month.
                     var lastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -1965,7 +1979,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.ArgusPropaneSaudiAramco;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for 48 consecutive months
                     // Trading shall terminate on the last business day of the month prior to the contract month.
                     // Business days are based on the Singapore Public Holiday Calendar.
@@ -1998,7 +2012,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.GroupThreeSuboctaneGasolinePlattsVsRBOB;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // 36 consecutive months
                     // Trading shall cease on the last business day of the contract month
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2010,7 +2024,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.SingaporeFuelOil180cstPlattsBALMO;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly BALMO contracts listed for 3 consecutive months
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2022,7 +2036,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.SingaporeFuelOil380cstPlattsBALMO;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly BALMO contracts listed for 3 consecutive months
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2034,7 +2048,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MontBelvieuEthaneOPIS;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for the current year and the next 4 calendar years.
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2046,7 +2060,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.MontBelvieuNormalButaneOPIS;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for the current year and next 4 calendar years.
                     // Trading shall cease on the last business day of the contract month.
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2071,7 +2085,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.ArgusLLSvsWTIArgusTradeMonth;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Trading shall cease at the close of trading on the last business day that falls on or before the 25th calendar day of the month prior to the contract month. If the 25th calendar day is a weekend or holiday, trading shall cease on the first business day prior to the 25th calendar day.
                     var previousMonth = time.AddMonths(-1);
                     var twentyFifthDay = new DateTime(previousMonth.Year, previousMonth.Month, 25);
@@ -2089,7 +2103,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.SingaporeGasoilPlattsVsLowSulphurGasoilFutures;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // Monthly contracts listed for the current year and the next 2 calendar years.
                     // Trading ceases on the last business day of the contract month
                     var lastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2104,7 +2118,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.NYMEX;
                     var symbol = Futures.Energy.LosAngelesCARBOBGasolineOPISvsRBOBGasoline;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // 36 consecutive months
                     // Trading shall cease on the last business day of the contract month
                     return FuturesExpiryUtilityFunctions.NthLastBusinessDay(time, 1, holidays);
@@ -2321,7 +2335,7 @@ namespace QuantConnect.Securities.Future
                     {
                         lastBusinessDay = FuturesExpiryUtilityFunctions.NthLastBusinessDay(twoMonthsPriorToContractMonth, 1, holidays);
                     }
-                    
+
                     lastBusinessDay = FuturesExpiryUtilityFunctions.AddBusinessDaysIfHoliday(lastBusinessDay, -1, holidays);
 
                     return lastBusinessDay;
@@ -2877,7 +2891,7 @@ namespace QuantConnect.Securities.Future
                     var market = Market.ICE;
                     var symbol = Futures.Softs.OrangeJuice;
                     var holidays = FuturesExpiryUtilityFunctions.GetHolidays(market, symbol);
-					
+
                     // January, March, May, July, September, November.
                     while (!FutureExpirationCycles.FHKNUX.Contains(time.Month))
                     {

Common/Securities/Option/OptionFilterUniverse.cs

@@ -31,6 +31,8 @@ namespace QuantConnect.Securities
     /// </summary>
     public class OptionFilterUniverse : ContractSecurityFilterUniverse<OptionFilterUniverse, OptionUniverse>
     {
+        private Option.Option _option;
+
         // Fields used in relative strikes filter
         private List<decimal> _uniqueStrikes;
         private bool _refreshUniqueStrikes;
@@ -59,6 +61,7 @@ namespace QuantConnect.Securities
         /// <param name="option">The canonical option chain security</param>
         public OptionFilterUniverse(Option.Option option)
         {
+            _option = option;
             _underlyingScaleFactor = option.SymbolProperties.StrikeMultiplier;
         }
 
@@ -66,9 +69,10 @@ namespace QuantConnect.Securities
         /// Constructs OptionFilterUniverse
         /// </summary>
         /// <remarks>Used for testing only</remarks>
-        public OptionFilterUniverse(IEnumerable<OptionUniverse> allData, BaseData underlying, decimal underlyingScaleFactor = 1)
+        public OptionFilterUniverse(Option.Option option, IEnumerable<OptionUniverse> allData, BaseData underlying, decimal underlyingScaleFactor = 1)
             : base(allData, underlying.EndTime)
         {
+            _option = option;
             UnderlyingInternal = underlying;
             _refreshUniqueStrikes = true;
             _underlyingScaleFactor = underlyingScaleFactor;
@@ -128,6 +132,24 @@ namespace QuantConnect.Securities
             };
         }
 
+        /// <summary>
+        /// Adjusts the date to the next trading day if the current date is not a trading day, so that expiration filter is properly applied.
+        /// e.g. Selection for Mondays happen on Friday midnight (Saturday start), so if the minimum time to expiration is, say 0,
+        /// contracts expiring on Monday would be filtered out if the date is not properly adjusted to the next trading day (Monday).
+        /// </summary>
+        /// <param name="referenceDate">The date to be adjusted</param>
+        /// <returns>The adjusted date</returns>
+        protected override DateTime AdjustExpirationReferenceDate(DateTime referenceDate)
+        {
+            // Check whether the reference time is a tradable date:
+            if (!_option.Exchange.Hours.IsDateOpen(referenceDate))
+            {
+                referenceDate = _option.Exchange.Hours.GetNextTradingDay(referenceDate);
+            }
+
+            return referenceDate;
+        }
+
         /// <summary>
         /// Applies filter selecting options contracts based on a range of strikes in relative terms
         /// </summary>

Data/future/eurex/factor_files/fesx.csv

@@ -0,0 +1,4 @@
+{"Date":"2024-02-29T00:00:00","BackwardsRatioScale":[0.9913489916535321268273586766,1.0164323896258166699663432984,1.0],"BackwardsPanamaCanalScale":[-42.66,83.0,0.0],"ForwardPanamaCanalScale":[-123866.99,774.5,33.0],"DataMappingMode":1}
+{"Date":"2024-03-14T00:00:00","BackwardsRatioScale":[0.9944097809171575660198252019,1.0088791461489374296086137569,1.0],"BackwardsPanamaCanalScale":[-27.80,44.0,0.0],"ForwardPanamaCanalScale":[-122928.36,1387.0,151.0],"DataMappingMode":0}
+{"Date":"2024-05-31T00:00:00","BackwardsRatioScale":[0.9982410719579438328820727682,1.0164323896258166699663432984,1.0],"BackwardsPanamaCanalScale":[-8.9,83.0,0.0],"ForwardPanamaCanalScale":[-123858.09,691.5,33.0],"DataMappingMode":1}
+{"Date":"2024-06-20T00:00:00","BackwardsRatioScale":[0.9999378547042986502442711058,1.0044105854049719326383319968,1.0],"BackwardsPanamaCanalScale":[-0.31,22.0,0.0],"ForwardPanamaCanalScale":[-122928.05,1365.0,151.0],"DataMappingMode":0}

Data/future/eurex/map_files/fesx.csv

@@ -0,0 +1,15 @@
+18991230,fesx,EUREX
+20231130,fesx yebksyl246g5,EUREX,1
+20231214,fesx yebksyl246g5,EUREX,0
+20240229,fesx ygt6hgvf2u1x,EUREX,1
+20240314,fesx ygt6hgvf2u1x,EUREX,0
+20240531,fesx yjhoampykrs5,EUREX,1
+20240620,fesx yjhoampykrs5,EUREX,0
+20240831,fesx ylz9z50bjfdx,EUREX,1
+20240919,fesx ylz9z50bjfdx,EUREX,0
+20241130,fesx yogvnnaoi2zp,EUREX,1
+20241219,fesx yogvnnaoi2zp,EUREX,0
+20250228,fesx yqyhc5l1gqlh,EUREX,1
+20250320,fesx yqyhc5l1gqlh,EUREX,0
+20250531,fesx ytg30nvefe79,EUREX,1
+20250619,fesx ytg30nvefe79,EUREX,0

Data/future/eurex/margins/FESX.csv

@@ -0,0 +1,2 @@
+date,initial,maintenance
+20000101,3000,3000

Data/market-hours/market-hours-database.json

@@ -118281,6 +118281,408 @@
         }
       ],
       "holidays": []
+    },
+    "Index-eurex-[*]": {
+      "dataTimeZone": "Europe/Berlin",
+      "exchangeTimeZone": "Europe/Berlin",
+      "sunday": [],
+      "monday": [
+        {
+          "start": "09:00:00",
+          "end": "17:30:00",
+          "state": "market"
+        }
+      ],
+      "tuesday": [
+        {
+          "start": "09:00:00",
+          "end": "17:30:00",
+          "state": "market"
+        }
+      ],
+      "wednesday": [
+        {
+          "start": "09:00:00",
+          "end": "17:30:00",
+          "state": "market"
+        }
+      ],
+      "thursday": [
+        {
+          "start": "09:00:00",
+          "end": "17:30:00",
+          "state": "market"
+        }
+      ],
+      "friday": [
+        {
+          "start": "09:00:00",
+          "end": "17:30:00",
+          "state": "market"
+        }
+      ],
+      "saturday": [],
+      "holidays": [
+        "4/21/2000",
+        "4/24/2000",
+        "5/1/2000",
+        "12/25/2000",
+        "12/26/2000",
+        "1/1/2001",
+        "4/13/2001",
+        "4/16/2001",
+        "5/1/2001",
+        "12/24/2001",
+        "12/25/2001",
+        "12/26/2001",
+        "12/31/2001",
+        "1/1/2002",
+        "3/29/2002",
+        "4/1/2002",
+        "5/1/2002",
+        "12/24/2002",
+        "12/25/2002",
+        "12/26/2002",
+        "12/31/2002",
+        "1/1/2003",
+        "4/18/2003",
+        "4/21/2003",
+        "1/1/2004",
+        "4/9/2004",
+        "4/12/2004",
+        "5/1/2004",
+        "12/24/2004",
+        "12/24/2004",
+        "12/25/2004",
+        "12/26/2004",
+        "12/31/2004",
+        "12/31/2004",
+        "3/25/2005",
+        "3/28/2005",
+        "12/26/2005",
+        "4/14/2006",
+        "4/17/2006",
+        "5/1/2006",
+        "12/25/2006",
+        "12/26/2006",
+        "1/1/2007",
+        "4/6/2007",
+        "4/9/2007",
+        "5/1/2007",
+        "12/24/2007",
+        "12/25/2007",
+        "12/26/2007",
+        "12/31/2007",
+        "1/1/2008",
+        "3/21/2008",
+        "3/24/2008",
+        "5/1/2008",
+        "12/24/2008",
+        "12/25/2008",
+        "12/26/2008",
+        "12/31/2008",
+        "1/1/2009",
+        "4/10/2009",
+        "4/13/2009",
+        "5/1/2009",
+        "12/24/2009",
+        "12/25/2009",
+        "12/31/2009",
+        "1/1/2010",
+        "4/2/2010",
+        "4/5/2010",
+        "12/24/2010",
+        "12/31/2010",
+        "4/22/2011",
+        "4/25/2011",
+        "12/26/2011",
+        "4/6/2012",
+        "4/9/2012",
+        "5/1/2012",
+        "12/24/2012",
+        "12/25/2012",
+        "12/26/2012",
+        "12/31/2012",
+        "1/1/2013",
+        "3/29/2013",
+        "4/1/2013",
+        "5/1/2013",
+        "12/24/2013",
+        "12/25/2013",
+        "12/26/2013",
+        "12/31/2013",
+        "1/1/2014",
+        "4/18/2014",
+        "4/21/2014",
+        "5/1/2014",
+        "12/24/2014",
+        "12/25/2014",
+        "12/26/2014",
+        "12/31/2014",
+        "1/1/2015",
+        "4/3/2015",
+        "4/6/2015",
+        "5/1/2015",
+        "5/25/2015",
+        "12/24/2015",
+        "12/25/2015",
+        "12/26/2015",
+        "12/31/2015",
+        "1/1/2016",
+        "3/25/2016",
+        "3/28/2016",
+        "12/26/2016",
+        "4/14/2017",
+        "4/17/2017",
+        "5/1/2017",
+        "12/25/2017",
+        "12/26/2017",
+        "1/1/2018",
+        "3/30/2018",
+        "4/2/2018",
+        "5/1/2018",
+        "12/24/2018",
+        "12/25/2018",
+        "12/26/2018",
+        "12/31/2018",
+        "1/1/2019",
+        "4/19/2019",
+        "4/22/2019",
+        "5/1/2019",
+        "12/24/2019",
+        "12/25/2019",
+        "12/26/2019",
+        "12/31/2019",
+        "1/1/2020",
+        "4/10/2020",
+        "4/13/2020",
+        "5/1/2020",
+        "12/24/2020",
+        "12/25/2020",
+        "12/31/2020",
+        "1/1/2021",
+        "4/2/2021",
+        "4/5/2021",
+        "12/24/2021",
+        "12/31/2021",
+        "4/15/2022",
+        "4/18/2022",
+        "12/26/2022",
+        "4/7/2023",
+        "4/10/2023",
+        "5/1/2023",
+        "12/25/2023",
+        "12/26/2023",
+        "1/1/2024",
+        "3/29/2024",
+        "4/1/2024",
+        "5/1/2024",
+        "12/24/2024",
+        "12/25/2024",
+        "12/26/2024",
+        "12/31/2024"
+      ]
+    },
+    "Future-eurex-FESX": {
+      "dataTimeZone": "Europe/Berlin",
+      "exchangeTimeZone": "Europe/Berlin",
+      "sunday": [],
+      "monday": [
+        {
+          "start": "01:10:00",
+          "end": "22:00:00",
+          "state": "market"
+        }
+      ],
+      "tuesday": [
+        {
+          "start": "01:10:00",
+          "end": "22:00:00",
+          "state": "market"
+        }
+      ],
+      "wednesday": [
+        {
+          "start": "01:10:00",
+          "end": "22:00:00",
+          "state": "market"
+        }
+      ],
+      "thursday": [
+        {
+          "start": "01:10:00",
+          "end": "22:00:00",
+          "state": "market"
+        }
+      ],
+      "friday": [
+        {
+          "start": "01:10:00",
+          "end": "22:00:00",
+          "state": "market"
+        }
+      ],
+      "saturday": [],
+      "holidays": [
+        "4/21/2000",
+        "4/24/2000",
+        "5/1/2000",
+        "12/25/2000",
+        "12/26/2000",
+        "1/1/2001",
+        "4/13/2001",
+        "4/16/2001",
+        "5/1/2001",
+        "12/24/2001",
+        "12/25/2001",
+        "12/26/2001",
+        "12/31/2001",
+        "1/1/2002",
+        "3/29/2002",
+        "4/1/2002",
+        "5/1/2002",
+        "12/24/2002",
+        "12/25/2002",
+        "12/26/2002",
+        "12/31/2002",
+        "1/1/2003",
+        "4/18/2003",
+        "4/21/2003",
+        "1/1/2004",
+        "4/9/2004",
+        "4/12/2004",
+        "5/1/2004",
+        "12/24/2004",
+        "12/24/2004",
+        "12/25/2004",
+        "12/26/2004",
+        "12/31/2004",
+        "12/31/2004",
+        "3/25/2005",
+        "3/28/2005",
+        "12/26/2005",
+        "4/14/2006",
+        "4/17/2006",
+        "5/1/2006",
+        "12/25/2006",
+        "12/26/2006",
+        "1/1/2007",
+        "4/6/2007",
+        "4/9/2007",
+        "5/1/2007",
+        "12/24/2007",
+        "12/25/2007",
+        "12/26/2007",
+        "12/31/2007",
+        "1/1/2008",
+        "3/21/2008",
+        "3/24/2008",
+        "5/1/2008",
+        "12/24/2008",
+        "12/25/2008",
+        "12/26/2008",
+        "12/31/2008",
+        "1/1/2009",
+        "4/10/2009",
+        "4/13/2009",
+        "5/1/2009",
+        "12/24/2009",
+        "12/25/2009",
+        "12/31/2009",
+        "1/1/2010",
+        "4/2/2010",
+        "4/5/2010",
+        "12/24/2010",
+        "12/31/2010",
+        "4/22/2011",
+        "4/25/2011",
+        "12/26/2011",
+        "4/6/2012",
+        "4/9/2012",
+        "5/1/2012",
+        "12/24/2012",
+        "12/25/2012",
+        "12/26/2012",
+        "12/31/2012",
+        "1/1/2013",
+        "3/29/2013",
+        "4/1/2013",
+        "5/1/2013",
+        "12/24/2013",
+        "12/25/2013",
+        "12/26/2013",
+        "12/31/2013",
+        "1/1/2014",
+        "4/18/2014",
+        "4/21/2014",
+        "5/1/2014",
+        "12/24/2014",
+        "12/25/2014",
+        "12/26/2014",
+        "12/31/2014",
+        "1/1/2015",
+        "4/3/2015",
+        "4/6/2015",
+        "5/1/2015",
+        "5/25/2015",
+        "12/24/2015",
+        "12/25/2015",
+        "12/26/2015",
+        "12/31/2015",
+        "1/1/2016",
+        "3/25/2016",
+        "3/28/2016",
+        "12/26/2016",
+        "4/14/2017",
+        "4/17/2017",
+        "5/1/2017",
+        "12/25/2017",
+        "12/26/2017",
+        "1/1/2018",
+        "3/30/2018",
+        "4/2/2018",
+        "5/1/2018",
+        "12/24/2018",
+        "12/25/2018",
+        "12/26/2018",
+        "12/31/2018",
+        "1/1/2019",
+        "4/19/2019",
+        "4/22/2019",
+        "5/1/2019",
+        "12/24/2019",
+        "12/25/2019",
+        "12/26/2019",
+        "12/31/2019",
+        "1/1/2020",
+        "4/10/2020",
+        "4/13/2020",
+        "5/1/2020",
+        "12/24/2020",
+        "12/25/2020",
+        "12/31/2020",
+        "1/1/2021",
+        "4/2/2021",
+        "4/5/2021",
+        "12/24/2021",
+        "12/31/2021",
+        "4/15/2022",
+        "4/18/2022",
+        "12/26/2022",
+        "4/7/2023",
+        "4/10/2023",
+        "5/1/2023",
+        "12/25/2023",
+        "12/26/2023",
+        "1/1/2024",
+        "3/29/2024",
+        "4/1/2024",
+        "5/1/2024",
+        "12/24/2024",
+        "12/25/2024",
+        "12/26/2024",
+        "12/31/2024"
+      ]
     }
   }
 }

Data/option/usa/universes/spy/20231228.csv

@@ -0,0 +1,24 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,476.8100,477.5300,476.2600,476.6900,59498271,,,,,,,
+SPY YEPD29TW8ETI|SPY R735QTJ8XC9X,SPY   231229C00270000,206.7850,208.0850,205.9000,206.6100,46,47,0.0000001,1,0,0,0,0
+SPY YEW96XE2ROXY|SPY R735QTJ8XC9X,SPY   240105C00270000,207.1400,208.3450,206.1650,206.9000,46,46,1.2716023,1,0,0,0,0
+SPY YEPD2AYWP9WM|SPY R735QTJ8XC9X,SPY   231229C00275000,201.7150,203.0850,200.6200,201.5850,0,,0.0000001,1,0,0,0,0
+SPY YEW96YJ38K12|SPY R735QTJ8XC9X,SPY   240105C00275000,202.1500,203.3400,201.1150,201.9350,0,,1.2324590,1,0,0,0,0
+SPY YEPD29U26QVA|SPY R735QTJ8XC9X,SPY   231229C00280000,196.7300,198.0350,195.8500,196.6150,10,6,0.0000001,1,0,0,0,0
+SPY YEW96XE8Q0ZQ|SPY R735QTJ8XC9X,SPY   240105C00280000,197.1600,198.3500,196.1250,196.9400,0,,1.1940285,1,0,0,0,0
+SPY YEPD2B0K8MEE|SPY R735QTJ8XC9X,SPY   231229C00285000,191.7200,193.0950,190.6500,191.6350,33,37,0.0000001,1,0,0,0,0
+SPY YEW96YKQRWIU|SPY R735QTJ8XC9X,SPY   240105C00285000,192.1700,193.3700,190.9850,191.9350,20,20,1.1562856,1,0,0,0,0
+SPY YEPD29U852X2|SPY R735QTJ8XC9X,SPY   231229C00290000,186.7900,188.1000,185.9150,186.6550,0,,0.0000001,1,0,0,0,0
+SPY YEW96XEEOD1I|SPY R735QTJ8XC9X,SPY   240105C00290000,187.1750,188.3800,186.0250,186.9400,0,,1.1192060,1,0,0,0,0
+SPY YEPD2B27RYW6|SPY R735QTJ8XC9X,SPY   231229C00295000,181.7900,183.1050,180.9200,181.6750,4,4,0.0000001,1,0,0,0,0
+SPY YEW96YMEB90M|SPY R735QTJ8XC9X,SPY   240105C00295000,182.1850,183.3800,181.1150,181.9650,0,,1.0827669,1,0,0,0,0
+SPY YEPD29PXEISM|SPY R735QTJ8XC9X,SPY   231229C00300000,176.7200,178.1050,175.8600,176.6550,0,4,0.0000001,1,0,0,0,0
+SPY YEW96XA3XSX2|SPY R735QTJ8XC9X,SPY   240105C00300000,177.1950,178.3900,176.2150,176.9750,0,,1.0469466,1,0,0,0,0
+SPY YEPD2B3VBBDY|SPY R735QTJ8XC9X,SPY   231229C00305000,171.7250,173.1150,170.9200,171.6600,0,,0.0000001,1,0,0,0,0
+SPY YEW96YO1ULIE|SPY R735QTJ8XC9X,SPY   240105C00305000,172.2050,173.4000,171.0100,171.9450,0,,1.0117244,1,0,0,0,0
+SPY YFA1G9SEX5RA|SPY R735QTJ8XC9X,SPY   240119C00305000,172.9300,174.2500,171.6450,172.6200,0,6,0.5837597,1,0,0,0,0
+SPY YEPD29UK1R0M|SPY R735QTJ8XC9X,SPY   231229C00310000,166.7600,168.1150,165.6950,166.6300,0,,0.0000001,1,0,0,0,0
+SPY YEW96XEQL152|SPY R735QTJ8XC9X,SPY   240105C00310000,167.2150,168.4100,166.1500,166.9950,0,,0.9770808,1,0,0,0,0
+SPY YEPD2B5IUNVQ|SPY R735QTJ8XC9X,SPY   231229C00315000,161.8000,163.1200,160.9200,161.6450,0,,0.0000001,1,0,0,0,0
+SPY YEW96YPPDY06|SPY R735QTJ8XC9X,SPY   240105C00315000,162.2200,163.4100,161.1500,162.0200,0,,0.9429972,1,0,0,0,0
+SPY YEPD29UQ032E|SPY R735QTJ8XC9X,SPY   231229C00320000,156.7250,158.1250,155.9200,156.6400,0,,0.0000001,1,0,0,0,0

Data/option/usa/universes/spy/20231229.csv

@@ -0,0 +1,16 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,476.4700,477.0200,473.3150,475.3100,96706712,,,,,,,
+SPY YETAUP0L4STI|SPY R735QTJ8XC9X,SPY   240102C00402000,74.5000,75.7850,71.5100,73.5200,1,,0.6225652,0.9990582,0.0001866,0.0015352,-0.0097524,-0.0007456
+SPY YEUAASDR7JZA|SPY R735QTJ8XC9X,SPY   240103C00402000,74.6900,75.8650,71.6300,73.6350,8,,0.5390879,0.9992449,0.0001939,0.0014585,-0.0055175,-0.0006899
+SPY YETAUP0R34VA|SPY R735QTJ8XC9X,SPY   240102C00403000,73.5000,74.7850,70.5400,72.5400,0,,0.6140000,0.9990404,0.0001911,0.0015516,-0.0107077,-0.0007402
+SPY YEUAASDX5W12|SPY R735QTJ8XC9X,SPY   240103C00403000,73.5900,74.8650,70.6350,72.6250,0,,0.5500093,0.9986411,0.0002501,0.0021631,-0.0108552,-0.0010937
+SPY YETAUP0X1GX2|SPY R735QTJ8XC9X,SPY   240102C00404000,72.5000,73.7800,69.5200,71.5350,0,1,0.6052588,0.9990271,0.0001953,0.0015642,-0.0113485,-0.0007372
+SPY YEUAASE3482U|SPY R735QTJ8XC9X,SPY   240103C00404000,72.6850,73.8650,69.6550,71.6300,8,,0.5241112,0.9992114,0.0002023,0.0015033,-0.0064616,-0.0006820
+SPY YETAUP12ZSYU|SPY R735QTJ8XC9X,SPY   240102C00405000,71.5000,72.7850,68.5550,70.5400,8,,0.5961598,0.9990230,0.0001989,0.0015696,-0.0113716,-0.0007268
+SPY YEUAASE92K4M|SPY R735QTJ8XC9X,SPY   240103C00405000,71.6000,72.8700,68.5850,70.6450,10,,0.5166274,0.9991950,0.0002078,0.0015250,-0.0069180,-0.0006887
+SPY YETAUP18Y50M|SPY R735QTJ8XC9X,SPY   240102C00406000,70.5000,71.7800,67.5500,69.5450,5,,0.5877552,0.9990020,0.0002047,0.0015896,-0.0125101,-0.0007239
+SPY YEUAASEF0W6E|SPY R735QTJ8XC9X,SPY   240103C00406000,70.6900,71.8700,67.6250,69.6500,6,,0.5088669,0.9991881,0.0002122,0.0015362,-0.0070462,-0.0006788
+SPY YETAUP1EWH2E|SPY R735QTJ8XC9X,SPY   240102C00407000,69.5000,70.7850,66.5500,68.5500,14,,0.5793580,0.9989810,0.0002107,0.0016087,-0.0129474,-0.0007251
+SPY YEUAASEKZ886|SPY R735QTJ8XC9X,SPY   240103C00407000,69.6900,70.8700,66.6050,68.6450,12,1,0.5016151,0.9991663,0.0002189,0.0015658,-0.0073815,-0.0006749
+SPY YETAUP1KUT46|SPY R735QTJ8XC9X,SPY   240102C00408000,68.5000,69.7850,65.5250,67.5550,8,,0.5708631,0.9989624,0.0002165,0.0016252,-0.0128765,-0.0007338
+SPY YEUAASEQXK9Y|SPY R735QTJ8XC9X,SPY   240103C00408000,68.6900,69.8700,65.6000,67.6350,0,,0.4943122,0.9991460,0.0002256,0.0015929,-0.0073707,-0.0007211

Data/option/usa/universes/spy/20240102.csv

@@ -0,0 +1,20 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,472.2100,473.6700,470.4900,472.6500,96336531,,,,,,,
+SPY YEUAASDR7JZA|SPY R735QTJ8XC9X,SPY   240103C00402000,70.2350,71.9700,68.2050,70.6750,1,6,0.0000001,1,0,0,0,0
+SPY YEV9QVQXAB52|SPY R735QTJ8XC9X,SPY   240104C00402000,70.4300,72.2050,68.4050,70.9600,0,1,1.0444474,0.9987106,0.0001826,0.0011904,-0.0503821,-0.0004696
+SPY YEUAASDX5W12|SPY R735QTJ8XC9X,SPY   240103C00403000,69.2350,70.9750,67.2100,69.6850,0,,0.0000001,1,0,0,0,0
+SPY YEV9QVR38N6U|SPY R735QTJ8XC9X,SPY   240104C00403000,69.4300,71.2100,67.4050,69.9200,0,,1.0296539,0.9986927,0.0001877,0.0011951,-0.0546676,-0.0004655
+SPY YEUAASE3482U|SPY R735QTJ8XC9X,SPY   240103C00404000,68.2350,69.9250,66.2100,68.6950,0,5,0.0000001,1,0,0,0,0
+SPY YEV9QVR96Z8M|SPY R735QTJ8XC9X,SPY   240104C00404000,68.4300,70.1750,66.4100,68.9200,0,,1.0150155,0.9986728,0.0001932,0.0011999,-0.0575827,-0.0004614
+SPY YEUAASE92K4M|SPY R735QTJ8XC9X,SPY   240103C00405000,67.2350,68.9700,65.2200,67.6950,0,6,0.0000001,1,0,0,0,0
+SPY YEV9QVRF5BAE|SPY R735QTJ8XC9X,SPY   240104C00405000,67.4400,69.2100,65.4100,67.8950,0,,1.0001185,0.9986563,0.0001984,0.0012042,-0.0569533,-0.0004559
+SPY YEUAASEF0W6E|SPY R735QTJ8XC9X,SPY   240103C00406000,66.2350,67.9800,64.2200,66.6900,0,4,0.0000001,1,0,0,0,0
+SPY YEV9QVRL3NC6|SPY R735QTJ8XC9X,SPY   240104C00406000,66.4400,68.2150,64.4100,66.9300,0,,0.9852584,0.9986394,0.0002038,0.0012083,-0.0563180,-0.0004550
+SPY YEUAASEKZ886|SPY R735QTJ8XC9X,SPY   240103C00407000,65.2350,66.9750,63.2150,65.6800,0,8,0.0000001,1,0,0,0,0
+SPY YEV9QVRR1ZDY|SPY R735QTJ8XC9X,SPY   240104C00407000,65.4400,67.2100,63.5150,65.9250,0,,0.9704350,0.9986219,0.0002095,0.0012122,-0.0556880,-0.0004510
+SPY YEUAASEQXK9Y|SPY R735QTJ8XC9X,SPY   240103C00408000,64.2400,65.8150,62.2150,64.6900,0,,0.0000001,1,0,0,0,0
+SPY YEV9QVRX0BFQ|SPY R735QTJ8XC9X,SPY   240104C00408000,64.4400,66.2100,62.4100,64.9500,0,1,0.9556481,0.9986041,0.0002154,0.0012163,-0.0550450,-0.0004467
+SPY YEUAASEWVWBQ|SPY R735QTJ8XC9X,SPY   240103C00409000,63.2400,64.9700,61.2150,63.6950,0,,0.0000001,1,0,0,0,0
+SPY YEV9QVS2YNHI|SPY R735QTJ8XC9X,SPY   240104C00409000,63.4400,65.2150,61.4100,63.9600,0,,0.9408974,0.9985857,0.0002215,0.0012205,-0.0543964,-0.0004403
+SPY YEUAAQQ1YVBA|SPY R735QTJ8XC9X,SPY   240103C00410000,62.2400,63.9750,60.2150,62.6900,1,2,0.0000001,1,0,0,0,0
+SPY YEV9QU381MH2|SPY R735QTJ8XC9X,SPY   240104C00410000,62.4400,64.2100,60.4150,62.9650,0,,0.9261830,0.9985668,0.0002279,0.0012248,-0.0537200,-0.0004386

Data/option/usa/universes/spy/20240103.csv

@@ -0,0 +1,23 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,470.5000,471.1800,468.1700,468.7900,90315933,,,,,,,
+SPY YM94G4IBZOFA|SPY R735QTJ8XC9X,SPY   240930C00401000,88.9300,88.9300,84.9950,85.7100,0,42,0.1906751,0.8395376,0.0033206,0.9109065,-0.0277559,-0.1929455
+SPY YEV9QVQXAB52|SPY R735QTJ8XC9X,SPY   240104C00402000,70.9600,70.9600,66.0550,66.8950,0,1,0.0000001,1,0,0,0,0
+SPY YEW96Z43D2AU|SPY R735QTJ8XC9X,SPY   240105C00402000,70.9800,70.9800,66.2000,67.0550,0,2,0.9961277,0.9986427,0.0002028,0.0011969,-0.0564078,-0.0004561
+SPY YEV9QVR38N6U|SPY R735QTJ8XC9X,SPY   240104C00403000,69.9200,69.9200,65.0600,65.8600,0,,0.0000001,1,0,0,0,0
+SPY YEW96Z49BECM|SPY R735QTJ8XC9X,SPY   240105C00403000,69.9750,69.9750,65.1300,65.9800,0,1,0.9811561,0.9986254,0.0002084,0.0012009,-0.0557766,-0.0004520
+SPY YEV9QVR96Z8M|SPY R735QTJ8XC9X,SPY   240104C00404000,68.9200,68.9200,64.0600,64.8700,0,,0.0000001,1,0,0,0,0
+SPY YEW96Z4F9QEE|SPY R735QTJ8XC9X,SPY   240105C00404000,68.9850,68.9850,64.1300,64.9900,0,6,0.9662217,0.9986076,0.0002143,0.0012049,-0.0551323,-0.0004477
+SPY YEV9QVRF5BAE|SPY R735QTJ8XC9X,SPY   240104C00405000,67.8950,67.8950,63.0600,63.8750,0,,0.0000001,1,0,0,0,0
+SPY YEW96Z4L82G6|SPY R735QTJ8XC9X,SPY   240105C00405000,67.9800,67.9800,63.1350,63.9900,0,2,0.9513244,0.9985892,0.0002204,0.0012091,-0.0544908,-0.0004408
+SPY YEV9QVRL3NC6|SPY R735QTJ8XC9X,SPY   240104C00406000,66.9300,66.9300,62.0650,62.8550,0,,0.0000001,1,0,0,0,0
+SPY YEW96Z4R6EHY|SPY R735QTJ8XC9X,SPY   240105C00406000,66.9650,66.9650,62.1350,62.9700,1,1,0.9364639,0.9985704,0.0002267,0.0012133,-0.0538141,-0.0004393
+SPY YEV9QVRR1ZDY|SPY R735QTJ8XC9X,SPY   240104C00407000,65.9250,65.9250,61.0350,61.9600,0,,0.0000001,1,0,0,0,0
+SPY YEW96Z4X4QJQ|SPY R735QTJ8XC9X,SPY   240105C00407000,65.9700,65.9700,61.1300,62.0150,0,2,0.9216401,0.9985510,0.0002334,0.0012173,-0.0531547,-0.0004358
+SPY YEV9QVRX0BFQ|SPY R735QTJ8XC9X,SPY   240104C00408000,64.9500,64.9500,60.0550,60.8650,0,1,0.0000001,1,0,0,0,0
+SPY YEW96Z5332LI|SPY R735QTJ8XC9X,SPY   240105C00408000,65.0150,65.0150,60.1350,61.0300,0,,0.9068528,0.9985310,0.0002403,0.0012213,-0.0524903,-0.0004302
+SPY YEV9QVS2YNHI|SPY R735QTJ8XC9X,SPY   240104C00409000,63.9600,63.9600,59.0650,60.0200,0,,0.0000001,1,0,0,0,0
+SPY YEW96Z591ENA|SPY R735QTJ8XC9X,SPY   240105C00409000,64.0250,64.0250,59.1350,60.0400,0,1,0.8921019,0.9985105,0.0002476,0.0012254,-0.0518212,-0.0004259
+SPY YEV9QU381MH2|SPY R735QTJ8XC9X,SPY   240104C00410000,62.9650,62.9650,58.0700,58.9850,0,,0.0000001,1,0,0,0,0
+SPY YEW96XGE4DMU|SPY R735QTJ8XC9X,SPY   240105C00410000,62.9550,62.9550,58.1250,59.0000,1,7,0.8773871,0.9984893,0.0002552,0.0012295,-0.0511404,-0.0004220
+SPY YEV9QVSEVBL2|SPY R735QTJ8XC9X,SPY   240104C00411000,61.9300,61.9300,57.0600,57.9550,0,1,0.0000001,1,0,0,0,0
+SPY YEW96Z5KY2QU|SPY R735QTJ8XC9X,SPY   240105C00411000,61.9900,61.9900,57.1350,58.0200,0,1,0.8627082,0.9984675,0.0002631,0.0012336,-0.0504563,-0.0004170

Data/option/usa/universes/spy/20240104.csv

@@ -0,0 +1,38 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,468.3500,470.9600,467.0500,467.2800,69508521,,,,,,,
+SPY Z8DP3QTE6IJQ|SPY R735QTJ8XC9X,SPY   261218C00265000,224.5000,231.4700,219.4200,223.5000,0,,0.2530959,0.9887201,0.0011566,0.2251360,-0.0004415,-0.1629460
+SPY YEW96YPPDY06|SPY R735QTJ8XC9X,SPY   240105C00315000,153.9250,156.0600,151.6950,152.3050,0,,0.0000001,1,0,0,0,0
+SPY Z8DP3R1NV90M|SPY R735QTJ8XC9X,SPY   261218C00315000,184.2500,189.0800,181.2300,183.0000,0,1,0.2251698,0.8960158,0.0017944,1.0649696,-0.0056454,-0.7803062
+SPY YEW96XEWJD6U|SPY R735QTJ8XC9X,SPY   240105C00320000,148.8650,151.0650,146.6950,147.3100,0,,0.0000001,1,0,0,0,0
+SPY Z8DP3PQV0O7A|SPY R735QTJ8XC9X,SPY   261218C00320000,180.0000,185.3800,177.3300,179.5000,0,1,0.2185436,0.8913955,0.0018672,1.1200809,-0.0063467,-0.7841679
+SPY YEW96YRCXAHY|SPY R735QTJ8XC9X,SPY   240105C00325000,143.8700,146.0650,141.7000,142.3350,0,,0.0000001,1,0,0,0,0
+SPY Z8DP3R3BELIE|SPY R735QTJ8XC9X,SPY   261218C00325000,176.0000,181.4350,173.4350,175.7500,0,,0.2171176,0.8800423,0.0018949,1.1885142,-0.0071088,-0.8503416
+SPY YEW96YRIVMJQ|SPY R735QTJ8XC9X,SPY   240105C00326000,142.9450,145.0650,140.7600,141.3300,0,,0.0000001,1,0,0,0,0
+SPY YEW96YROTYLI|SPY R735QTJ8XC9X,SPY   240105C00327000,141.8700,144.0700,139.7600,140.3650,0,,0.0000001,1,0,0,0,0
+SPY YEW96YRUSANA|SPY R735QTJ8XC9X,SPY   240105C00328000,140.8750,143.0700,138.8050,139.3300,0,,0.0000001,1,0,0,0,0
+SPY YEW96YS0QMP2|SPY R735QTJ8XC9X,SPY   240105C00329000,139.8650,142.0700,137.7650,138.3100,0,,0.0000001,1,0,0,0,0
+SPY YEW96XF2HP8M|SPY R735QTJ8XC9X,SPY   240105C00330000,138.8800,141.0700,136.7050,137.3850,0,7,0.0000001,1,0,0,0,0
+SPY Z8DP3PR0Z092|SPY R735QTJ8XC9X,SPY   261218C00330000,172.2500,177.5050,169.6050,171.7500,0,,0.2073876,0.8793950,0.0019980,1.1983140,-0.0068509,-0.8130756
+SPY YEW96YSCNASM|SPY R735QTJ8XC9X,SPY   240105C00331000,137.8200,140.0700,135.7650,136.3550,0,,0.0000001,1,0,0,0,0
+SPY YEW96YSILMUE|SPY R735QTJ8XC9X,SPY   240105C00332000,136.8700,139.0700,134.7050,135.4050,0,,0.0000001,1,0,0,0,0
+SPY YEW96YSOJYW6|SPY R735QTJ8XC9X,SPY   240105C00333000,135.8800,138.0700,133.7100,134.3150,0,,0.0000001,1,0,0,0,0
+SPY YEW96YSUIAXY|SPY R735QTJ8XC9X,SPY   240105C00334000,134.8750,137.0750,132.7050,133.3350,0,,0.0000001,1,0,0,0,0
+SPY YEW96YT0GMZQ|SPY R735QTJ8XC9X,SPY   240105C00335000,133.8850,136.0750,131.7650,132.3700,0,,0.0000001,1,0,0,0,0
+SPY Z8DP3R4YXY06|SPY R735QTJ8XC9X,SPY   261218C00335000,168.7500,173.5900,165.7650,167.5000,0,,0.2154184,0.8551619,0.0019415,1.3505771,-0.0080640,-0.9337619
+SPY YEW96YT6EZ1I|SPY R735QTJ8XC9X,SPY   240105C00336000,132.8900,135.0750,130.7050,131.3550,0,,0.0000001,1,0,0,0,0
+SPY YEW96YTCDB3A|SPY R735QTJ8XC9X,SPY   240105C00337000,132.1100,134.0750,129.7100,130.3600,0,,0.0000001,1,0,0,0,0
+SPY YEW96YTIBN52|SPY R735QTJ8XC9X,SPY   240105C00338000,130.8850,133.0750,128.7100,129.3650,0,,0.0000001,1,0,0,0,0
+SPY YEW96YTO9Z6U|SPY R735QTJ8XC9X,SPY   240105C00339000,129.8750,132.0750,127.7100,128.3650,0,,0.0000001,1,0,0,0,0
+SPY YEW96XF8G1AE|SPY R735QTJ8XC9X,SPY   240105C00340000,128.7650,131.0800,126.9050,127.3700,0,,0.0000001,1,0,0,0,0
+SPY YYFADOLR2PVQ|SPY R735QTJ8XC9X,SPY   251219C00340000,155.5000,158.0550,153.2450,154.2500,0,41,0.2213402,0.8793751,0.0019453,1.0481947,-0.0100939,-0.6165659
+SPY YZ6UWAUH7UDI|SPY R735QTJ8XC9X,SPY   260116C00340000,155.7500,158.0000,153.6800,154.5050,0,5,0.2217299,0.8745455,0.0019359,1.1233462,-0.0105301,-0.6370790
+SPY Z8DP3PR6XCAU|SPY R735QTJ8XC9X,SPY   261218C00340000,164.5000,169.9350,161.9350,164.0000,0,25,0.2046498,0.8550012,0.0020583,1.3530355,-0.0077142,-0.8852939
+SPY YEW96YU06NAE|SPY R735QTJ8XC9X,SPY   240105C00341000,128.0850,130.0800,125.7100,126.3350,0,,0.0000001,1,0,0,0,0
+SPY YEW96YU64ZC6|SPY R735QTJ8XC9X,SPY   240105C00342000,126.8850,129.0800,124.7700,125.3650,0,,0.0000001,1,0,0,0,0
+SPY YEW96YUC3BDY|SPY R735QTJ8XC9X,SPY   240105C00343000,125.8900,128.0800,123.7100,124.3750,0,,0.0000001,1,0,0,0,0
+SPY YEW96YUI1NFQ|SPY R735QTJ8XC9X,SPY   240105C00344000,125.1100,127.0800,122.7750,123.3250,0,,0.0000001,1,0,0,0,0
+SPY YEW96YUNZZHI|SPY R735QTJ8XC9X,SPY   240105C00345000,123.8700,126.0800,121.7150,122.3150,0,,0.0000001,1,0,0,0,0
+SPY YTG30PGGPCVA|SPY R735QTJ8XC9X,SPY   250620C00345000,145.7500,150.1800,141.8550,144.5050,0,7,0.2244864,0.8948588,0.0019484,0.8623178,-0.0128214,-0.4456611
+SPY YYFADQ16MO2U|SPY R735QTJ8XC9X,SPY   251219C00345000,151.2500,153.9500,149.1550,150.2500,0,30,0.2165133,0.8713837,0.0020113,1.1328990,-0.0117288,-0.6071148
+SPY YZ6UWC9WRSKM|SPY R735QTJ8XC9X,SPY   260116C00345000,151.5000,153.9900,149.6850,150.5000,0,3,0.2120927,0.8724199,0.0020376,1.1392599,-0.0109666,-0.6088566
+SPY Z8DP3R6MHAHY|SPY R735QTJ8XC9X,SPY   261218C00345000,160.7500,166.0400,158.1650,160.0000,0,,0.2081333,0.8363435,0.0020331,1.5416429,-0.0095248,-0.9302435

Data/option/usa/universes/spy/20240105.csv

@@ -0,0 +1,21 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,467.4400,470.4400,466.4300,467.9200,74304611,,,,,,,
+SPY YH5ZAQHFMCPY|SPY R735QTJ8XC9X,SPY   240328C00404000,69.0350,72.4550,67.4800,69.3250,0,108,0.2033026,0.9414430,0.0028436,0.2523082,-0.0274981,-0.0470943
+SPY YJOKFC4YNRHI|SPY R735QTJ8XC9X,SPY   240628C00404000,75.4850,78.6800,74.2850,75.3250,40,136,0.1896656,0.8763471,0.0034973,0.6400785,-0.0307813,-0.1120247
+SPY YM94G4ITUOKM|SPY R735QTJ8XC9X,SPY   240930C00404000,81.6150,84.3700,80.1550,81.7550,0,4,0.1845833,0.8332365,0.0035214,0.9163969,-0.0273540,-0.1833526
+SPY YEZ7J983GBXI|SPY R735QTJ8XC9X,SPY   240108C00405000,62.4200,65.6200,61.3050,63.1200,4,,0.6647743,0.9987164,0.0002343,0.0015368,-0.0229803,-0.0006487
+SPY YF06ZCL9J33A|SPY R735QTJ8XC9X,SPY   240109C00405000,62.4800,65.7300,61.3700,63.0350,0,,0.5427059,0.9988816,0.0002437,0.0016609,-0.0126945,-0.0007335
+SPY YEZ7J989ENZA|SPY R735QTJ8XC9X,SPY   240108C00406000,61.4250,64.6650,60.3050,62.1250,0,,0.6542663,0.9986965,0.0002410,0.0015457,-0.0227714,-0.0006381
+SPY YJOKFC5AKFL2|SPY R735QTJ8XC9X,SPY   240628C00406000,73.6800,76.8550,72.5050,74.1600,0,107,0.1872376,0.8711568,0.0036292,0.6461438,-0.0307593,-0.1106796
+SPY YEZ7J98FD012|SPY R735QTJ8XC9X,SPY   240108C00407000,60.2750,63.6600,59.3000,61.2200,1,2,0.6437842,0.9986761,0.0002480,0.0015545,-0.0225352,-0.0006382
+SPY YF06ZCLLFR6U|SPY R735QTJ8XC9X,SPY   240109C00407000,60.4500,63.7350,59.3750,61.0400,0,,0.5255675,0.9988405,0.0002579,0.0016897,-0.0125766,-0.0007257
+SPY YEZ7J98LBC2U|SPY R735QTJ8XC9X,SPY   240108C00408000,59.4350,62.6100,58.3000,60.1700,1,1,0.6333279,0.9986551,0.0002553,0.0015633,-0.0223045,-0.0006369
+SPY YF06ZCLRE38M|SPY R735QTJ8XC9X,SPY   240109C00408000,59.4600,62.7750,58.3750,60.2550,0,,0.5170300,0.9988191,0.0002654,0.0017036,-0.0125052,-0.0007346
+SPY YEZ7J98R9O4M|SPY R735QTJ8XC9X,SPY   240108C00409000,58.4400,61.6550,57.3050,59.1900,0,,0.6228974,0.9986334,0.0002629,0.0015723,-0.0220815,-0.0006281
+SPY YF06ZCLXCFAE|SPY R735QTJ8XC9X,SPY   240109C00409000,58.4500,61.7950,57.3800,59.2550,0,,0.5085135,0.9987970,0.0002733,0.0017175,-0.0124366,-0.0007292
+SPY YEZ7J7JWCN46|SPY R735QTJ8XC9X,SPY   240108C00410000,57.5400,60.6650,56.3050,58.1850,2,1,0.6124924,0.9986110,0.0002710,0.0015815,-0.0218439,-0.0006191
+SPY YF06ZAX2FE9Y|SPY R735QTJ8XC9X,SPY   240109C00410000,57.4800,60.7750,56.3700,58.2550,0,,0.5000178,0.9987742,0.0002814,0.0017323,-0.0123604,-0.0007172
+SPY YEZ7J9936C86|SPY R735QTJ8XC9X,SPY   240108C00411000,56.4450,59.6550,55.3050,57.1850,1,1,0.6021128,0.9985878,0.0002794,0.0015903,-0.0215896,-0.0006170
+SPY YF06ZCM993DY|SPY R735QTJ8XC9X,SPY   240109C00411000,56.4500,59.8050,55.3800,57.0150,0,,0.4915429,0.9987506,0.0002899,0.0017470,-0.0122585,-0.0007270
+SPY YEZ7J9994O9Y|SPY R735QTJ8XC9X,SPY   240108C00412000,55.4450,58.6550,54.3100,56.1850,1,1,0.5917585,0.9985640,0.0002883,0.0015994,-0.0213436,-0.0006120
+SPY YF06ZCMF7FFQ|SPY R735QTJ8XC9X,SPY   240109C00412000,55.4850,58.7900,54.3800,56.0250,0,,0.5018704,0.9979429,0.0003795,0.0029132,-0.0218174,-0.0009296.0025941

Data/option/usa/universes/spy/20240108.csv

@@ -0,0 +1,22 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,468.3800,474.7400,468.3300,474.6000,68277421,,,,,,,
+SPY YM94G4ITUOKM|SPY R735QTJ8XC9X,SPY   240930C00404000,81.7550,88.0800,81.4400,87.3550,0,4,0.1857914,0.8549470,0.0032380,0.8669661,-0.0234441,-0.1890177
+SPY YF06ZCL9J33A|SPY R735QTJ8XC9X,SPY   240109C00405000,63.0350,70.0000,62.6550,69.5900,0,,0.0000001,1,0,0,0,0
+SPY YF16FFYFLU92|SPY R735QTJ8XC9X,SPY   240110C00405000,63.0800,70.0400,62.8150,69.6200,3,3,1.0243866,0.9986906,0.0001882,0.0012008,-0.0551000,-0.0004651
+SPY YF06ZCLFHF52|SPY R735QTJ8XC9X,SPY   240109C00406000,62.2650,69.0300,61.9450,68.6850,0,,0.0000001,1,0,0,0,0
+SPY YF16FFYLK6AU|SPY R735QTJ8XC9X,SPY   240110C00406000,62.0950,69.0200,61.7150,68.6350,0,1,1.0097577,0.9986715,0.0001936,0.0012056,-0.0575529,-0.0004610
+SPY YF06ZCLLFR6U|SPY R735QTJ8XC9X,SPY   240109C00407000,61.0400,68.0300,60.7800,67.5600,0,,0.0000001,1,0,0,0,0
+SPY YF16FFYRIICM|SPY R735QTJ8XC9X,SPY   240110C00407000,61.0950,68.0400,60.8150,67.6150,0,,0.9949344,0.9986550,0.0001988,0.0012098,-0.0569222,-0.0004568
+SPY YF06ZCLRE38M|SPY R735QTJ8XC9X,SPY   240109C00408000,60.2550,66.9650,59.9350,66.5600,0,,0.0000001,1,0,0,0,0
+SPY YF16FFYXGUEE|SPY R735QTJ8XC9X,SPY   240110C00408000,60.0950,66.9950,59.8050,66.6200,0,,0.9801477,0.9986380,0.0002043,0.0012139,-0.0562868,-0.0004553
+SPY YF06ZCLXCFAE|SPY R735QTJ8XC9X,SPY   240109C00409000,59.2550,66.0350,58.9500,65.5350,0,,0.0000001,1,0,0,0,0
+SPY YF16FFZ3F6G6|SPY R735QTJ8XC9X,SPY   240110C00409000,59.0950,66.0350,58.8100,65.6200,0,,0.9653973,0.9986206,0.0002099,0.0012179,-0.0556558,-0.0004506
+SPY YF06ZAX2FE9Y|SPY R735QTJ8XC9X,SPY   240109C00410000,58.2550,64.9650,57.9500,64.5600,1,1,0.0000001,1,0,0,0,0
+SPY YF16FEA8I5FQ|SPY R735QTJ8XC9X,SPY   240110C00410000,58.1000,65.0200,57.8150,64.6400,0,,0.9506830,0.9986027,0.0002158,0.0012220,-0.0550140,-0.0004463
+SPY Z8DP3PSCLONA|SPY R735QTJ8XC9X,SPY   261218C00410000,114.0000,119.6650,111.1650,118.9700,0,5,0.1779143,0.6985475,0.0025528,2.3278853,-0.0144928,-0.8485138
+SPY YF06ZCM993DY|SPY R735QTJ8XC9X,SPY   240109C00411000,57.0150,64.0300,56.7350,63.5700,0,,0.0000001,1,0,0,0,0
+SPY YF16FFZFBUJQ|SPY R735QTJ8XC9X,SPY   240110C00411000,57.1350,64.0200,56.8650,63.6400,0,,0.9360046,0.9985843,0.0002220,0.0012262,-0.0543628,-0.0004408
+SPY YF06ZCMF7FFQ|SPY R735QTJ8XC9X,SPY   240109C00412000,56.0250,63.0200,55.7450,62.5900,0,,0.0000001,1,0,0,0,0
+SPY YF16FFZLA6LI|SPY R735QTJ8XC9X,SPY   240110C00412000,56.2950,63.0500,56.0150,62.6250,0,,0.9213621,0.9985653,0.0002284,0.0012304,-0.0536868,-0.0004385
+SPY YF06ZCML5RHI|SPY R735QTJ8XC9X,SPY   240109C00413000,55.0150,62.0300,54.7350,61.5750,0,,0.0000001,1,0,0,0,0
+SPY YF16FFZR8INA|SPY R735QTJ8XC9X,SPY   240110C00413000,55.1000,62.0250,54.8250,61.6200,0,,0.9067552,0.9985458,0.0002351,0.0012345,-0.0530308,-0.0004344

Data/option/usa/universes/spy/20240109.csv

@@ -0,0 +1,25 @@
+#symbol_id,symbol_value,open,high,low,close,volume,open_interest,implied_volatility,delta,gamma,vega,theta,rho
+SPY R735QTJ8XC9X,SPY,471.8800,474.9300,471.3550,473.8800,59621043,,,,,,,
+SPY YM94G4ITUOKM|SPY R735QTJ8XC9X,SPY   240930C00404000,87.3550,88.0450,84.0350,86.5800,0,4,0.1840764,0.8551702,0.0032760,0.8618596,-0.0232696,-0.1858383
+SPY YF16FFYFLU92|SPY R735QTJ8XC9X,SPY   240110C00405000,69.6200,69.9700,65.8350,68.9000,0,3,0.0000001,1,0,0,0,0
+SPY YF25VJBLOLEU|SPY R735QTJ8XC9X,SPY   240111C00405000,69.8400,70.5600,66.0950,69.2100,0,,1.0155835,0.9986762,0.0001921,0.0012024,-0.0577236,-0.0004630
+SPY YF16FFYLK6AU|SPY R735QTJ8XC9X,SPY   240110C00406000,68.6350,68.9550,64.8400,67.9050,0,1,0.0000001,1,0,0,0,0
+SPY YF25VJBRMXGM|SPY R735QTJ8XC9X,SPY   240111C00406000,68.8200,69.5450,65.0950,68.2100,0,1,1.0007235,0.9986598,0.0001973,0.0012066,-0.0571013,-0.0004564
+SPY YF16FFYRIICM|SPY R735QTJ8XC9X,SPY   240110C00407000,67.6150,67.9700,63.8950,66.9100,0,,0.0000001,1,0,0,0,0
+SPY YF25VJBXL9IE|SPY R735QTJ8XC9X,SPY   240111C00407000,67.9500,68.3250,64.1000,67.2300,0,,0.9859002,0.9986430,0.0002027,0.0012108,-0.0564684,-0.0004566
+SPY YF35BMP3O0O6|SPY R735QTJ8XC9X,SPY   240112C00407000,67.9450,68.4000,64.1600,67.2500,2,3,0.7235212,0.9981417,0.0002706,0.0022215,-0.0275138,-0.0008316
+SPY YF16FFYXGUEE|SPY R735QTJ8XC9X,SPY   240110C00408000,66.6200,66.9700,62.8400,65.9150,0,,0.0000001,1,0,0,0,0
+SPY YF25VJC3JLK6|SPY R735QTJ8XC9X,SPY   240111C00408000,66.9400,67.3050,63.1000,66.2150,0,,0.9711134,0.9986257,0.0002083,0.0012147,-0.0558355,-0.0004526
+SPY YF35BMP9MCPY|SPY R735QTJ8XC9X,SPY   240112C00408000,66.9550,67.3700,63.1650,66.2550,0,1,0.7130112,0.9981067,0.0002779,0.0023266,-0.0272431,-0.0008218
+SPY YF16FFZ3F6G6|SPY R735QTJ8XC9X,SPY   240110C00409000,65.6200,65.9700,61.8950,64.9150,0,,0.0000001,1,0,0,0,0
+SPY YF25VJC9HXLY|SPY R735QTJ8XC9X,SPY   240111C00409000,65.9500,66.3650,62.1000,65.2350,0,,0.9563629,0.9986079,0.0002141,0.0012188,-0.0551911,-0.0004483
+SPY YF16FEA8I5FQ|SPY R735QTJ8XC9X,SPY   240110C00410000,64.6400,64.9600,60.8600,63.9100,1,1,0.0000001,1,0,0,0,0
+SPY YF25VHNEKWLI|SPY R735QTJ8XC9X,SPY   240111C00410000,64.9600,65.3050,61.1000,64.2350,0,119,0.9416485,0.9985897,0.0002202,0.0012230,-0.0545531,-0.0004414
+SPY YF16FFZFBUJQ|SPY R735QTJ8XC9X,SPY   240110C00411000,63.6400,63.9750,59.8400,62.9100,0,,0.0000001,1,0,0,0,0
+SPY YF25VJCLELPI|SPY R735QTJ8XC9X,SPY   240111C00411000,63.9550,64.3200,60.1050,63.1900,0,,0.9269701,0.9985709,0.0002265,0.0012273,-0.0538773,-0.0004396
+SPY YF16FFZLA6LI|SPY R735QTJ8XC9X,SPY   240110C00412000,62.6250,62.9600,58.8400,61.9250,0,,0.0000001,1,0,0,0,0
+SPY YF25VJCRCXRA|SPY R735QTJ8XC9X,SPY   240111C00412000,62.9550,63.3100,59.1050,62.2350,0,,0.9123275,0.9985515,0.0002331,0.0012313,-0.0532144,-0.0004361
+SPY YF35BMPXFOX2|SPY R735QTJ8XC9X,SPY   240112C00412000,62.9450,63.4000,59.1700,62.2600,0,,0.6704539,0.9979796,0.0003110,0.0025083,-0.0349754,-0.0007904
+SPY YFA1GAA3YZ1I|SPY R735QTJ8XC9X,SPY   240119C00412000,63.3450,63.8050,59.6450,62.6500,0,886,0.3608598,0.9945798,0.0007279,0.0111471,-0.0190700,-0.0034017
+SPY YF16FFZR8INA|SPY R735QTJ8XC9X,SPY   240110C00413000,61.6200,61.9600,57.8450,60.9200,0,,0.0000001,1,0,0,0,0
+SPY YF25VJCXB9T2|SPY R735QTJ8XC9X,SPY   240111C00413000,61.9650,62.3200,58.1050,61.2250,0,,0.8977205,0.9985316,0.0002401,0.0012353,-0.0525510,-0.0004308