diff --git a/Algorithm.CSharp/OptionChainFiltersRegressionAlgorithm.cs b/Algorithm.CSharp/OptionChainFiltersRegressionAlgorithm.cs
new file mode 100644
index 000000000000..d73971b1fa41
--- /dev/null
+++ b/Algorithm.CSharp/OptionChainFiltersRegressionAlgorithm.cs
@@ -0,0 +1,195 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm demonstrating that option chains can be filtered with the same filters used for
+    /// option universe selection, both on chains from <see cref="QCAlgorithm.OptionChain(Symbol, bool)"/>
+    /// and on the chains delivered in the slice
+    /// </summary>
+    public class OptionChainFiltersRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _option;
+        private bool _traded;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+
+            var option = AddOption("GOOG");
+            _option = option.Symbol;
+            // The same words select the universe and, below, narrow down the chains
+            option.SetFilter(universe => universe.CallsOnly().Expiration(1, 10).Strikes(-2, 2));
+
+            var chain = OptionChain(_option);
+            if (chain.Count == 0)
+            {
+                throw new RegressionTestException("Expected a non empty option chain");
+            }
+            // The relative strikes filter needs the underlying price, chains built from universe data must carry it
+            if (chain.Underlying.Price == 0)
+            {
+                throw new RegressionTestException("Expected the chain to carry the underlying price");
+            }
+
+            var totalContracts = chain.Count;
+            var filtered = chain.CallsOnly().Expiration(1, 10).Strikes(-2, 2);
+            // GOOG closed at 748.54 on 2015-12-23 and the only expiration 1 to 10 days out is 2015-12-31,
+            // so the two strikes below the spot and the two at or above it are 745, 747.5, 750 and 752.5
+            AssertContracts(filtered, OptionRight.Call, new DateTime(2015, 12, 31), new[] { 745m, 747.5m, 750m, 752.5m });
+            if (chain.Count != totalContracts)
+            {
+                throw new RegressionTestException("Filters must not modify the source chain");
+            }
+
+            // Front month is the nearest expiration, 2015-12-24 itself
+            AssertContracts(chain.PutsOnly().FrontMonth(), OptionRight.Put, new DateTime(2015, 12, 24));
+
+            // Standard contracts expire on the third Friday, weeklys do not
+            var standards = chain.StandardsOnly().FrontMonth();
+            if (standards.Count == 0 || standards.Any(x => x.Expiry != new DateTime(2016, 1, 15)))
+            {
+                throw new RegressionTestException("Expected the standard front month to expire on 2016-01-15");
+            }
+            var weeklys = chain.WeeklysOnly();
+            if (weeklys.Count == 0 || weeklys.Any(x => OptionSymbol.IsStandard(x.Symbol)))
+            {
+                throw new RegressionTestException("Expected only weekly contracts");
+            }
+
+            // Greeks filters use the greeks the chain carries
+            var deltas = chain.Delta(0.5m, 0.6m);
+            var expectedDeltas = chain.Count(x => x.Greeks.Delta >= 0.5m && x.Greeks.Delta <= 0.6m);
+            if (deltas.Count == 0 || deltas.Count != expectedDeltas || deltas.Any(x => x.Greeks.Delta < 0.5m || x.Greeks.Delta > 0.6m))
+            {
+                throw new RegressionTestException("Delta filter mismatch");
+            }
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (_traded || !slice.OptionChains.TryGetValue(_option, out var chain))
+            {
+                return;
+            }
+
+            // The universe only selected calls expiring 1 to 10 days out, so the chain filters agree with it
+            if (chain.CallsOnly().Expiration(1, 10).Count != chain.Count || chain.PutsOnly().Count != 0)
+            {
+                throw new RegressionTestException("Slice chain filters disagree with the universe filter");
+            }
+
+            // Buy the call at the first strike at or above the underlying price
+            var contract = chain.Strikes(0, 0).FirstOrDefault();
+            if (contract != null)
+            {
+                MarketOrder(contract.Symbol, 1);
+                _traded = true;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_traded)
+            {
+                throw new RegressionTestException("Expected to trade a contract selected from the slice option chain");
+            }
+        }
+
+        private static void AssertContracts(OptionChain chain, OptionRight right, DateTime expiry, decimal[] strikes = null)
+        {
+            if (chain.Count == 0 || chain.Any(x => x.Right != right || x.Expiry != expiry))
+            {
+                throw new RegressionTestException($"Expected only {right} contracts expiring on {expiry:yyyy-MM-dd}");
+            }
+            if (strikes != null && !chain.Select(x => x.Strike).OrderBy(x => x).SequenceEqual(strikes))
+            {
+                throw new RegressionTestException($"Unexpected strikes: {string.Join(", ", chain.Select(x => x.Strike))}");
+            }
+        }
+
+        /// <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 => 7080;
+
+        /// <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", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "99764"},
+            {"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", "$1.00"},
+            {"Estimated Strategy Capacity", "$36000.00"},
+            {"Lowest Capacity Asset", "GOOCV W6U7P9WYPQVA|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "0.73%"},
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "d505d8b11141dfd2d54b74ac20e39268"}
+        };
+    }
+}
diff --git a/Algorithm.CSharp/OptionChainStrategyFiltersRegressionAlgorithm.cs b/Algorithm.CSharp/OptionChainStrategyFiltersRegressionAlgorithm.cs
new file mode 100644
index 000000000000..2dfcfda1f2b0
--- /dev/null
+++ b/Algorithm.CSharp/OptionChainStrategyFiltersRegressionAlgorithm.cs
@@ -0,0 +1,183 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm demonstrating that the option strategy filters of the universe selection, like
+    /// <see cref="Securities.BaseOptionFilterUniverse{TUniverse, TData}.Straddle"/> or
+    /// <see cref="Securities.BaseOptionFilterUniverse{TUniverse, TData}.IronCondor"/>, select the strategy legs
+    /// straight from an option chain too
+    /// </summary>
+    public class OptionChainStrategyFiltersRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _option;
+        private bool _traded;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+
+            var option = AddOption("GOOG");
+            _option = option.Symbol;
+            // The universe selects the straddle legs, the same filter picks them again from the slice chain below
+            option.SetFilter(universe => universe.Straddle(7));
+
+            var chain = OptionChain(_option);
+            var expiry = new DateTime(2015, 12, 31);
+
+            // GOOG closed at 748.54 on 2015-12-23, the first expiry at least 7 days out is 2015-12-31 and the ATM strike is 747.50
+            var straddle = chain.Straddle(7);
+            AssertLegs(straddle, expiry, (OptionRight.Call, 747.5m), (OptionRight.Put, 747.5m));
+
+            // Iron condor: near legs 5 away from the spot, far legs 10 away
+            var ironCondor = chain.IronCondor(7, 5, 10);
+            AssertLegs(ironCondor, expiry, (OptionRight.Put, 737.5m), (OptionRight.Put, 742.5m), (OptionRight.Call, 752.5m), (OptionRight.Call, 757.5m));
+
+            // Single contract and vertical spread pickers
+            AssertLegs(chain.NakedPut(7, -5), expiry, (OptionRight.Put, 742.5m));
+            AssertLegs(chain.CallSpread(7, 5), expiry, (OptionRight.Call, 742.5m), (OptionRight.Call, 752.5m));
+
+            // Calendar spread: same strike, expiries at least 7 and 14 days out
+            var calendar = chain.CallCalendarSpread(0, 7, 14);
+            if (calendar.Count != 2 || calendar.Any(x => x.Right != OptionRight.Call || x.Strike != 747.5m)
+                || !calendar.Select(x => x.Expiry).OrderBy(x => x).SequenceEqual(new[] { expiry, new DateTime(2016, 1, 8) }))
+            {
+                throw new RegressionTestException($"Unexpected calendar spread legs: {string.Join(", ", calendar.Select(x => x.Symbol.Value))}");
+            }
+
+            // No match selects nothing instead of throwing
+            if (chain.Straddle(1000).Count != 0)
+            {
+                throw new RegressionTestException("Expected no legs for an expiry out of the chain");
+            }
+
+            // Invalid arguments are rejected like the universe filters do
+            try
+            {
+                chain.Strangle(7, -5, 5);
+                throw new RegressionTestException("Expected Strangle() to reject a negative call strike distance");
+            }
+            catch (ArgumentException)
+            {
+            }
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (_traded || !slice.OptionChains.TryGetValue(_option, out var chain))
+            {
+                return;
+            }
+
+            // The same filter that selected the universe picks the legs from the slice chain
+            var legs = chain.Straddle(7);
+            if (legs.Count == 2)
+            {
+                var leg = legs.First();
+                Buy(OptionStrategies.Straddle(_option, leg.Strike, leg.Expiry), 1);
+                _traded = true;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_traded)
+            {
+                throw new RegressionTestException("Expected to trade the straddle selected from the slice option chain");
+            }
+        }
+
+        private static void AssertLegs(OptionChain legs, DateTime expiry, params (OptionRight right, decimal strike)[] expected)
+        {
+            var actual = legs.Select(x => (x.Right, x.Strike)).OrderBy(x => x.Right).ThenBy(x => x.Strike).ToList();
+            if (legs.Any(x => x.Expiry != expiry) || !actual.SequenceEqual(expected.OrderBy(x => x.right).ThenBy(x => x.strike)))
+            {
+                throw new RegressionTestException($"Unexpected legs: {string.Join(", ", legs.Select(x => x.Symbol.Value))}");
+            }
+        }
+
+        /// <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 => 5886;
+
+        /// <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", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "99638"},
+            {"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", "$2.00"},
+            {"Estimated Strategy Capacity", "$23000.00"},
+            {"Lowest Capacity Asset", "GOOCV 305Y7VNVZK3D2|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "1.55%"},
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "0918e55ec2074aaafad98475aa2fcc43"}
+        };
+    }
+}
diff --git a/Algorithm.Python/OptionChainFiltersRegressionAlgorithm.py b/Algorithm.Python/OptionChainFiltersRegressionAlgorithm.py
new file mode 100644
index 000000000000..3452d3235d80
--- /dev/null
+++ b/Algorithm.Python/OptionChainFiltersRegressionAlgorithm.py
@@ -0,0 +1,96 @@
+# 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 demonstrating that option chains can be filtered with the same filters used for
+### option universe selection, both on chains from QCAlgorithm.option_chain() and on the chains delivered in the slice
+### </summary>
+class OptionChainFiltersRegressionAlgorithm(QCAlgorithm):
+
+    def initialize(self):
+        self.set_start_date(2015, 12, 24)
+        self.set_end_date(2015, 12, 24)
+        self.set_cash(100000)
+
+        option = self.add_option("GOOG")
+        self._option = option.symbol
+        # The same words select the universe and, below, narrow down the chains
+        option.set_filter(lambda universe: universe.calls_only().expiration(1, 10).strikes(-2, 2))
+
+        chain = self.option_chain(self._option)
+        if chain.count == 0:
+            raise AssertionError("Expected a non empty option chain")
+        # The relative strikes filter needs the underlying price, chains built from universe data must carry it
+        if chain.underlying.price == 0:
+            raise AssertionError("Expected the chain to carry the underlying price")
+
+        total_contracts = chain.count
+        filtered = chain.calls_only().expiration(1, 10).strikes(-2, 2)
+        # GOOG closed at 748.54 on 2015-12-23 and the only expiration 1 to 10 days out is 2015-12-31,
+        # so the two strikes below the spot and the two at or above it are 745, 747.5, 750 and 752.5
+        self._assert_contracts(filtered, OptionRight.CALL, datetime(2015, 12, 31), [745, 747.5, 750, 752.5])
+        if chain.count != total_contracts:
+            raise AssertionError("Filters must not modify the source chain")
+
+        # Front month is the nearest expiration, 2015-12-24 itself
+        self._assert_contracts(chain.puts_only().front_month(), OptionRight.PUT, datetime(2015, 12, 24))
+
+        # Standard contracts expire on the third Friday, weeklys do not
+        standards = chain.standards_only().front_month()
+        if standards.count == 0 or any(x.expiry != datetime(2016, 1, 15) for x in standards):
+            raise AssertionError("Expected the standard front month to expire on 2016-01-15")
+        weeklys = chain.weeklys_only()
+        if weeklys.count == 0 or any(OptionSymbol.is_standard(x.symbol) for x in weeklys):
+            raise AssertionError("Expected only weekly contracts")
+
+        # Greeks filters use the greeks the chain carries
+        deltas = chain.delta(0.5, 0.6)
+        expected_deltas = sum(1 for x in chain if 0.5 <= x.greeks.delta <= 0.6)
+        if deltas.count == 0 or deltas.count != expected_deltas or any(not 0.5 <= x.greeks.delta <= 0.6 for x in deltas):
+            raise AssertionError("Delta filter mismatch")
+
+        # where() takes a predicate, like the universe filter does
+        high_open_interest = chain.where(lambda x: x.open_interest > 1000)
+        if high_open_interest.count == 0 or high_open_interest.count != sum(1 for x in chain if x.open_interest > 1000):
+            raise AssertionError("where() filter mismatch")
+
+        self._traded = False
+
+    def on_data(self, slice):
+        if self._traded:
+            return
+        chain = slice.option_chains.get(self._option)
+        if not chain:
+            return
+
+        # The universe only selected calls expiring 1 to 10 days out, so the chain filters agree with it
+        if chain.calls_only().expiration(1, 10).count != chain.count or chain.puts_only().count != 0:
+            raise AssertionError("Slice chain filters disagree with the universe filter")
+
+        # Buy the call at the first strike at or above the underlying price
+        contract = next(iter(chain.strikes(0, 0)), None)
+        if contract is not None:
+            self.market_order(contract.symbol, 1)
+            self._traded = True
+
+    def on_end_of_algorithm(self):
+        if not self._traded:
+            raise AssertionError("Expected to trade a contract selected from the slice option chain")
+
+    def _assert_contracts(self, chain, right, expiry, strikes=None):
+        if chain.count == 0 or any(x.right != right or x.expiry != expiry for x in chain):
+            raise AssertionError(f"Expected only {right} contracts expiring on {expiry:%Y-%m-%d}")
+        if strikes is not None and sorted(x.strike for x in chain) != strikes:
+            raise AssertionError(f"Unexpected strikes: {[x.strike for x in chain]}")
diff --git a/Algorithm.Python/OptionChainStrategyFiltersRegressionAlgorithm.py b/Algorithm.Python/OptionChainStrategyFiltersRegressionAlgorithm.py
new file mode 100644
index 000000000000..7521e005ca88
--- /dev/null
+++ b/Algorithm.Python/OptionChainStrategyFiltersRegressionAlgorithm.py
@@ -0,0 +1,86 @@
+# 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 demonstrating that the option strategy filters of the universe selection, like straddle()
+### or iron_condor(), select the strategy legs straight from an option chain too
+### </summary>
+class OptionChainStrategyFiltersRegressionAlgorithm(QCAlgorithm):
+
+    def initialize(self):
+        self.set_start_date(2015, 12, 24)
+        self.set_end_date(2015, 12, 24)
+        self.set_cash(100000)
+
+        option = self.add_option("GOOG")
+        self._option = option.symbol
+        # The universe selects the straddle legs, the same filter picks them again from the slice chain below
+        option.set_filter(lambda universe: universe.straddle(7))
+
+        chain = self.option_chain(self._option)
+        expiry = datetime(2015, 12, 31)
+
+        # GOOG closed at 748.54 on 2015-12-23, the first expiry at least 7 days out is 2015-12-31 and the ATM strike is 747.50
+        self._assert_legs(chain.straddle(7), expiry, [(OptionRight.CALL, 747.5), (OptionRight.PUT, 747.5)])
+
+        # Iron condor: near legs 5 away from the spot, far legs 10 away
+        self._assert_legs(chain.iron_condor(7, 5, 10), expiry,
+            [(OptionRight.CALL, 752.5), (OptionRight.CALL, 757.5), (OptionRight.PUT, 737.5), (OptionRight.PUT, 742.5)])
+
+        # Single contract and vertical spread pickers
+        self._assert_legs(chain.naked_put(7, -5), expiry, [(OptionRight.PUT, 742.5)])
+        self._assert_legs(chain.call_spread(7, 5), expiry, [(OptionRight.CALL, 742.5), (OptionRight.CALL, 752.5)])
+
+        # Calendar spread: same strike, expiries at least 7 and 14 days out
+        calendar = chain.call_calendar_spread(0, 7, 14)
+        if (calendar.count != 2 or any(x.right != OptionRight.CALL or x.strike != 747.5 for x in calendar)
+                or sorted(x.expiry for x in calendar) != [expiry, datetime(2016, 1, 8)]):
+            raise AssertionError(f"Unexpected calendar spread legs: {[x.symbol.value for x in calendar]}")
+
+        # No match selects nothing instead of raising
+        if chain.straddle(1000).count != 0:
+            raise AssertionError("Expected no legs for an expiry out of the chain")
+
+        # Invalid arguments are rejected like the universe filters do
+        try:
+            chain.strangle(7, -5, 5)
+            raise AssertionError("Expected strangle() to reject a negative call strike distance")
+        except ArgumentException:
+            pass
+
+        self._traded = False
+
+    def on_data(self, slice):
+        if self._traded:
+            return
+        chain = slice.option_chains.get(self._option)
+        if not chain:
+            return
+
+        # The same filter that selected the universe picks the legs from the slice chain
+        legs = chain.straddle(7)
+        if legs.count == 2:
+            leg = next(iter(legs))
+            self.buy(OptionStrategies.straddle(self._option, leg.strike, leg.expiry), 1)
+            self._traded = True
+
+    def on_end_of_algorithm(self):
+        if not self._traded:
+            raise AssertionError("Expected to trade the straddle selected from the slice option chain")
+
+    def _assert_legs(self, legs, expiry, expected):
+        actual = sorted((x.right, x.strike) for x in legs)
+        if any(x.expiry != expiry for x in legs) or actual != sorted(expected):
+            raise AssertionError(f"Unexpected legs: {[x.symbol.value for x in legs]}")
diff --git a/Common/Data/Market/BaseChain.cs b/Common/Data/Market/BaseChain.cs
index 1341d16f51a8..c199926efce1 100644
--- a/Common/Data/Market/BaseChain.cs
+++ b/Common/Data/Market/BaseChain.cs
@@ -35,6 +35,7 @@ public class BaseChain<T, TContractsCollection> : BaseData, IEnumerable<T>
         private Dictionary<Type, Dictionary<Symbol, List<BaseData>>> _auxiliaryData;
         private readonly Lazy<PyObject> _dataframe;
         private readonly bool _flatten;
+        private DateTime? _exchangeTime;
 
         private Dictionary<Type, Dictionary<Symbol, List<BaseData>>> AuxiliaryData
         {
@@ -59,6 +60,16 @@ public BaseData Underlying
             get; internal set;
         }
 
+        /// <summary>
+        /// The chain time in the exchange time zone, the reference date for the contract filters. Slice chains carry
+        /// their data's end time, chains built from universe data default to <see cref="BaseData.Time"/>
+        /// </summary>
+        internal DateTime ExchangeTime
+        {
+            get => _exchangeTime ?? Time;
+            set => _exchangeTime = value;
+        }
+
         /// <summary>
         /// Gets all ticks for every option contract in this chain, keyed by option symbol
         /// </summary>
@@ -171,6 +182,7 @@ protected BaseChain(BaseChain<T, TContractsCollection> other)
         {
             Symbol = other.Symbol;
             Time = other.Time;
+            _exchangeTime = other._exchangeTime;
             Value = other.Value;
             Underlying = other.Underlying;
             Ticks = other.Ticks;
@@ -178,6 +190,24 @@ protected BaseChain(BaseChain<T, TContractsCollection> other)
             TradeBars = other.TradeBars;
             Contracts = other.Contracts;
             FilteredContracts = other.FilteredContracts;
+            _auxiliaryData = other._auxiliaryData;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseChain{T, TContractsCollection}"/> class as a copy of the specified chain
+        /// containing only the given subset of its contracts. The underlying, ticks, trade bars, quote bars and auxiliary data are shared with the source chain
+        /// </summary>
+        /// <param name="other">The chain to copy</param>
+        /// <param name="contracts">The contracts to keep</param>
+        protected BaseChain(BaseChain<T, TContractsCollection> other, IEnumerable<T> contracts)
+            : this(other)
+        {
+            Contracts = new();
+            Contracts.Time = other.Contracts.Time;
+            foreach (var contract in contracts)
+            {
+                Contracts[contract.Symbol] = contract;
+            }
         }
 
         /// <summary>
diff --git a/Common/Data/Market/OptionChain.Filters.cs b/Common/Data/Market/OptionChain.Filters.cs
new file mode 100644
index 000000000000..3fdaac86b4ac
--- /dev/null
+++ b/Common/Data/Market/OptionChain.Filters.cs
@@ -0,0 +1,527 @@
+/*
+ * 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 Python.Runtime;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Data.Market
+{
+    /// <summary>
+    /// The option chain filters, the same ones the option universe selection offers, see <see cref="IOptionContractFilters{TSelf}"/>.
+    /// Each filter returns a new chain, leaving this one untouched
+    /// </summary>
+    public partial class OptionChain
+    {
+        #region Filters
+
+        /// <summary>
+        /// Selects the contracts with strikes in the given range relative to the underlying price, in number of strikes.
+        /// Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Strikes"/>
+        /// </summary>
+        /// <param name="minStrike">The minimum strike relative to the underlying price, for example, -1 would filter out contracts further than 1 strike below market price</param>
+        /// <param name="maxStrike">The maximum strike relative to the underlying price, for example, +1 would filter out contracts further than 1 strike above market price</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Strikes(int minStrike, int maxStrike)
+        {
+            return Filter(universe => universe.Strikes(minStrike, maxStrike));
+        }
+
+        /// <summary>
+        /// Selects the contracts expiring in the given range relative to the chain date.
+        /// Same as <see cref="ContractSecurityFilterUniverse{T, TData}.Expiration(TimeSpan, TimeSpan)"/>
+        /// </summary>
+        /// <param name="minExpiry">The minimum time until expiry to include, for example, TimeSpan.FromDays(10)
+        /// would exclude contracts expiring in less than 10 days</param>
+        /// <param name="maxExpiry">The maximum time until expiry to include, for example, TimeSpan.FromDays(10)
+        /// would exclude contracts expiring in more than 10 days</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Expiration(TimeSpan minExpiry, TimeSpan maxExpiry)
+        {
+            return Filter(universe => universe.Expiration(minExpiry, maxExpiry));
+        }
+
+        /// <summary>
+        /// Selects the contracts expiring in the given range of days relative to the chain date.
+        /// Same as <see cref="ContractSecurityFilterUniverse{T, TData}.Expiration(int, int)"/>
+        /// </summary>
+        /// <param name="minExpiryDays">The minimum time, expressed in days, until expiry to include, for example, 10
+        /// would exclude contracts expiring in less than 10 days</param>
+        /// <param name="maxExpiryDays">The maximum time, expressed in days, until expiry to include, for example, 10
+        /// would exclude contracts expiring in more than 10 days</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Expiration(int minExpiryDays, int maxExpiryDays)
+        {
+            return Filter(universe => universe.Expiration(minExpiryDays, maxExpiryDays));
+        }
+
+        /// <summary>
+        /// Selects the call contracts. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.CallsOnly"/>
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain CallsOnly()
+        {
+            return Filter(universe => universe.CallsOnly());
+        }
+
+        /// <summary>
+        /// Selects the put contracts. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.PutsOnly"/>
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain PutsOnly()
+        {
+            return Filter(universe => universe.PutsOnly());
+        }
+
+        /// <summary>
+        /// Selects the standard contracts in the chain, excluding weeklys. Unlike <see cref="ContractSecurityFilterUniverse{T, TData}.StandardsOnly"/>,
+        /// it applies to the contracts already selected, so it can be combined with the expiry filters in any order
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain StandardsOnly()
+        {
+            return Filter(universe => universe.StandardsOnly());
+        }
+
+        /// <summary>
+        /// Selects the non standard weekly contracts in the chain. Unlike <see cref="ContractSecurityFilterUniverse{T, TData}.WeeklysOnly"/>,
+        /// it applies to the contracts already selected, so it can be combined with the expiry filters in any order
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain WeeklysOnly()
+        {
+            return Filter(universe => universe.WeeklysOnly());
+        }
+
+        /// <summary>
+        /// Selects the contracts of the nearest expiration. Same as <see cref="ContractSecurityFilterUniverse{T, TData}.FrontMonth"/>
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain FrontMonth()
+        {
+            return Filter(universe => universe.FrontMonth());
+        }
+
+        /// <summary>
+        /// Selects the contracts of all expirations but the nearest one. Same as <see cref="ContractSecurityFilterUniverse{T, TData}.BackMonths"/>
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain BackMonths()
+        {
+            return Filter(universe => universe.BackMonths());
+        }
+
+        /// <summary>
+        /// Selects the contracts of the second nearest expiration. Same as <see cref="ContractSecurityFilterUniverse{T, TData}.BackMonth"/>
+        /// </summary>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain BackMonth()
+        {
+            return Filter(universe => universe.BackMonth());
+        }
+
+        /// <summary>
+        /// Selects the contracts with delta in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Delta"/>
+        /// </summary>
+        /// <param name="min">The minimum delta value</param>
+        /// <param name="max">The maximum delta value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Delta(decimal min, decimal max)
+        {
+            return Filter(universe => universe.Delta(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with delta in the given range. Alias for <see cref="Delta"/>
+        /// </summary>
+        /// <param name="min">The minimum delta value</param>
+        /// <param name="max">The maximum delta value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain D(decimal min, decimal max)
+        {
+            return Delta(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts with gamma in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Gamma"/>
+        /// </summary>
+        /// <param name="min">The minimum gamma value</param>
+        /// <param name="max">The maximum gamma value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Gamma(decimal min, decimal max)
+        {
+            return Filter(universe => universe.Gamma(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with gamma in the given range. Alias for <see cref="Gamma"/>
+        /// </summary>
+        /// <param name="min">The minimum gamma value</param>
+        /// <param name="max">The maximum gamma value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain G(decimal min, decimal max)
+        {
+            return Gamma(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts with theta in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Theta"/>
+        /// </summary>
+        /// <param name="min">The minimum theta value</param>
+        /// <param name="max">The maximum theta value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Theta(decimal min, decimal max)
+        {
+            return Filter(universe => universe.Theta(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with theta in the given range. Alias for <see cref="Theta"/>
+        /// </summary>
+        /// <param name="min">The minimum theta value</param>
+        /// <param name="max">The maximum theta value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain T(decimal min, decimal max)
+        {
+            return Theta(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts with vega in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Vega"/>
+        /// </summary>
+        /// <param name="min">The minimum vega value</param>
+        /// <param name="max">The maximum vega value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Vega(decimal min, decimal max)
+        {
+            return Filter(universe => universe.Vega(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with vega in the given range. Alias for <see cref="Vega"/>
+        /// </summary>
+        /// <param name="min">The minimum vega value</param>
+        /// <param name="max">The maximum vega value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain V(decimal min, decimal max)
+        {
+            return Vega(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts with rho in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Rho"/>
+        /// </summary>
+        /// <param name="min">The minimum rho value</param>
+        /// <param name="max">The maximum rho value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Rho(decimal min, decimal max)
+        {
+            return Filter(universe => universe.Rho(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with rho in the given range. Alias for <see cref="Rho"/>
+        /// </summary>
+        /// <param name="min">The minimum rho value</param>
+        /// <param name="max">The maximum rho value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain R(decimal min, decimal max)
+        {
+            return Rho(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts with implied volatility in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.ImpliedVolatility"/>
+        /// </summary>
+        /// <param name="min">The minimum implied volatility value</param>
+        /// <param name="max">The maximum implied volatility value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain ImpliedVolatility(decimal min, decimal max)
+        {
+            return Filter(universe => universe.ImpliedVolatility(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with implied volatility in the given range. Alias for <see cref="ImpliedVolatility"/>
+        /// </summary>
+        /// <param name="min">The minimum implied volatility value</param>
+        /// <param name="max">The maximum implied volatility value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain IV(decimal min, decimal max)
+        {
+            return ImpliedVolatility(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts with open interest in the given range. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.OpenInterest"/>
+        /// </summary>
+        /// <param name="min">The minimum open interest value</param>
+        /// <param name="max">The maximum open interest value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain OpenInterest(long min, long max)
+        {
+            return Filter(universe => universe.OpenInterest(min, max));
+        }
+
+        /// <summary>
+        /// Selects the contracts with open interest in the given range. Alias for <see cref="OpenInterest"/>
+        /// </summary>
+        /// <param name="min">The minimum open interest value</param>
+        /// <param name="max">The maximum open interest value</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain OI(long min, long max)
+        {
+            return OpenInterest(min, max);
+        }
+
+        /// <summary>
+        /// Selects the contracts matching the given predicate, e.g. <c>chain.where(lambda contract: contract.open_interest > 100)</c>.
+        /// From C# use Linq's Where, which keeps this chain's type untouched
+        /// </summary>
+        /// <param name="predicate">Function determining which contracts are kept</param>
+        /// <returns>A new chain with the filter applied</returns>
+        public OptionChain Where(PyObject predicate)
+        {
+            return new OptionChain(this, Contracts.Values.Where(predicate.SafeAs<Func<OptionContract, bool>>()));
+        }
+
+        #endregion
+
+        #region Strategy filters
+
+        /// <summary>
+        /// Selects the single call contract with the closest match to the criteria given, for a naked, covered or protective call. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.NakedCall"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeFromAtm">The desired strike price distance from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain NakedCall(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
+        {
+            return Filter(universe => universe.NakedCall(minDaysTillExpiry, strikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects the single put contract with the closest match to the criteria given, for a naked, covered or protective put. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.NakedPut"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeFromAtm">The desired strike price distance from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain NakedPut(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
+        {
+            return Filter(universe => universe.NakedPut(minDaysTillExpiry, strikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects the 2 call contracts with the same expiry and different strikes closest to the criteria given, for a bull or bear call spread. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.CallSpread"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="higherStrikeFromAtm">The desired strike price distance from the current underlying price of the higher strike price</param>
+        /// <param name="lowerStrikeFromAtm">The desired strike price distance from the current underlying price of the lower strike price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain CallSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null)
+        {
+            return Filter(universe => universe.CallSpread(minDaysTillExpiry, higherStrikeFromAtm, lowerStrikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects the 2 put contracts with the same expiry and different strikes closest to the criteria given, for a bull or bear put spread. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.PutSpread"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="higherStrikeFromAtm">The desired strike price distance from the current underlying price of the higher strike price</param>
+        /// <param name="lowerStrikeFromAtm">The desired strike price distance from the current underlying price of the lower strike price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain PutSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null)
+        {
+            return Filter(universe => universe.PutSpread(minDaysTillExpiry, higherStrikeFromAtm, lowerStrikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects the 2 call contracts with the same strike and different expiries closest to the criteria given, for a call calendar spread. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.CallCalendarSpread"/>
+        /// </summary>
+        /// <param name="strikeFromAtm">The desired strike price distance from the current underlying price</param>
+        /// <param name="minNearDaysTillExpiry">The minimum days till expiry of the closer contract from the current time, closest expiry will be selected</param>
+        /// <param name="minFarDaysTillExpiry">The minimum days till expiry of the further contract from the current time, closest expiry will be selected</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain CallCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
+        {
+            return Filter(universe => universe.CallCalendarSpread(strikeFromAtm, minNearDaysTillExpiry, minFarDaysTillExpiry));
+        }
+
+        /// <summary>
+        /// Selects the 2 put contracts with the same strike and different expiries closest to the criteria given, for a put calendar spread. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.PutCalendarSpread"/>
+        /// </summary>
+        /// <param name="strikeFromAtm">The desired strike price distance from the current underlying price</param>
+        /// <param name="minNearDaysTillExpiry">The minimum days till expiry of the closer contract from the current time, closest expiry will be selected</param>
+        /// <param name="minFarDaysTillExpiry">The minimum days till expiry of the further contract from the current time, closest expiry will be selected</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain PutCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
+        {
+            return Filter(universe => universe.PutCalendarSpread(strikeFromAtm, minNearDaysTillExpiry, minFarDaysTillExpiry));
+        }
+
+        /// <summary>
+        /// Selects an OTM call and an OTM put with the same expiry closest to the criteria given, for a strangle. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Strangle"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="callStrikeFromAtm">The desired strike price distance from the current underlying price of the OTM call, must be positive</param>
+        /// <param name="putStrikeFromAtm">The desired strike price distance from the current underlying price of the OTM put, must be negative</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain Strangle(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5)
+        {
+            return Filter(universe => universe.Strangle(minDaysTillExpiry, callStrikeFromAtm, putStrikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects the ATM call and the ATM put with the same expiry closest to the criteria given, for a straddle. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Straddle"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain Straddle(int minDaysTillExpiry = 30)
+        {
+            return Filter(universe => universe.Straddle(minDaysTillExpiry));
+        }
+
+        /// <summary>
+        /// Selects a call and a put with the same expiry and a lower put strike closest to the criteria given, for a protective collar. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.ProtectiveCollar"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="callStrikeFromAtm">The desired strike price distance from the current underlying price of the call</param>
+        /// <param name="putStrikeFromAtm">The desired strike price distance from the current underlying price of the put</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain ProtectiveCollar(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5)
+        {
+            return Filter(universe => universe.ProtectiveCollar(minDaysTillExpiry, callStrikeFromAtm, putStrikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects a call and a put with the same expiry and strike closest to the criteria given, for a conversion or reverse conversion. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.Conversion"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeFromAtm">The desired strike price distance from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain Conversion(int minDaysTillExpiry = 30, decimal strikeFromAtm = 5)
+        {
+            return Filter(universe => universe.Conversion(minDaysTillExpiry, strikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects an ITM, an ATM and an OTM call with the same expiry and equal strike distance closest to the criteria given, for a call butterfly. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.CallButterfly"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeSpread">The desired strike price distance of the ITM and OTM calls from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain CallButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        {
+            return Filter(universe => universe.CallButterfly(minDaysTillExpiry, strikeSpread));
+        }
+
+        /// <summary>
+        /// Selects an ITM, an ATM and an OTM put with the same expiry and equal strike distance closest to the criteria given, for a put butterfly. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.PutButterfly"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeSpread">The desired strike price distance of the ITM and OTM puts from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain PutButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        {
+            return Filter(universe => universe.PutButterfly(minDaysTillExpiry, strikeSpread));
+        }
+
+        /// <summary>
+        /// Selects an OTM call, an ATM call, an ATM put and an OTM put with the same expiry and equal strike distance closest to the criteria given, for an iron butterfly. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.IronButterfly"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeSpread">The desired strike price distance of the OTM call and the OTM put from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain IronButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        {
+            return Filter(universe => universe.IronButterfly(minDaysTillExpiry, strikeSpread));
+        }
+
+        /// <summary>
+        /// Selects a far OTM call, a near OTM call, a near OTM put and a far OTM put with the same expiry closest to the criteria given, for an iron condor. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.IronCondor"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="nearStrikeSpread">The desired strike price distance of the near call and near put from the current underlying price</param>
+        /// <param name="farStrikeSpread">The desired strike price distance of the far call and far put from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain IronCondor(int minDaysTillExpiry = 30, decimal nearStrikeSpread = 5, decimal farStrikeSpread = 10)
+        {
+            return Filter(universe => universe.IronCondor(minDaysTillExpiry, nearStrikeSpread, farStrikeSpread));
+        }
+
+        /// <summary>
+        /// Selects an OTM call, an ITM call, an OTM put and an ITM put with the same expiry closest to the criteria given, for a box spread. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.BoxSpread"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="strikeSpread">The desired strike price distance of the OTM call and the OTM put from the current underlying price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain BoxSpread(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        {
+            return Filter(universe => universe.BoxSpread(minDaysTillExpiry, strikeSpread));
+        }
+
+        /// <summary>
+        /// Selects 2 calls and 2 puts with the same strike and 2 expiries closest to the criteria given, for a jelly roll. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.JellyRoll"/>
+        /// </summary>
+        /// <param name="strikeFromAtm">The desired strike price distance from the current underlying price</param>
+        /// <param name="minNearDaysTillExpiry">The minimum days till expiry of the closer contract from the current time, closest expiry will be selected</param>
+        /// <param name="minFarDaysTillExpiry">The minimum days till expiry of the further contract from the current time, closest expiry will be selected</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain JellyRoll(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
+        {
+            return Filter(universe => universe.JellyRoll(strikeFromAtm, minNearDaysTillExpiry, minFarDaysTillExpiry));
+        }
+
+        /// <summary>
+        /// Selects 3 calls with the same expiry and different strikes closest to the criteria given, for a bull or bear call ladder. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.CallLadder"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="higherStrikeFromAtm">The desired strike price distance from the current underlying price of the higher strike price</param>
+        /// <param name="middleStrikeFromAtm">The desired strike price distance from the current underlying price of the middle strike price</param>
+        /// <param name="lowerStrikeFromAtm">The desired strike price distance from the current underlying price of the lower strike price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain CallLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
+        {
+            return Filter(universe => universe.CallLadder(minDaysTillExpiry, higherStrikeFromAtm, middleStrikeFromAtm, lowerStrikeFromAtm));
+        }
+
+        /// <summary>
+        /// Selects 3 puts with the same expiry and different strikes closest to the criteria given, for a bull or bear put ladder. Same as <see cref="BaseOptionFilterUniverse{TUniverse, TData}.PutLadder"/>
+        /// </summary>
+        /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
+        /// <param name="higherStrikeFromAtm">The desired strike price distance from the current underlying price of the higher strike price</param>
+        /// <param name="middleStrikeFromAtm">The desired strike price distance from the current underlying price of the middle strike price</param>
+        /// <param name="lowerStrikeFromAtm">The desired strike price distance from the current underlying price of the lower strike price</param>
+        /// <returns>A new chain with the selected contracts, empty if there is no match</returns>
+        public OptionChain PutLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
+        {
+            return Filter(universe => universe.PutLadder(minDaysTillExpiry, higherStrikeFromAtm, middleStrikeFromAtm, lowerStrikeFromAtm));
+        }
+
+        /// <summary>
+        /// Applies the given universe filter to the contracts of this chain and returns the result as a new chain
+        /// </summary>
+        /// <param name="filter">The universe filter to apply</param>
+        private OptionChain Filter(Func<OptionChainFilterUniverse, OptionChainFilterUniverse> filter)
+        {
+            var universe = new OptionChainFilterUniverse(this);
+            // the type filters (standards/weeklys) are only applied on demand, like the universe selection does after the user filter
+            return new OptionChain(this, filter(universe).ApplyTypesFilter());
+        }
+
+        #endregion
+    }
+}
diff --git a/Common/Data/Market/OptionChain.cs b/Common/Data/Market/OptionChain.cs
index 562cd18e0a0f..20c1ec0a7126 100644
--- a/Common/Data/Market/OptionChain.cs
+++ b/Common/Data/Market/OptionChain.cs
@@ -22,9 +22,12 @@ namespace QuantConnect.Data.Market
 {
     /// <summary>
     /// Represents an entire chain of option contracts for a single underlying security.
-    /// This type is <see cref="IEnumerable{OptionContract}"/>
+    /// This type is <see cref="IEnumerable{OptionContract}"/>.
+    /// The chain can be narrowed down with the same filters available for option universe selection
+    /// (see <see cref="IOptionContractFilters{TSelf}"/> and <see cref="OptionFilterUniverse"/>), e.g. <c>chain.calls_only().expiration(0, 30).strikes(-2, 2)</c>.
+    /// Each filter returns a new chain, leaving this one untouched.
     /// </summary>
-    public class OptionChain : BaseChain<OptionContract, OptionContracts>
+    public partial class OptionChain : BaseChain<OptionContract, OptionContracts>, IOptionContractFilters<OptionChain>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="OptionChain"/> class
@@ -49,9 +52,15 @@ public OptionChain(Symbol canonicalOptionSymbol, DateTime time, IEnumerable<Opti
             bool flatten = true)
             : this(canonicalOptionSymbol, time, flatten)
         {
+            var underlyingSet = false;
             foreach (var contractData in contracts)
             {
-                Underlying ??= contractData.Underlying;
+                // The base constructor pre-sets an empty underlying, so it is replaced by the first actual underlying data found
+                if (!underlyingSet && contractData.Underlying != null)
+                {
+                    Underlying = contractData.Underlying;
+                    underlyingSet = true;
+                }
                 if (contractData.Symbol.ID.Date.Date < time.Date) continue;
                 Contracts[contractData.Symbol] = OptionContract.Create(contractData, symbolProperties);
             }
@@ -65,6 +74,15 @@ private OptionChain(OptionChain other)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OptionChain"/> class as a copy of the specified chain
+        /// containing only the given subset of its contracts
+        /// </summary>
+        private OptionChain(OptionChain other, IEnumerable<OptionContract> contracts)
+            : base(other, contracts)
+        {
+        }
+
         /// <summary>
         /// Return a new instance clone of this object, used in fill forward
         /// </summary>
diff --git a/Common/Data/Market/OptionContract.cs b/Common/Data/Market/OptionContract.cs
index 3d44ec15f2c9..4006c4c573aa 100644
--- a/Common/Data/Market/OptionContract.cs
+++ b/Common/Data/Market/OptionContract.cs
@@ -104,6 +104,11 @@ public class OptionContract : BaseContract
         /// </summary>
         public decimal UnderlyingLastPrice => _optionData.UnderlyingLastPrice;
 
+        /// <summary>
+        /// The option symbol properties
+        /// </summary>
+        internal SymbolProperties SymbolProperties => _symbolProperties;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="OptionContract"/> class
         /// </summary>
diff --git a/Common/Securities/ContractSecurityFilterUniverse.cs b/Common/Securities/ContractSecurityFilterUniverse.cs
index 7a317eeb4a90..ec1be57ef2f4 100644
--- a/Common/Securities/ContractSecurityFilterUniverse.cs
+++ b/Common/Securities/ContractSecurityFilterUniverse.cs
@@ -19,6 +19,7 @@
 using Python.Runtime;
 using System.Collections;
 using System.Collections.Generic;
+using QuantConnect.Data;
 
 namespace QuantConnect.Securities
 {
@@ -28,7 +29,7 @@ namespace QuantConnect.Securities
     /// </summary>
     public abstract class ContractSecurityFilterUniverse<T, TData> : IDerivativeSecurityFilterUniverse<TData>
         where T : ContractSecurityFilterUniverse<T, TData>
-        where TData : IChainUniverseData
+        where TData : ISymbolProvider
     {
         private bool _alreadyAppliedTypeFilters;
 
@@ -153,12 +154,19 @@ internal T ApplyTypesFilter()
                 return (T)this;
             }
 
+            // Every contract passes by default, so skip the pass and only pin the ordering rule for StandardsOnly()
+            if (Type == DefaultExpirationType)
+            {
+                _alreadyAppliedTypeFilters = true;
+                return (T)this;
+            }
+
             // memoization map for ApplyTypesFilter()
             var memoizedMap = new Dictionary<DateTime, bool>();
 
             Func<TData, bool> memoizedIsStandardType = data =>
             {
-                var dt = data.ID.Date;
+                var dt = data.Symbol.ID.Date;
 
                 bool result;
                 if (memoizedMap.TryGetValue(dt, out result))
@@ -252,9 +260,9 @@ public T WeeklysOnly()
         public virtual T FrontMonth()
         {
             ApplyTypesFilter();
-            var ordered = Data.OrderBy(x => x.ID.Date).ToList();
+            var ordered = Data.OrderBy(x => x.Symbol.ID.Date).ToList();
             if (ordered.Count == 0) return (T)this;
-            var frontMonth = ordered.TakeWhile(x => ordered[0].ID.Date == x.ID.Date);
+            var frontMonth = ordered.TakeWhile(x => ordered[0].Symbol.ID.Date == x.Symbol.ID.Date);
 
             Data = frontMonth.ToList();
             return (T)this;
@@ -267,9 +275,9 @@ public virtual T FrontMonth()
         public virtual T BackMonths()
         {
             ApplyTypesFilter();
-            var ordered = Data.OrderBy(x => x.ID.Date).ToList();
+            var ordered = Data.OrderBy(x => x.Symbol.ID.Date).ToList();
             if (ordered.Count == 0) return (T)this;
-            var backMonths = ordered.SkipWhile(x => ordered[0].ID.Date == x.ID.Date);
+            var backMonths = ordered.SkipWhile(x => ordered[0].Symbol.ID.Date == x.Symbol.ID.Date);
 
             Data = backMonths.ToList();
             return (T)this;
@@ -317,7 +325,7 @@ public virtual T Expiration(TimeSpan minExpiry, TimeSpan maxExpiry)
             var maxExpiryToDate = referenceDate + maxExpiry;
 
             Data = Data
-                .Where(symbol => symbol.ID.Date.Date >= minExpiryToDate && symbol.ID.Date.Date <= maxExpiryToDate)
+                .Where(data => data.Symbol.ID.Date.Date >= minExpiryToDate && data.Symbol.ID.Date.Date <= maxExpiryToDate)
                 .ToList();
 
             return (T)this;
diff --git a/Common/Securities/IDerivativeSecurityFilterUniverse.cs b/Common/Securities/IDerivativeSecurityFilterUniverse.cs
index a3a61cddfce7..32f28d178d14 100644
--- a/Common/Securities/IDerivativeSecurityFilterUniverse.cs
+++ b/Common/Securities/IDerivativeSecurityFilterUniverse.cs
@@ -15,6 +15,7 @@
 */
 
 using System.Collections.Generic;
+using QuantConnect.Data;
 
 namespace QuantConnect.Securities
 {
@@ -22,7 +23,7 @@ namespace QuantConnect.Securities
     /// Represents derivative symbols universe used in filtering.
     /// </summary>
     public interface IDerivativeSecurityFilterUniverse<T> : IEnumerable<T>
-        where T : IChainUniverseData
+        where T : ISymbolProvider
     {
         /// <summary>
         /// The number of contracts in the universe
diff --git a/Common/Securities/Option/IOptionContractFilters.cs b/Common/Securities/Option/IOptionContractFilters.cs
new file mode 100644
index 000000000000..095601441bc1
--- /dev/null
+++ b/Common/Securities/Option/IOptionContractFilters.cs
@@ -0,0 +1,238 @@
+/*
+ * 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;
+
+namespace QuantConnect.Securities
+{
+    /// <summary>
+    /// The option contract filters shared by the option universe selection (<see cref="OptionFilterUniverse"/>)
+    /// and the option chain (<see cref="Data.Market.OptionChain"/>), so both offer the same filters with the same semantics.
+    /// <c>OptionChainTests.ChainExposesEveryUniverseFilter</c> checks that every universe filter is declared here
+    /// </summary>
+    /// <typeparam name="TSelf">The implementing type, returned by every filter for chaining</typeparam>
+    public interface IOptionContractFilters<TSelf>
+    {
+        /// <summary>
+        /// Selects the contracts with strikes in the given range relative to the underlying price, in number of strikes
+        /// </summary>
+        TSelf Strikes(int minStrike, int maxStrike);
+
+        /// <summary>
+        /// Selects the contracts expiring in the given range relative to the current date
+        /// </summary>
+        TSelf Expiration(TimeSpan minExpiry, TimeSpan maxExpiry);
+
+        /// <summary>
+        /// Selects the contracts expiring in the given range of days relative to the current date
+        /// </summary>
+        TSelf Expiration(int minExpiryDays, int maxExpiryDays);
+
+        /// <summary>
+        /// Selects the call contracts
+        /// </summary>
+        TSelf CallsOnly();
+
+        /// <summary>
+        /// Selects the put contracts
+        /// </summary>
+        TSelf PutsOnly();
+
+        /// <summary>
+        /// Selects the standard contracts, excluding weeklys
+        /// </summary>
+        TSelf StandardsOnly();
+
+        /// <summary>
+        /// Selects the non standard weekly contracts
+        /// </summary>
+        TSelf WeeklysOnly();
+
+        /// <summary>
+        /// Selects the contracts of the nearest expiration
+        /// </summary>
+        TSelf FrontMonth();
+
+        /// <summary>
+        /// Selects the contracts of all expirations but the nearest one
+        /// </summary>
+        TSelf BackMonths();
+
+        /// <summary>
+        /// Selects the contracts of the second nearest expiration
+        /// </summary>
+        TSelf BackMonth();
+
+        /// <summary>
+        /// Selects the contracts with delta in the given range
+        /// </summary>
+        TSelf Delta(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with delta in the given range. Alias for <see cref="Delta"/>
+        /// </summary>
+        TSelf D(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with gamma in the given range
+        /// </summary>
+        TSelf Gamma(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with gamma in the given range. Alias for <see cref="Gamma"/>
+        /// </summary>
+        TSelf G(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with theta in the given range
+        /// </summary>
+        TSelf Theta(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with theta in the given range. Alias for <see cref="Theta"/>
+        /// </summary>
+        TSelf T(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with vega in the given range
+        /// </summary>
+        TSelf Vega(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with vega in the given range. Alias for <see cref="Vega"/>
+        /// </summary>
+        TSelf V(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with rho in the given range
+        /// </summary>
+        TSelf Rho(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with rho in the given range. Alias for <see cref="Rho"/>
+        /// </summary>
+        TSelf R(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with implied volatility in the given range
+        /// </summary>
+        TSelf ImpliedVolatility(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with implied volatility in the given range. Alias for <see cref="ImpliedVolatility"/>
+        /// </summary>
+        TSelf IV(decimal min, decimal max);
+
+        /// <summary>
+        /// Selects the contracts with open interest in the given range
+        /// </summary>
+        TSelf OpenInterest(long min, long max);
+
+        /// <summary>
+        /// Selects the contracts with open interest in the given range. Alias for <see cref="OpenInterest"/>
+        /// </summary>
+        TSelf OI(long min, long max);
+
+        /// <summary>
+        /// Selects the single call contract with the closest match to the criteria given
+        /// </summary>
+        TSelf NakedCall(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0);
+
+        /// <summary>
+        /// Selects the single put contract with the closest match to the criteria given
+        /// </summary>
+        TSelf NakedPut(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0);
+
+        /// <summary>
+        /// Selects the 2 call contracts with the same expiry and different strikes closest to the criteria given
+        /// </summary>
+        TSelf CallSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null);
+
+        /// <summary>
+        /// Selects the 2 put contracts with the same expiry and different strikes closest to the criteria given
+        /// </summary>
+        TSelf PutSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null);
+
+        /// <summary>
+        /// Selects the 2 call contracts with the same strike and different expiries closest to the criteria given
+        /// </summary>
+        TSelf CallCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60);
+
+        /// <summary>
+        /// Selects the 2 put contracts with the same strike and different expiries closest to the criteria given
+        /// </summary>
+        TSelf PutCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60);
+
+        /// <summary>
+        /// Selects an OTM call and an OTM put with the same expiry closest to the criteria given
+        /// </summary>
+        TSelf Strangle(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5);
+
+        /// <summary>
+        /// Selects the ATM call and the ATM put with the same expiry closest to the criteria given
+        /// </summary>
+        TSelf Straddle(int minDaysTillExpiry = 30);
+
+        /// <summary>
+        /// Selects a call and a put with the same expiry and a lower put strike closest to the criteria given
+        /// </summary>
+        TSelf ProtectiveCollar(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5);
+
+        /// <summary>
+        /// Selects a call and a put with the same expiry and strike closest to the criteria given
+        /// </summary>
+        TSelf Conversion(int minDaysTillExpiry = 30, decimal strikeFromAtm = 5);
+
+        /// <summary>
+        /// Selects an ITM, an ATM and an OTM call with the same expiry and equal strike distance closest to the criteria given
+        /// </summary>
+        TSelf CallButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5);
+
+        /// <summary>
+        /// Selects an ITM, an ATM and an OTM put with the same expiry and equal strike distance closest to the criteria given
+        /// </summary>
+        TSelf PutButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5);
+
+        /// <summary>
+        /// Selects an OTM call, an ATM call, an ATM put and an OTM put with the same expiry and equal strike distance closest to the criteria given
+        /// </summary>
+        TSelf IronButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5);
+
+        /// <summary>
+        /// Selects a far OTM call, a near OTM call, a near OTM put and a far OTM put with the same expiry closest to the criteria given
+        /// </summary>
+        TSelf IronCondor(int minDaysTillExpiry = 30, decimal nearStrikeSpread = 5, decimal farStrikeSpread = 10);
+
+        /// <summary>
+        /// Selects an OTM call, an ITM call, an OTM put and an ITM put with the same expiry closest to the criteria given
+        /// </summary>
+        TSelf BoxSpread(int minDaysTillExpiry = 30, decimal strikeSpread = 5);
+
+        /// <summary>
+        /// Selects 2 calls and 2 puts with the same strike and 2 expiries closest to the criteria given
+        /// </summary>
+        TSelf JellyRoll(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60);
+
+        /// <summary>
+        /// Selects 3 calls with the same expiry and different strikes closest to the criteria given
+        /// </summary>
+        TSelf CallLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm);
+
+        /// <summary>
+        /// Selects 3 puts with the same expiry and different strikes closest to the criteria given
+        /// </summary>
+        TSelf PutLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm);
+    }
+}
diff --git a/Common/Securities/Option/OptionChainFilterUniverse.cs b/Common/Securities/Option/OptionChainFilterUniverse.cs
new file mode 100644
index 000000000000..37d68d575813
--- /dev/null
+++ b/Common/Securities/Option/OptionChainFilterUniverse.cs
@@ -0,0 +1,95 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+
+namespace QuantConnect.Securities
+{
+    /// <summary>
+    /// Option contracts filter over the contracts of an <see cref="OptionChain"/>, so chains offer
+    /// the same filters as the option universe selection (<see cref="OptionFilterUniverse"/>)
+    /// </summary>
+    internal class OptionChainFilterUniverse : BaseOptionFilterUniverse<OptionChainFilterUniverse, OptionContract>
+    {
+        private readonly Symbol _symbol;
+        private SecurityExchangeHours _exchangeHours;
+
+        /// <summary>
+        /// The option exchange hours
+        /// </summary>
+        protected override SecurityExchangeHours ExchangeHours =>
+            _exchangeHours ??= MarketHoursDatabase.FromDataFolder().GetExchangeHours(_symbol.ID.Market, _symbol, _symbol.SecurityType);
+
+        /// <summary>
+        /// The option security type
+        /// </summary>
+        protected override SecurityType SecurityType => _symbol.SecurityType;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OptionChainFilterUniverse"/> class over the contracts of the given chain
+        /// </summary>
+        /// <param name="chain">The option chain to filter</param>
+        public OptionChainFilterUniverse(OptionChain chain)
+            : base(GetContracts(chain), GetUnderlying(chain), chain.ExchangeTime, GetStrikeMultiplier(chain))
+        {
+            _symbol = chain.Symbol;
+        }
+
+        /// <summary>
+        /// Not supported: the chain filters only ever select contracts that are already in the chain
+        /// </summary>
+        protected override OptionContract CreateDataInstance(Symbol symbol)
+        {
+            throw new InvalidOperationException($"OptionChainFilterUniverse.CreateDataInstance(): {symbol} is not part of the chain");
+        }
+
+        /// <summary>
+        /// Gets the greeks of the given contract
+        /// </summary>
+        protected override Greeks GetGreeks(OptionContract contract) => contract.Greeks;
+
+        /// <summary>
+        /// Gets the implied volatility of the given contract
+        /// </summary>
+        protected override decimal GetImpliedVolatility(OptionContract contract) => contract.ImpliedVolatility;
+
+        /// <summary>
+        /// Gets the open interest of the given contract
+        /// </summary>
+        protected override decimal GetOpenInterest(OptionContract contract) => contract.OpenInterest;
+
+        private static IReadOnlyList<OptionContract> GetContracts(OptionChain chain)
+        {
+            // The dictionary caches its values as a list that is replaced, never mutated, so it is safe to share
+            return chain.Contracts.Values as IReadOnlyList<OptionContract> ?? chain.Contracts.Values.ToList();
+        }
+
+        private static BaseData GetUnderlying(OptionChain chain)
+        {
+            // A chain without underlying data carries an empty placeholder, which must not be used as a zero price
+            var underlying = chain.Underlying;
+            return underlying != null && underlying.Price != 0 ? underlying : null;
+        }
+
+        private static decimal GetStrikeMultiplier(OptionChain chain)
+        {
+            return chain.Contracts.Values.FirstOrDefault()?.SymbolProperties?.StrikeMultiplier ?? 1;
+        }
+    }
+}
diff --git a/Common/Securities/Option/OptionFilterUniverse.cs b/Common/Securities/Option/OptionFilterUniverse.cs
index 5cb946a97286..f7050a692203 100644
--- a/Common/Securities/Option/OptionFilterUniverse.cs
+++ b/Common/Securities/Option/OptionFilterUniverse.cs
@@ -20,6 +20,7 @@
 using System.Runtime.CompilerServices;
 using Python.Runtime;
 using QuantConnect.Data;
+using QuantConnect.Data.Market;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Securities.FutureOption;
 using QuantConnect.Securities.IndexOption;
@@ -28,12 +29,15 @@
 namespace QuantConnect.Securities
 {
     /// <summary>
-    /// Represents options symbols universe used in filtering.
+    /// Base option contracts filter, shared by the option universe selection filter (<see cref="OptionFilterUniverse"/>)
+    /// and the option chain filters (<see cref="Data.Market.OptionChain"/>) so both offer the same filters with the same semantics
     /// </summary>
-    public class OptionFilterUniverse : ContractSecurityFilterUniverse<OptionFilterUniverse, OptionUniverse>
+    /// <typeparam name="TUniverse">The concrete filter universe type</typeparam>
+    /// <typeparam name="TData">The option contract data type</typeparam>
+    public abstract class BaseOptionFilterUniverse<TUniverse, TData> : ContractSecurityFilterUniverse<TUniverse, TData>, IOptionContractFilters<TUniverse>
+        where TUniverse : BaseOptionFilterUniverse<TUniverse, TData>
+        where TData : ISymbolProvider
     {
-        private Option.Option _option;
-
         // Fields used in relative strikes filter
         private List<decimal> _uniqueStrikes;
         private bool _refreshUniqueStrikes;
@@ -45,6 +49,31 @@ public class OptionFilterUniverse : ContractSecurityFilterUniverse<OptionFilterU
         /// </summary>
         protected BaseData UnderlyingInternal { get; set; }
 
+        /// <summary>
+        /// The option exchange hours, used to resolve trading dates. Can be null, in which case no date adjustment is made
+        /// </summary>
+        protected abstract SecurityExchangeHours ExchangeHours { get; }
+
+        /// <summary>
+        /// The option security type
+        /// </summary>
+        protected abstract SecurityType SecurityType { get; }
+
+        /// <summary>
+        /// Gets the greeks of the given contract
+        /// </summary>
+        protected abstract Greeks GetGreeks(TData contract);
+
+        /// <summary>
+        /// Gets the implied volatility of the given contract
+        /// </summary>
+        protected abstract decimal GetImpliedVolatility(TData contract);
+
+        /// <summary>
+        /// Gets the open interest of the given contract
+        /// </summary>
+        protected abstract decimal GetOpenInterest(TData contract);
+
         /// <summary>
         /// The underlying price data
         /// </summary>
@@ -57,27 +86,29 @@ public BaseData Underlying
         }
 
         /// <summary>
-        /// Constructs OptionFilterUniverse
+        /// Constructs BaseOptionFilterUniverse
         /// By default, the filter includes both standard and weekly contracts.
         /// </summary>
-        /// <param name="option">The canonical option chain security</param>
-        public OptionFilterUniverse(Option.Option option)
+        /// <param name="underlyingScaleFactor">The option strike multiplier, see <see cref="SymbolProperties.StrikeMultiplier"/></param>
+        protected BaseOptionFilterUniverse(decimal underlyingScaleFactor)
         {
-            _option = option;
-            _underlyingScaleFactor = option.SymbolProperties.StrikeMultiplier;
+            _underlyingScaleFactor = underlyingScaleFactor;
         }
 
         /// <summary>
-        /// Constructs OptionFilterUniverse
+        /// Constructs BaseOptionFilterUniverse
         /// </summary>
-        /// <remarks>Used for testing only</remarks>
-        public OptionFilterUniverse(Option.Option option, IReadOnlyList<OptionUniverse> allData, BaseData underlying, decimal underlyingScaleFactor = 1)
-            : base(allData, underlying.EndTime)
+        /// <param name="allData">All data for the option contracts</param>
+        /// <param name="underlying">The current underlying last data point</param>
+        /// <param name="localTime">The current local time</param>
+        /// <param name="underlyingScaleFactor">The option strike multiplier, see <see cref="SymbolProperties.StrikeMultiplier"/></param>
+        protected BaseOptionFilterUniverse(IReadOnlyList<TData> allData, BaseData underlying, DateTime localTime, decimal underlyingScaleFactor = 1)
+            : base(allData, localTime)
         {
-            _option = option;
             UnderlyingInternal = underlying;
             _refreshUniqueStrikes = true;
             _underlyingScaleFactor = underlyingScaleFactor;
+            _lastExchangeDate = localTime.Date;
         }
 
         /// <summary>
@@ -86,7 +117,7 @@ public OptionFilterUniverse(Option.Option option, IReadOnlyList<OptionUniverse>
         /// <param name="allContractsData">All data for the option contracts</param>
         /// <param name="underlying">The current underlying last data point</param>
         /// <param name="localTime">The current local time</param>
-        public void Refresh(IReadOnlyList<OptionUniverse> allContractsData, BaseData underlying, DateTime localTime)
+        public void Refresh(IReadOnlyList<TData> allContractsData, BaseData underlying, DateTime localTime)
         {
             base.Refresh(allContractsData, localTime);
 
@@ -112,19 +143,6 @@ protected override bool IsStandard(Symbol symbol)
             }
         }
 
-        /// <summary>
-        /// Creates a new instance of the data type for the given symbol
-        /// </summary>
-        /// <returns>A data instance for the given symbol</returns>
-        protected override OptionUniverse CreateDataInstance(Symbol symbol)
-        {
-            return new OptionUniverse()
-            {
-                Symbol = symbol,
-                Time = LocalTime
-            };
-        }
-
         /// <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,
@@ -135,9 +153,9 @@ protected override OptionUniverse CreateDataInstance(Symbol symbol)
         protected override DateTime AdjustExpirationReferenceDate(DateTime referenceDate)
         {
             // Check whether the reference time is a tradable date:
-            if (!_option.Exchange.Hours.IsDateOpen(referenceDate))
+            if (ExchangeHours != null && !ExchangeHours.IsDateOpen(referenceDate))
             {
-                referenceDate = _option.Exchange.Hours.GetNextTradingDay(referenceDate);
+                referenceDate = ExchangeHours.GetNextTradingDay(referenceDate);
             }
 
             return referenceDate;
@@ -149,11 +167,11 @@ protected override DateTime AdjustExpirationReferenceDate(DateTime referenceDate
         /// <param name="minStrike">The minimum strike relative to the underlying price, for example, -1 would filter out contracts further than 1 strike below market price</param>
         /// <param name="maxStrike">The maximum strike relative to the underlying price, for example, +1 would filter out contracts further than 1 strike above market price</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Strikes(int minStrike, int maxStrike)
+        public TUniverse Strikes(int minStrike, int maxStrike)
         {
             if (UnderlyingInternal == null)
             {
-                return this;
+                return (TUniverse)this;
             }
 
             if (_refreshUniqueStrikes || _uniqueStrikes == null)
@@ -235,19 +253,19 @@ public OptionFilterUniverse Strikes(int minStrike, int maxStrike)
             Data = Data
                 .Where(data =>
                     {
-                        var price = data.ID.StrikePrice;
+                        var price = data.Symbol.ID.StrikePrice;
                         return price >= minPrice && price <= maxPrice;
                     }
                 ).ToList();
 
-            return this;
+            return (TUniverse)this;
         }
 
         /// <summary>
         /// Sets universe of call options (if any) as a selection
         /// </summary>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse CallsOnly()
+        public TUniverse CallsOnly()
         {
             return Contracts(contracts => contracts.Where(x => x.Symbol.ID.OptionRight == OptionRight.Call));
         }
@@ -256,7 +274,7 @@ public OptionFilterUniverse CallsOnly()
         /// Sets universe of put options (if any) as a selection
         /// </summary>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse PutsOnly()
+        public TUniverse PutsOnly()
         {
             return Contracts(contracts => contracts.Where(x => x.Symbol.ID.OptionRight == OptionRight.Put));
         }
@@ -268,7 +286,7 @@ public OptionFilterUniverse PutsOnly()
         /// <param name="strikeFromAtm">The desire strike price distance from the current underlying price</param>
         /// <remarks>Applicable to Naked Call, Covered Call, and Protective Call Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse NakedCall(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
+        public TUniverse NakedCall(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
         {
             return SingleContract(OptionRight.Call, minDaysTillExpiry, strikeFromAtm);
         }
@@ -280,13 +298,18 @@ public OptionFilterUniverse NakedCall(int minDaysTillExpiry = 30, decimal strike
         /// <param name="strikeFromAtm">The desire strike price distance from the current underlying price</param>
         /// <remarks>Applicable to Naked Put, Covered Put, and Protective Put Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse NakedPut(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
+        public TUniverse NakedPut(int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
         {
             return SingleContract(OptionRight.Put, minDaysTillExpiry, strikeFromAtm);
         }
 
-        private OptionFilterUniverse SingleContract(OptionRight right, int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
+        private TUniverse SingleContract(OptionRight right, int minDaysTillExpiry = 30, decimal strikeFromAtm = 0)
         {
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contractsForExpiry = GetContractsForExpiry(AllSymbols, minDaysTillExpiry);
             var contracts = contractsForExpiry.Where(x => x.ID.OptionRight == right).ToList();
@@ -310,7 +333,7 @@ private OptionFilterUniverse SingleContract(OptionRight right, int minDaysTillEx
         /// <param name="lowerStrikeFromAtm">The desire strike price distance from the current underlying price of the lower strike price</param>
         /// <remarks>Applicable to Bear Call Spread and Bull Call Spread Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse CallSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null)
+        public TUniverse CallSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null)
         {
             return Spread(OptionRight.Call, minDaysTillExpiry, higherStrikeFromAtm, lowerStrikeFromAtm);
         }
@@ -323,12 +346,12 @@ public OptionFilterUniverse CallSpread(int minDaysTillExpiry = 30, decimal highe
         /// <param name="lowerStrikeFromAtm">The desire strike price distance from the current underlying price of the lower strike price</param>
         /// <remarks>Applicable to Bear Put Spread and Bull Put Spread Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse PutSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null)
+        public TUniverse PutSpread(int minDaysTillExpiry = 30, decimal higherStrikeFromAtm = 5, decimal? lowerStrikeFromAtm = null)
         {
             return Spread(OptionRight.Put, minDaysTillExpiry, higherStrikeFromAtm, lowerStrikeFromAtm);
         }
 
-        private OptionFilterUniverse Spread(OptionRight right, int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal? lowerStrikeFromAtm = null)
+        private TUniverse Spread(OptionRight right, int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal? lowerStrikeFromAtm = null)
         {
             if (!lowerStrikeFromAtm.HasValue)
             {
@@ -341,6 +364,11 @@ private OptionFilterUniverse Spread(OptionRight right, int minDaysTillExpiry, de
                     + $"{nameof(higherStrikeFromAtm)}, {nameof(lowerStrikeFromAtm)}");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contractsForExpiry = GetContractsForExpiry(AllSymbols, minDaysTillExpiry);
             var contracts = contractsForExpiry.Where(x => x.ID.OptionRight == right).ToList();
@@ -372,7 +400,7 @@ private OptionFilterUniverse Spread(OptionRight right, int minDaysTillExpiry, de
         /// <param name="minFarDaysTillExpiry">The mininum days till expiry of the further conrtact from the current time, closest expiry will be selected</param>
         /// <remarks>Applicable to Long and Short Call Calendar Spread Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse CallCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
+        public TUniverse CallCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
         {
             return CalendarSpread(OptionRight.Call, strikeFromAtm, minNearDaysTillExpiry, minFarDaysTillExpiry);
         }
@@ -385,12 +413,12 @@ public OptionFilterUniverse CallCalendarSpread(decimal strikeFromAtm = 0, int mi
         /// <param name="minFarDaysTillExpiry">The mininum days till expiry of the further conrtact from the current time, closest expiry will be selected</param>
         /// <remarks>Applicable to Long and Short Put Calendar Spread Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse PutCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
+        public TUniverse PutCalendarSpread(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
         {
             return CalendarSpread(OptionRight.Put, strikeFromAtm, minNearDaysTillExpiry, minFarDaysTillExpiry);
         }
 
-        private OptionFilterUniverse CalendarSpread(OptionRight right, decimal strikeFromAtm, int minNearDaysTillExpiry, int minFarDaysTillExpiry)
+        private TUniverse CalendarSpread(OptionRight right, decimal strikeFromAtm, int minNearDaysTillExpiry, int minFarDaysTillExpiry)
         {
             if (minFarDaysTillExpiry <= minNearDaysTillExpiry)
             {
@@ -403,6 +431,11 @@ private OptionFilterUniverse CalendarSpread(OptionRight right, decimal strikeFro
                 throw new ArgumentException("CalendarSpread(): near expiry argument must be positive.");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the set strike
             var strike = GetStrike(AllSymbols, strikeFromAtm);
             var contracts = AllSymbols.Where(x => x.ID.StrikePrice == strike && x.ID.OptionRight == right).ToList();
@@ -432,7 +465,7 @@ private OptionFilterUniverse CalendarSpread(OptionRight right, decimal strikeFro
         /// <param name="putStrikeFromAtm">The desire strike price distance from the current underlying price of the OTM put. It must be negative.</param>
         /// <remarks>Applicable to Long and Short Strangle Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Strangle(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5)
+        public TUniverse Strangle(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5)
         {
             if (callStrikeFromAtm <= 0)
             {
@@ -453,7 +486,7 @@ public OptionFilterUniverse Strangle(int minDaysTillExpiry = 30, decimal callStr
         /// <param name="minDaysTillExpiry">The minimum days till expiry from the current time, closest expiry will be selected</param>
         /// <remarks>Applicable to Long and Short Straddle Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Straddle(int minDaysTillExpiry = 30)
+        public TUniverse Straddle(int minDaysTillExpiry = 30)
         {
             return CallPutSpread(minDaysTillExpiry, 0, 0);
         }
@@ -466,7 +499,7 @@ public OptionFilterUniverse Straddle(int minDaysTillExpiry = 30)
         /// <param name="putStrikeFromAtm">The desire strike price distance from the current underlying price of the put.</param>
         /// <remarks>Applicable to Protective Collar Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse ProtectiveCollar(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5)
+        public TUniverse ProtectiveCollar(int minDaysTillExpiry = 30, decimal callStrikeFromAtm = 5, decimal putStrikeFromAtm = -5)
         {
             if (callStrikeFromAtm <= putStrikeFromAtm)
             {
@@ -476,9 +509,9 @@ public OptionFilterUniverse ProtectiveCollar(int minDaysTillExpiry = 30, decimal
 
             var filtered = CallPutSpread(minDaysTillExpiry, callStrikeFromAtm, putStrikeFromAtm);
 
-            var callStrike = filtered.Single(x => x.ID.OptionRight == OptionRight.Call).ID.StrikePrice;
-            var putStrike = filtered.Single(x => x.ID.OptionRight == OptionRight.Put).ID.StrikePrice;
-            if (callStrike <= putStrike)
+            var call = filtered.SingleOrDefault(x => x.Symbol.ID.OptionRight == OptionRight.Call);
+            var put = filtered.SingleOrDefault(x => x.Symbol.ID.OptionRight == OptionRight.Put);
+            if (call == null || put == null || call.Symbol.ID.StrikePrice <= put.Symbol.ID.StrikePrice)
             {
                 return Empty();
             }
@@ -493,13 +526,18 @@ public OptionFilterUniverse ProtectiveCollar(int minDaysTillExpiry = 30, decimal
         /// <param name="strikeFromAtm">The desire strike price distance from the current underlying price</param>
         /// <remarks>Applicable to Conversion and Reverse Conversion Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Conversion(int minDaysTillExpiry = 30, decimal strikeFromAtm = 5)
+        public TUniverse Conversion(int minDaysTillExpiry = 30, decimal strikeFromAtm = 5)
         {
             return CallPutSpread(minDaysTillExpiry, strikeFromAtm, strikeFromAtm);
         }
 
-        private OptionFilterUniverse CallPutSpread(int minDaysTillExpiry, decimal callStrikeFromAtm, decimal putStrikeFromAtm, bool otm = false)
+        private TUniverse CallPutSpread(int minDaysTillExpiry, decimal callStrikeFromAtm, decimal putStrikeFromAtm, bool otm = false)
         {
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contracts = GetContractsForExpiry(AllSymbols, minDaysTillExpiry).ToList();
 
@@ -534,7 +572,7 @@ private OptionFilterUniverse CallPutSpread(int minDaysTillExpiry, decimal callSt
         /// <param name="strikeSpread">The desire strike price distance of the ITM call and the OTM call from the current underlying price</param>
         /// <remarks>Applicable to Long and Short Call Butterfly Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse CallButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        public TUniverse CallButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
         {
             return Butterfly(OptionRight.Call, minDaysTillExpiry, strikeSpread);
         }
@@ -546,18 +584,23 @@ public OptionFilterUniverse CallButterfly(int minDaysTillExpiry = 30, decimal st
         /// <param name="strikeSpread">The desire strike price distance of the ITM put and the OTM put from the current underlying price</param>
         /// <remarks>Applicable to Long and Short Put Butterfly Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse PutButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        public TUniverse PutButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
         {
             return Butterfly(OptionRight.Put, minDaysTillExpiry, strikeSpread);
         }
 
-        private OptionFilterUniverse Butterfly(OptionRight right, int minDaysTillExpiry, decimal strikeSpread)
+        private TUniverse Butterfly(OptionRight right, int minDaysTillExpiry, decimal strikeSpread)
         {
             if (strikeSpread <= 0)
             {
                 throw new ArgumentException("ProtectiveCollar(): strikeSpread arguments must be positive");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contractsForExpiry = GetContractsForExpiry(AllSymbols, minDaysTillExpiry);
             var contracts = contractsForExpiry.Where(x => x.ID.OptionRight == right).ToList();
@@ -576,9 +619,9 @@ private OptionFilterUniverse Butterfly(OptionRight right, int minDaysTillExpiry,
             }
 
             // Select the contracts
-            var filtered = this.Where(x =>
-                x.ID.Date == contracts[0].ID.Date && x.ID.OptionRight == right &&
-                (x.ID.StrikePrice == atmStrike || x.ID.StrikePrice == lowerStrike || x.ID.StrikePrice == upperStrike));
+            var filtered = Contracts(data => data.Where(x =>
+                x.Symbol.ID.Date == contracts[0].ID.Date && x.Symbol.ID.OptionRight == right &&
+                (x.Symbol.ID.StrikePrice == atmStrike || x.Symbol.ID.StrikePrice == lowerStrike || x.Symbol.ID.StrikePrice == upperStrike)));
             if (filtered.Count() != 3)
             {
                 return Empty();
@@ -593,13 +636,18 @@ private OptionFilterUniverse Butterfly(OptionRight right, int minDaysTillExpiry,
         /// <param name="strikeSpread">The desire strike price distance of the OTM call and the OTM put from the current underlying price</param>
         /// <remarks>Applicable to Long and Short Iron Butterfly Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse IronButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        public TUniverse IronButterfly(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
         {
             if (strikeSpread <= 0)
             {
                 throw new ArgumentException("IronButterfly(): strikeSpread arguments must be positive");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contracts = GetContractsForExpiry(AllSymbols, minDaysTillExpiry).ToList();
             var calls = contracts.Where(x => x.ID.OptionRight == OptionRight.Call && x.ID.StrikePrice > Underlying.Price).ToList();
@@ -619,12 +667,12 @@ public OptionFilterUniverse IronButterfly(int minDaysTillExpiry = 30, decimal st
                 otmPutStrike = atmStrike * 2 - otmCallStrike;
             }
 
-            var filtered = this.Where(x =>
-                x.ID.Date == contracts[0].ID.Date && (
-                x.ID.StrikePrice == atmStrike ||
-                (x.ID.OptionRight == OptionRight.Call && x.ID.StrikePrice == otmCallStrike) ||
-                (x.ID.OptionRight == OptionRight.Put && x.ID.StrikePrice == otmPutStrike)
-            ));
+            var filtered = Contracts(data => data.Where(x =>
+                x.Symbol.ID.Date == contracts[0].ID.Date && (
+                x.Symbol.ID.StrikePrice == atmStrike ||
+                (x.Symbol.ID.OptionRight == OptionRight.Call && x.Symbol.ID.StrikePrice == otmCallStrike) ||
+                (x.Symbol.ID.OptionRight == OptionRight.Put && x.Symbol.ID.StrikePrice == otmPutStrike)
+            )));
             if (filtered.Count() != 4)
             {
                 return Empty();
@@ -641,7 +689,7 @@ public OptionFilterUniverse IronButterfly(int minDaysTillExpiry = 30, decimal st
         /// <param name="farStrikeSpread">The desire strike price distance of the further-to-expiry call and the further-to-expiry put from the current underlying price</param>
         /// <remarks>Applicable to Long and Short Iron Condor Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse IronCondor(int minDaysTillExpiry = 30, decimal nearStrikeSpread = 5, decimal farStrikeSpread = 10)
+        public TUniverse IronCondor(int minDaysTillExpiry = 30, decimal nearStrikeSpread = 5, decimal farStrikeSpread = 10)
         {
             if (nearStrikeSpread <= 0 || farStrikeSpread <= 0)
             {
@@ -655,6 +703,11 @@ public OptionFilterUniverse IronCondor(int minDaysTillExpiry = 30, decimal nearS
                     + $"{nameof(nearStrikeSpread)}, {nameof(farStrikeSpread)}");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contracts = GetContractsForExpiry(AllSymbols, minDaysTillExpiry).ToList();
             var calls = contracts.Where(x => x.ID.OptionRight == OptionRight.Call && x.ID.StrikePrice > Underlying.Price).ToList();
@@ -676,13 +729,13 @@ public OptionFilterUniverse IronCondor(int minDaysTillExpiry = 30, decimal nearS
             }
 
             // Select the contracts
-            var filtered = this.Where(x =>
-                x.ID.Date == contracts[0].ID.Date && (
-                (x.ID.OptionRight == OptionRight.Call && x.ID.StrikePrice == nearCallStrike) ||
-                (x.ID.OptionRight == OptionRight.Put && x.ID.StrikePrice == nearPutStrike) ||
-                (x.ID.OptionRight == OptionRight.Call && x.ID.StrikePrice == farCallStrike) ||
-                (x.ID.OptionRight == OptionRight.Put && x.ID.StrikePrice == farPutStrike)
-            ));
+            var filtered = Contracts(data => data.Where(x =>
+                x.Symbol.ID.Date == contracts[0].ID.Date && (
+                (x.Symbol.ID.OptionRight == OptionRight.Call && x.Symbol.ID.StrikePrice == nearCallStrike) ||
+                (x.Symbol.ID.OptionRight == OptionRight.Put && x.Symbol.ID.StrikePrice == nearPutStrike) ||
+                (x.Symbol.ID.OptionRight == OptionRight.Call && x.Symbol.ID.StrikePrice == farCallStrike) ||
+                (x.Symbol.ID.OptionRight == OptionRight.Put && x.Symbol.ID.StrikePrice == farPutStrike)
+            )));
             if (filtered.Count() != 4)
             {
                 return Empty();
@@ -698,13 +751,18 @@ public OptionFilterUniverse IronCondor(int minDaysTillExpiry = 30, decimal nearS
         /// <param name="strikeSpread">The desire strike price distance of the OTM call and the OTM put from the current underlying price</param>
         /// <remarks>Applicable to Long and Short Box Spread Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse BoxSpread(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
+        public TUniverse BoxSpread(int minDaysTillExpiry = 30, decimal strikeSpread = 5)
         {
             if (strikeSpread <= 0)
             {
                 throw new ArgumentException($"BoxSpread(): strike arguments must be positive, {nameof(strikeSpread)}");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contracts = GetContractsForExpiry(AllSymbols, minDaysTillExpiry).ToList();
             if (contracts.Count == 0)
@@ -717,9 +775,9 @@ public OptionFilterUniverse BoxSpread(int minDaysTillExpiry = 30, decimal strike
             var lowerStrike = GetStrike(contracts.Where(x => x.ID.StrikePrice < higherStrike && x.ID.StrikePrice < Underlying.Price), -strikeSpread);
 
             // Select the contracts
-            var filtered = this.Where(x =>
-                (x.ID.StrikePrice == higherStrike || x.ID.StrikePrice == lowerStrike) &&
-                x.ID.Date == contracts[0].ID.Date);
+            var filtered = Contracts(data => data.Where(x =>
+                (x.Symbol.ID.StrikePrice == higherStrike || x.Symbol.ID.StrikePrice == lowerStrike) &&
+                x.Symbol.ID.Date == contracts[0].ID.Date));
             if (filtered.Count() != 4)
             {
                 return Empty();
@@ -735,7 +793,7 @@ public OptionFilterUniverse BoxSpread(int minDaysTillExpiry = 30, decimal strike
         /// <param name="minFarDaysTillExpiry">The mininum days till expiry of the further conrtact from the current time, closest expiry will be selected</param>
         /// <remarks>Applicable to Long and Short Jelly Roll Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse JellyRoll(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
+        public TUniverse JellyRoll(decimal strikeFromAtm = 0, int minNearDaysTillExpiry = 30, int minFarDaysTillExpiry = 60)
         {
             if (minFarDaysTillExpiry <= minNearDaysTillExpiry)
             {
@@ -748,6 +806,11 @@ public OptionFilterUniverse JellyRoll(decimal strikeFromAtm = 0, int minNearDays
                 throw new ArgumentException("JellyRoll(): near expiry argument must be positive.");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the set strike
             var strike = AllSymbols.OrderBy(x => Math.Abs(Underlying.Price - x.ID.StrikePrice + strikeFromAtm))
                 .First().ID.StrikePrice;
@@ -769,7 +832,7 @@ public OptionFilterUniverse JellyRoll(decimal strikeFromAtm = 0, int minNearDays
             }
             var farExpiry = farExpiryContract.ID.Date;
 
-            var filtered = this.Where(x => x.ID.StrikePrice == strike && (x.ID.Date == nearExpiry || x.ID.Date == farExpiry));
+            var filtered = Contracts(data => data.Where(x => x.Symbol.ID.StrikePrice == strike && (x.Symbol.ID.Date == nearExpiry || x.Symbol.ID.Date == farExpiry)));
             if (filtered.Count() != 4)
             {
                 return Empty();
@@ -786,7 +849,7 @@ public OptionFilterUniverse JellyRoll(decimal strikeFromAtm = 0, int minNearDays
         /// <param name="lowerStrikeFromAtm">The desire strike price distance from the current underlying price of the lower strike price</param>
         /// <remarks>Applicable to Bear Call Ladder and Bull Call Ladder Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse CallLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
+        public TUniverse CallLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
         {
             return Ladder(OptionRight.Call, minDaysTillExpiry, higherStrikeFromAtm, middleStrikeFromAtm, lowerStrikeFromAtm);
         }
@@ -800,7 +863,7 @@ public OptionFilterUniverse CallLadder(int minDaysTillExpiry, decimal higherStri
         /// <param name="lowerStrikeFromAtm">The desire strike price distance from the current underlying price of the lower strike price</param>
         /// <remarks>Applicable to Bear Put Ladder and Bull Put Ladder Option Strategy</remarks>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse PutLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
+        public TUniverse PutLadder(int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
         {
             return Ladder(OptionRight.Put, minDaysTillExpiry, higherStrikeFromAtm, middleStrikeFromAtm, lowerStrikeFromAtm);
         }
@@ -811,10 +874,10 @@ public OptionFilterUniverse PutLadder(int minDaysTillExpiry, decimal higherStrik
         /// <param name="min">The minimum Delta value</param>
         /// <param name="max">The maximum Delta value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Delta(decimal min, decimal max)
+        public TUniverse Delta(decimal min, decimal max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(Delta));
-            return this.Where(contractData => contractData.Greeks.Delta >= min && contractData.Greeks.Delta <= max);
+            return InRange(contract => GetGreeks(contract).Delta, min, max);
         }
 
         /// <summary>
@@ -824,7 +887,7 @@ public OptionFilterUniverse Delta(decimal min, decimal max)
         /// <param name="min">The minimum Delta value</param>
         /// <param name="max">The maximum Delta value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse D(decimal min, decimal max)
+        public TUniverse D(decimal min, decimal max)
         {
             return Delta(min, max);
         }
@@ -835,10 +898,10 @@ public OptionFilterUniverse D(decimal min, decimal max)
         /// <param name="min">The minimum Gamma value</param>
         /// <param name="max">The maximum Gamma value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Gamma(decimal min, decimal max)
+        public TUniverse Gamma(decimal min, decimal max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(Gamma));
-            return this.Where(contractData => contractData.Greeks.Gamma >= min && contractData.Greeks.Gamma <= max);
+            return InRange(contract => GetGreeks(contract).Gamma, min, max);
         }
 
         /// <summary>
@@ -848,7 +911,7 @@ public OptionFilterUniverse Gamma(decimal min, decimal max)
         /// <param name="min">The minimum Gamma value</param>
         /// <param name="max">The maximum Gamma value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse G(decimal min, decimal max)
+        public TUniverse G(decimal min, decimal max)
         {
             return Gamma(min, max);
         }
@@ -859,10 +922,10 @@ public OptionFilterUniverse G(decimal min, decimal max)
         /// <param name="min">The minimum Theta value</param>
         /// <param name="max">The maximum Theta value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Theta(decimal min, decimal max)
+        public TUniverse Theta(decimal min, decimal max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(Theta));
-            return this.Where(contractData => contractData.Greeks.Theta >= min && contractData.Greeks.Theta <= max);
+            return InRange(contract => GetGreeks(contract).Theta, min, max);
         }
 
         /// <summary>
@@ -872,7 +935,7 @@ public OptionFilterUniverse Theta(decimal min, decimal max)
         /// <param name="min">The minimum Theta value</param>
         /// <param name="max">The maximum Theta value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse T(decimal min, decimal max)
+        public TUniverse T(decimal min, decimal max)
         {
             return Theta(min, max);
         }
@@ -883,10 +946,10 @@ public OptionFilterUniverse T(decimal min, decimal max)
         /// <param name="min">The minimum Vega value</param>
         /// <param name="max">The maximum Vega value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Vega(decimal min, decimal max)
+        public TUniverse Vega(decimal min, decimal max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(Vega));
-            return this.Where(contractData => contractData.Greeks.Vega >= min && contractData.Greeks.Vega <= max);
+            return InRange(contract => GetGreeks(contract).Vega, min, max);
         }
 
         /// <summary>
@@ -896,7 +959,7 @@ public OptionFilterUniverse Vega(decimal min, decimal max)
         /// <param name="min">The minimum Vega value</param>
         /// <param name="max">The maximum Vega value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse V(decimal min, decimal max)
+        public TUniverse V(decimal min, decimal max)
         {
             return Vega(min, max);
         }
@@ -907,10 +970,10 @@ public OptionFilterUniverse V(decimal min, decimal max)
         /// <param name="min">The minimum Rho value</param>
         /// <param name="max">The maximum Rho value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse Rho(decimal min, decimal max)
+        public TUniverse Rho(decimal min, decimal max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(Rho));
-            return this.Where(contractData => contractData.Greeks.Rho >= min && contractData.Greeks.Rho <= max);
+            return InRange(contract => GetGreeks(contract).Rho, min, max);
         }
 
         /// <summary>
@@ -920,7 +983,7 @@ public OptionFilterUniverse Rho(decimal min, decimal max)
         /// <param name="min">The minimum Rho value</param>
         /// <param name="max">The maximum Rho value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse R(decimal min, decimal max)
+        public TUniverse R(decimal min, decimal max)
         {
             return Rho(min, max);
         }
@@ -931,10 +994,10 @@ public OptionFilterUniverse R(decimal min, decimal max)
         /// <param name="min">The minimum implied volatility value</param>
         /// <param name="max">The maximum implied volatility value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse ImpliedVolatility(decimal min, decimal max)
+        public TUniverse ImpliedVolatility(decimal min, decimal max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(ImpliedVolatility));
-            return this.Where(contractData => contractData.ImpliedVolatility >= min && contractData.ImpliedVolatility <= max);
+            return InRange(GetImpliedVolatility, min, max);
         }
 
         /// <summary>
@@ -944,7 +1007,7 @@ public OptionFilterUniverse ImpliedVolatility(decimal min, decimal max)
         /// <param name="min">The minimum implied volatility value</param>
         /// <param name="max">The maximum implied volatility value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse IV(decimal min, decimal max)
+        public TUniverse IV(decimal min, decimal max)
         {
             return ImpliedVolatility(min, max);
         }
@@ -955,10 +1018,10 @@ public OptionFilterUniverse IV(decimal min, decimal max)
         /// <param name="min">The minimum open interest value</param>
         /// <param name="max">The maximum open interest value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse OpenInterest(long min, long max)
+        public TUniverse OpenInterest(long min, long max)
         {
             ValidateSecurityTypeForSupportedFilters(nameof(OpenInterest));
-            return this.Where(contractData => contractData.OpenInterest >= min && contractData.OpenInterest <= max);
+            return InRange(GetOpenInterest, min, max);
         }
 
         /// <summary>
@@ -968,25 +1031,12 @@ public OptionFilterUniverse OpenInterest(long min, long max)
         /// <param name="min">The minimum open interest value</param>
         /// <param name="max">The maximum open interest value</param>
         /// <returns>Universe with filter applied</returns>
-        public OptionFilterUniverse OI(long min, long max)
+        public TUniverse OI(long min, long max)
         {
             return OpenInterest(min, max);
         }
 
-        /// <summary>
-        /// Implicitly convert the universe to a list of symbols
-        /// </summary>
-        /// <param name="universe"></param>
-#pragma warning disable CA1002 // Do not expose generic lists
-#pragma warning disable CA2225 // Operator overloads have named alternates
-        public static implicit operator List<Symbol>(OptionFilterUniverse universe)
-        {
-            return universe.AllSymbols.ToList();
-        }
-#pragma warning restore CA2225 // Operator overloads have named alternates
-#pragma warning restore CA1002 // Do not expose generic lists
-
-        private OptionFilterUniverse Ladder(OptionRight right, int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
+        private TUniverse Ladder(OptionRight right, int minDaysTillExpiry, decimal higherStrikeFromAtm, decimal middleStrikeFromAtm, decimal lowerStrikeFromAtm)
         {
             if (higherStrikeFromAtm <= lowerStrikeFromAtm || higherStrikeFromAtm <= middleStrikeFromAtm || middleStrikeFromAtm <= lowerStrikeFromAtm)
             {
@@ -994,6 +1044,11 @@ private OptionFilterUniverse Ladder(OptionRight right, int minDaysTillExpiry, de
                     + $"{nameof(higherStrikeFromAtm)}, {nameof(middleStrikeFromAtm)}, {nameof(lowerStrikeFromAtm)}");
             }
 
+            if (UnderlyingInternal == null)
+            {
+                return Empty();
+            }
+
             // Select the expiry as the nearest to set days later
             var contracts = GetContractsForExpiry(AllSymbols.Where(x => x.ID.OptionRight == right).ToList(), minDaysTillExpiry);
 
@@ -1012,7 +1067,7 @@ private OptionFilterUniverse Ladder(OptionRight right, int minDaysTillExpiry, de
                 return Empty();
             }
 
-            return this.WhereContains(new List<Symbol> { lowerStrikeContract, middleStrikeContract, higherStrikeContract });
+            return Contracts(data => data.Where(x => x.Symbol == lowerStrikeContract || x.Symbol == middleStrikeContract || x.Symbol == higherStrikeContract));
         }
 
         /// <summary>
@@ -1032,22 +1087,34 @@ private IEnumerable<Symbol> GetContractsForExpiry(IEnumerable<Symbol> symbols, i
                 ?.OrderBy(x => x.ID) ?? Enumerable.Empty<Symbol>();
         }
 
+        /// <summary>
+        /// Selects the contracts whose value, given by the selector, is within the given range. The selector runs once per contract
+        /// </summary>
+        private TUniverse InRange(Func<TData, decimal> selector, decimal min, decimal max)
+        {
+            return Contracts(data => data.Where(contract =>
+            {
+                var value = selector(contract);
+                return value >= min && value <= max;
+            }));
+        }
+
         /// <summary>
         /// Helper method that will select no contract
         /// </summary>
-        private OptionFilterUniverse Empty()
+        private TUniverse Empty()
         {
-            Data = Enumerable.Empty<OptionUniverse>().ToList();
-            return this;
+            Data = Enumerable.Empty<TData>().ToList();
+            return (TUniverse)this;
         }
 
         /// <summary>
         /// Helper method that will select the given contract list
         /// </summary>
-        private OptionFilterUniverse SymbolList(List<Symbol> contracts)
+        private TUniverse SymbolList(List<Symbol> contracts)
         {
             AllSymbols = contracts;
-            return this;
+            return (TUniverse)this;
         }
 
         private decimal GetStrike(IEnumerable<Symbol> symbols, decimal strikeFromAtm)
@@ -1061,13 +1128,93 @@ private decimal GetStrike(IEnumerable<Symbol> symbols, decimal strikeFromAtm)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void ValidateSecurityTypeForSupportedFilters(string filterName)
         {
-            if (_option.Symbol.SecurityType == SecurityType.FutureOption)
+            if (SecurityType == SecurityType.FutureOption)
             {
                 throw new InvalidOperationException($"{filterName} filter is not supported for future options.");
             }
         }
     }
 
+    /// <summary>
+    /// Represents options symbols universe used in filtering.
+    /// </summary>
+    public class OptionFilterUniverse : BaseOptionFilterUniverse<OptionFilterUniverse, OptionUniverse>
+    {
+        private readonly Option.Option _option;
+
+        /// <summary>
+        /// The option exchange hours
+        /// </summary>
+        protected override SecurityExchangeHours ExchangeHours => _option?.Exchange.Hours;
+
+        /// <summary>
+        /// The option security type
+        /// </summary>
+        protected override SecurityType SecurityType => _option.Symbol.SecurityType;
+
+        /// <summary>
+        /// Constructs OptionFilterUniverse
+        /// By default, the filter includes both standard and weekly contracts.
+        /// </summary>
+        /// <param name="option">The canonical option chain security</param>
+        public OptionFilterUniverse(Option.Option option)
+            : base(option.SymbolProperties.StrikeMultiplier)
+        {
+            _option = option;
+        }
+
+        /// <summary>
+        /// Constructs OptionFilterUniverse
+        /// </summary>
+        /// <remarks>Used for testing only</remarks>
+        public OptionFilterUniverse(Option.Option option, IReadOnlyList<OptionUniverse> allData, BaseData underlying, decimal underlyingScaleFactor = 1)
+            : base(allData, underlying, underlying.EndTime, underlyingScaleFactor)
+        {
+            _option = option;
+        }
+
+        /// <summary>
+        /// Creates a new instance of the data type for the given symbol
+        /// </summary>
+        /// <returns>A data instance for the given symbol</returns>
+        protected override OptionUniverse CreateDataInstance(Symbol symbol)
+        {
+            return new OptionUniverse()
+            {
+                Symbol = symbol,
+                Time = LocalTime
+            };
+        }
+
+        /// <summary>
+        /// Gets the greeks of the given contract
+        /// </summary>
+        protected override Greeks GetGreeks(OptionUniverse contract) => contract.Greeks;
+
+        /// <summary>
+        /// Gets the implied volatility of the given contract
+        /// </summary>
+        protected override decimal GetImpliedVolatility(OptionUniverse contract) => contract.ImpliedVolatility;
+
+        /// <summary>
+        /// Gets the open interest of the given contract
+        /// </summary>
+        protected override decimal GetOpenInterest(OptionUniverse contract) => contract.OpenInterest;
+
+        /// <summary>
+        /// Implicitly convert the universe to a list of symbols
+        /// </summary>
+        /// <param name="universe"></param>
+#pragma warning disable CA1002 // Do not expose generic lists
+#pragma warning disable CA2225 // Operator overloads have named alternates
+        public static implicit operator List<Symbol>(OptionFilterUniverse universe)
+        {
+            return universe.AllSymbols.ToList();
+        }
+#pragma warning restore CA2225 // Operator overloads have named alternates
+#pragma warning restore CA1002 // Do not expose generic lists
+    }
+
     /// <summary>
     /// Extensions for Linq support
     /// </summary>
@@ -1081,8 +1228,7 @@ public static class OptionFilterUniverseEx
         /// <returns>Universe with filter applied</returns>
         public static OptionFilterUniverse Where(this OptionFilterUniverse universe, Func<OptionUniverse, bool> predicate)
         {
-            universe.Data = universe.Data.Where(predicate).ToList();
-            return universe;
+            return universe.Contracts(data => data.Where(predicate));
         }
 
         /// <summary>
@@ -1093,8 +1239,7 @@ public static OptionFilterUniverse Where(this OptionFilterUniverse universe, Fun
         /// <returns>Universe with filter applied</returns>
         public static OptionFilterUniverse Where(this OptionFilterUniverse universe, PyObject predicate)
         {
-            universe.Data = universe.Data.Where(predicate.SafeAs<Func<OptionUniverse, bool>>()).ToList();
-            return universe;
+            return universe.Where(predicate.SafeAs<Func<OptionUniverse, bool>>());
         }
 
         /// <summary>
@@ -1105,8 +1250,7 @@ public static OptionFilterUniverse Where(this OptionFilterUniverse universe, PyO
         /// <returns>Universe with filter applied</returns>
         public static OptionFilterUniverse Select(this OptionFilterUniverse universe, Func<OptionUniverse, Symbol> mapFunc)
         {
-            universe.AllSymbols = universe.Data.Select(mapFunc).ToList();
-            return universe;
+            return universe.Contracts(data => data.Select(mapFunc));
         }
 
         /// <summary>
@@ -1128,8 +1272,7 @@ public static OptionFilterUniverse Select(this OptionFilterUniverse universe, Py
         /// <returns>Universe with filter applied</returns>
         public static OptionFilterUniverse SelectMany(this OptionFilterUniverse universe, Func<OptionUniverse, IEnumerable<Symbol>> mapFunc)
         {
-            universe.AllSymbols = universe.Data.SelectMany(mapFunc).ToList();
-            return universe;
+            return universe.Contracts(data => data.SelectMany(mapFunc));
         }
 
         /// <summary>
@@ -1151,8 +1294,7 @@ public static OptionFilterUniverse SelectMany(this OptionFilterUniverse universe
         /// <returns>Universe with filter applied</returns>
         public static OptionFilterUniverse WhereContains(this OptionFilterUniverse universe, List<Symbol> filterList)
         {
-            universe.Data = universe.Data.Where(x => filterList.Contains(x)).ToList();
-            return universe;
+            return universe.Where(x => filterList.Contains(x.Symbol));
         }
 
         /// <summary>
diff --git a/Engine/DataFeeds/TimeSliceFactory.cs b/Engine/DataFeeds/TimeSliceFactory.cs
index 28208e25696a..153db02c58ba 100644
--- a/Engine/DataFeeds/TimeSliceFactory.cs
+++ b/Engine/DataFeeds/TimeSliceFactory.cs
@@ -427,7 +427,8 @@ private bool HandleOptionData(DateTime algorithmTime, BaseData baseData, OptionC
             var canonical = symbol.Canonical;
             if (!optionChains.TryGetValue(canonical, out chain))
             {
-                chain = new OptionChain(canonical, algorithmTime);
+                // the data is already in the exchange time zone, unlike the algorithm time the chain is stamped with
+                chain = new OptionChain(canonical, algorithmTime) { ExchangeTime = baseData.EndTime };
                 optionChains[canonical] = chain;
             }
 
@@ -504,7 +505,7 @@ private bool HandleFuturesData(DateTime algorithmTime, BaseData baseData, Future
                     return false;
                 }
 
-                chain = new FuturesChain(canonical, algorithmTime);
+                chain = new FuturesChain(canonical, algorithmTime) { ExchangeTime = baseData.EndTime };
                 futuresChains[canonical] = chain;
             }
 
diff --git a/Tests/Common/Data/Market/OptionChainTests.cs b/Tests/Common/Data/Market/OptionChainTests.cs
new file mode 100644
index 000000000000..f117c4dbd962
--- /dev/null
+++ b/Tests/Common/Data/Market/OptionChainTests.cs
@@ -0,0 +1,481 @@
+/*
+ * 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.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using NUnit.Framework;
+using Python.Runtime;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Tests.Common.Data.Market
+{
+    [TestFixture]
+    public class OptionChainTests
+    {
+        private static readonly DateTime Date = new(2016, 2, 26);
+        private static readonly Symbol Canonical = Symbol.CreateCanonicalOption(Symbols.SPY);
+        private const decimal UnderlyingPrice = 101m;
+        private static readonly DateTime[] Expiries = { new(2016, 3, 4), new(2016, 3, 18), new(2016, 4, 15), new(2016, 6, 17) };
+        private static readonly decimal[] Strikes = { 90m, 95m, 97.5m, 100m, 102.5m, 105m, 110m };
+
+        private List<OptionUniverse> _data;
+        private BaseData _underlying;
+        private SymbolProperties _symbolProperties;
+        private Option _option;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            (_data, _underlying) = CreateUniverseData(Date, UnderlyingPrice, Expiries, Strikes);
+            _symbolProperties = SymbolPropertiesDatabase.FromDataFolder().GetSymbolProperties(QuantConnect.Market.USA, Canonical, SecurityType.Option, Currencies.USD);
+            _option = CreateOption();
+        }
+
+        private static IEnumerable<TestCaseData> FilterCases()
+        {
+            yield return Case("Strikes(-2, 2)", u => u.Strikes(-2, 2), c => c.Strikes(-2, 2));
+            yield return Case("Strikes(0, 0)", u => u.Strikes(0, 0), c => c.Strikes(0, 0));
+            yield return Case("Strikes(-1, 0)", u => u.Strikes(-1, 0), c => c.Strikes(-1, 0));
+            yield return Case("Strikes(-100, -10)", u => u.Strikes(-100, -10), c => c.Strikes(-100, -10), empty: true);
+            yield return Case("Expiration(0, 10)", u => u.Expiration(0, 10), c => c.Expiration(0, 10));
+            yield return Case("Expiration(10, 60)", u => u.Expiration(10, 60), c => c.Expiration(10, 60));
+            yield return Case("Expiration(TimeSpan)", u => u.Expiration(TimeSpan.FromDays(30), TimeSpan.FromDays(200)),
+                c => c.Expiration(TimeSpan.FromDays(30), TimeSpan.FromDays(200)));
+            yield return Case("Expiration(500, 600)", u => u.Expiration(500, 600), c => c.Expiration(500, 600), empty: true);
+            yield return Case("CallsOnly", u => u.CallsOnly(), c => c.CallsOnly());
+            yield return Case("PutsOnly", u => u.PutsOnly(), c => c.PutsOnly());
+            yield return Case("StandardsOnly", u => u.StandardsOnly(), c => c.StandardsOnly());
+            yield return Case("WeeklysOnly", u => u.WeeklysOnly(), c => c.WeeklysOnly());
+            yield return Case("FrontMonth", u => u.FrontMonth(), c => c.FrontMonth());
+            yield return Case("BackMonth", u => u.BackMonth(), c => c.BackMonth());
+            yield return Case("BackMonths", u => u.BackMonths(), c => c.BackMonths());
+            yield return Case("Delta", u => u.Delta(0.4m, 0.6m), c => c.Delta(0.4m, 0.6m));
+            yield return Case("D", u => u.D(-0.6m, -0.4m), c => c.D(-0.6m, -0.4m));
+            yield return Case("Delta(5, 6)", u => u.Delta(5, 6), c => c.Delta(5, 6), empty: true);
+            yield return Case("Gamma", u => u.Gamma(0.012m, 0.02m), c => c.Gamma(0.012m, 0.02m));
+            yield return Case("G", u => u.G(0.012m, 0.02m), c => c.G(0.012m, 0.02m));
+            // theta is annualized from the per day value in the file
+            yield return Case("Theta", u => u.Theta(-365, -219), c => c.Theta(-365, -219));
+            yield return Case("T", u => u.T(-365, -219), c => c.T(-365, -219));
+            yield return Case("Vega", u => u.Vega(6, 8), c => c.Vega(6, 8));
+            yield return Case("V", u => u.V(6, 8), c => c.V(6, 8));
+            yield return Case("Rho", u => u.Rho(2, 4), c => c.Rho(2, 4));
+            yield return Case("R", u => u.R(2, 4), c => c.R(2, 4));
+            yield return Case("ImpliedVolatility", u => u.ImpliedVolatility(0.16m, 0.18m), c => c.ImpliedVolatility(0.16m, 0.18m));
+            yield return Case("IV", u => u.IV(0.16m, 0.18m), c => c.IV(0.16m, 0.18m));
+            yield return Case("OpenInterest", u => u.OpenInterest(200, 500), c => c.OpenInterest(200, 500));
+            yield return Case("OI", u => u.OI(200, 500), c => c.OI(200, 500));
+            yield return Case("CallsOnly.Expiration.Strikes", u => u.CallsOnly().Expiration(0, 30).Strikes(-1, 1),
+                c => c.CallsOnly().Expiration(0, 30).Strikes(-1, 1));
+            yield return Case("PutsOnly.FrontMonth.Strikes", u => u.PutsOnly().FrontMonth().Strikes(-2, 0),
+                c => c.PutsOnly().FrontMonth().Strikes(-2, 0));
+            yield return Case("StandardsOnly.FrontMonth", u => u.StandardsOnly().FrontMonth(), c => c.StandardsOnly().FrontMonth());
+            yield return Case("WeeklysOnly.CallsOnly", u => u.WeeklysOnly().CallsOnly(), c => c.WeeklysOnly().CallsOnly());
+            yield return Case("Expiration.Delta.Strikes", u => u.Expiration(0, 30).Delta(0.4m, 0.6m).Strikes(-3, 3),
+                c => c.Expiration(0, 30).Delta(0.4m, 0.6m).Strikes(-3, 3));
+            yield return Case("NakedCall", u => u.NakedCall(10, 0), c => c.NakedCall(10, 0));
+            yield return Case("NakedPut", u => u.NakedPut(10, -5), c => c.NakedPut(10, -5));
+            yield return Case("NakedCall(1000)", u => u.NakedCall(1000, 0), c => c.NakedCall(1000, 0), empty: true);
+            yield return Case("CallSpread", u => u.CallSpread(10, 5), c => c.CallSpread(10, 5));
+            yield return Case("PutSpread", u => u.PutSpread(10, 5, -5), c => c.PutSpread(10, 5, -5));
+            yield return Case("CallCalendarSpread", u => u.CallCalendarSpread(0, 10, 40), c => c.CallCalendarSpread(0, 10, 40));
+            yield return Case("PutCalendarSpread", u => u.PutCalendarSpread(0, 10, 40), c => c.PutCalendarSpread(0, 10, 40));
+            yield return Case("Strangle", u => u.Strangle(10, 5, -5), c => c.Strangle(10, 5, -5));
+            yield return Case("Straddle", u => u.Straddle(10), c => c.Straddle(10));
+            yield return Case("ProtectiveCollar", u => u.ProtectiveCollar(10, 5, -5), c => c.ProtectiveCollar(10, 5, -5));
+            yield return Case("Conversion", u => u.Conversion(10, 5), c => c.Conversion(10, 5));
+            yield return Case("CallButterfly", u => u.CallButterfly(10, 5), c => c.CallButterfly(10, 5));
+            yield return Case("PutButterfly", u => u.PutButterfly(10, 5), c => c.PutButterfly(10, 5));
+            yield return Case("IronButterfly", u => u.IronButterfly(10, 5), c => c.IronButterfly(10, 5));
+            yield return Case("IronCondor", u => u.IronCondor(10, 5, 10), c => c.IronCondor(10, 5, 10));
+            yield return Case("BoxSpread", u => u.BoxSpread(10, 5), c => c.BoxSpread(10, 5));
+            yield return Case("JellyRoll", u => u.JellyRoll(0, 10, 40), c => c.JellyRoll(0, 10, 40));
+            yield return Case("CallLadder", u => u.CallLadder(10, 10, 5, -5), c => c.CallLadder(10, 10, 5, -5));
+            yield return Case("PutLadder", u => u.PutLadder(10, 10, 5, -5), c => c.PutLadder(10, 10, 5, -5));
+            yield return Case("StandardsOnly.IronCondor", u => u.StandardsOnly().IronCondor(10, 5, 10), c => c.StandardsOnly().IronCondor(10, 5, 10));
+        }
+
+        [TestCaseSource(nameof(FilterCases))]
+        public void ChainFiltersMatchUniverseFilters(Func<OptionFilterUniverse, OptionFilterUniverse> universeFilter,
+            Func<OptionChain, OptionChain> chainFilter, bool expectEmpty)
+        {
+            // the universe selection applies the contract type filters after the user filter
+            var expected = universeFilter(CreateUniverse()).ApplyTypesFilter().AsEnumerable().Select(x => x.Symbol.Value).ToList();
+            var actual = chainFilter(CreateChain()).Select(x => x.Symbol.Value).ToList();
+
+            Assert.AreEqual(expectEmpty, expected.Count == 0);
+            CollectionAssert.AreEquivalent(expected, actual);
+        }
+
+        [Test]
+        public void ChainExposesEveryUniverseFilter()
+        {
+            // Contracts() takes explicit symbols or a selector, which only makes sense for the universe selection
+            var universeFilters = typeof(OptionFilterUniverse)
+                .GetMethods(BindingFlags.Public | BindingFlags.Instance)
+                .Where(x => x.ReturnType == typeof(OptionFilterUniverse) && x.Name != "Contracts" && !x.IsDefined(typeof(ObsoleteAttribute)))
+                .ToList();
+
+            Assert.IsNotEmpty(universeFilters);
+            foreach (var universeFilter in universeFilters)
+            {
+                var parameters = universeFilter.GetParameters().Select(x => x.ParameterType).ToArray();
+                var chainFilter = typeof(IOptionContractFilters<OptionChain>).GetMethod(universeFilter.Name, parameters);
+                Assert.IsNotNull(chainFilter, $"{universeFilter.Name}({string.Join(", ", parameters.Select(x => x.Name))}) is not an option chain filter");
+            }
+        }
+
+        [Test]
+        public void FilteredChainSharesTheAuxiliaryData()
+        {
+            var chain = CreateChain();
+            var symbol = chain.First().Symbol;
+            chain.AddData(new TestAuxData { Symbol = symbol, Time = Date, Value = 1 });
+
+            var filtered = chain.PutsOnly();
+
+            Assert.IsNotNull(chain.GetAux<TestAuxData>(symbol));
+            Assert.AreSame(chain.GetAux<TestAuxData>(symbol), filtered.GetAux<TestAuxData>(symbol));
+        }
+
+        [Test]
+        public void FilteredChainIsANewChainSharingTheSourceProperties()
+        {
+            var chain = CreateChain();
+            var count = chain.Count;
+
+            var filtered = chain.CallsOnly().FrontMonth();
+
+            Assert.AreNotSame(chain, filtered);
+            Assert.AreEqual(count, chain.Count);
+            Assert.AreEqual(Strikes.Length, filtered.Count);
+            Assert.IsTrue(filtered.All(x => x.Right == OptionRight.Call && x.Expiry == Expiries[0]));
+            Assert.IsTrue(filtered.ContainsKey(filtered.First().Symbol));
+            Assert.AreEqual(chain.Symbol, filtered.Symbol);
+            Assert.AreEqual(chain.Time, filtered.Time);
+            Assert.AreSame(chain.Underlying, filtered.Underlying);
+        }
+
+        [Test]
+        public void UnderlyingIsTakenFromTheContractsData()
+        {
+            var chain = CreateChain();
+
+            Assert.AreEqual(UnderlyingPrice, chain.Underlying.Price);
+        }
+
+        [Test]
+        public void FiltersOnAnEmptyChainReturnAnEmptyChain()
+        {
+            var chain = new OptionChain(Canonical, Date);
+
+            foreach (var testCase in FilterCases())
+            {
+                var filter = (Func<OptionChain, OptionChain>)testCase.Arguments[1];
+                Assert.AreEqual(0, filter(chain).Count, testCase.TestName);
+            }
+        }
+
+        [Test]
+        public void FiltersUseTheExchangeTimeAsTheReferenceDate()
+        {
+            // The engine stamps slice chains in the algorithm time zone, which can already be the day after the exchange date
+            var exchangeDate = new DateTime(2016, 3, 4);
+            var (data, underlying) = CreateUniverseData(exchangeDate, UnderlyingPrice, new[] { exchangeDate, Expiries[1] }, Strikes);
+            var chain = new OptionChain(Canonical, exchangeDate, data, _symbolProperties) { Time = exchangeDate.AddDays(1) };
+            var universe = CreateUniverse(data, underlying, exchangeDate).Expiration(0, 0).ToList();
+
+            Assert.AreEqual(2 * Strikes.Length, universe.Count);
+            Assert.AreEqual(0, chain.Expiration(0, 0).Count);
+
+            chain.ExchangeTime = exchangeDate;
+            var filtered = chain.Expiration(0, 0);
+
+            CollectionAssert.AreEquivalent(universe.Select(x => x.Symbol.Value), filtered.Select(x => x.Symbol.Value));
+            Assert.AreEqual(chain.Time, filtered.Time);
+            Assert.AreEqual(exchangeDate, filtered.ExchangeTime);
+            CollectionAssert.AreEquivalent(universe.Where(x => x.ID.OptionRight == OptionRight.Call).Select(x => x.Symbol.Value),
+                chain.CallsOnly().Expiration(0, 0).Select(x => x.Symbol.Value));
+        }
+
+        [Test]
+        public void StrikesFilterIsSkippedWithoutUnderlyingPrice()
+        {
+            var contracts = _data.Select(x => new OptionUniverse(x) { Underlying = null }).ToList();
+            var chain = new OptionChain(Canonical, Date, contracts, _symbolProperties);
+
+            Assert.AreEqual(0, chain.Underlying.Price);
+            Assert.AreEqual(chain.Count, chain.Strikes(0, 0).Count);
+        }
+
+        [Test]
+        public void FiltersAreAvailableFromPython()
+        {
+            var chain = CreateChain();
+            var expectedFiltered = chain.CallsOnly().Expiration(0, 30).Strikes(-1, 1).Select(x => x.Symbol).ToList();
+            var expectedWhere = chain.Where(x => x.Right == OptionRight.Put && x.Strike > 100).Select(x => x.Symbol).ToList();
+            Assert.IsNotEmpty(expectedFiltered);
+            Assert.IsNotEmpty(expectedWhere);
+
+            using (Py.GIL())
+            {
+                using var module = PyModule.FromString(nameof(OptionChainTests), @"
+from AlgorithmImports import *
+
+def filter_chain(chain):
+    return chain.calls_only().expiration(0, 30).strikes(-1, 1)
+
+def where_chain(chain):
+    return chain.where(lambda contract: contract.right == OptionRight.PUT and contract.strike > 100)
+");
+                using var pyChain = chain.ToPython();
+
+                using var filtered = module.GetAttr("filter_chain").Invoke(pyChain);
+                CollectionAssert.AreEqual(expectedFiltered, filtered.As<OptionChain>().Select(x => x.Symbol).ToList());
+
+                using var where = module.GetAttr("where_chain").Invoke(pyChain);
+                CollectionAssert.AreEqual(expectedWhere, where.As<OptionChain>().Select(x => x.Symbol).ToList());
+            }
+        }
+
+        private static IEnumerable<TestCaseData> StrategyFilterCases()
+        {
+            yield return Case("NakedCall", u => u.NakedCall(10, 0), c => c.NakedCall(10, 0));
+            yield return Case("CallSpread", u => u.CallSpread(10, 5, -5), c => c.CallSpread(10, 5, -5));
+            yield return Case("CallCalendarSpread", u => u.CallCalendarSpread(0, 10, 40), c => c.CallCalendarSpread(0, 10, 40));
+            yield return Case("Strangle", u => u.Strangle(10, 5, -5), c => c.Strangle(10, 5, -5));
+            yield return Case("Straddle", u => u.Straddle(10), c => c.Straddle(10));
+            yield return Case("ProtectiveCollar", u => u.ProtectiveCollar(10, 5, -5), c => c.ProtectiveCollar(10, 5, -5));
+            yield return Case("Conversion", u => u.Conversion(10, 5), c => c.Conversion(10, 5));
+            yield return Case("CallButterfly", u => u.CallButterfly(10, 5), c => c.CallButterfly(10, 5));
+            yield return Case("IronButterfly", u => u.IronButterfly(10, 5), c => c.IronButterfly(10, 5));
+            yield return Case("IronCondor", u => u.IronCondor(10, 5, 10), c => c.IronCondor(10, 5, 10));
+            yield return Case("BoxSpread", u => u.BoxSpread(10, 5), c => c.BoxSpread(10, 5));
+            yield return Case("JellyRoll", u => u.JellyRoll(0, 10, 40), c => c.JellyRoll(0, 10, 40));
+            yield return Case("CallLadder", u => u.CallLadder(10, 5, 0, -5), c => c.CallLadder(10, 5, 0, -5));
+        }
+
+        [TestCaseSource(nameof(StrategyFilterCases))]
+        public void StrategyFiltersSelectNothingWithoutUnderlyingPrice(Func<OptionFilterUniverse, OptionFilterUniverse> universeFilter,
+            Func<OptionChain, OptionChain> chainFilter, bool _)
+        {
+            var contracts = _data.Select(x => new OptionUniverse(x) { Underlying = null }).ToList();
+            var chain = new OptionChain(Canonical, Date, contracts, _symbolProperties);
+            var universe = new OptionFilterUniverse(_option);
+            universe.Refresh(contracts, null, Date);
+
+            Assert.AreEqual(0, chain.Underlying.Price);
+            Assert.AreEqual(0, universeFilter(universe).Count);
+            Assert.AreEqual(0, chainFilter(chain).Count);
+        }
+
+        [Test]
+        public void StrategyFiltersValidateArgumentsLikeTheUniverseFilters()
+        {
+            var contracts = _data.Select(x => new OptionUniverse(x) { Underlying = null }).ToList();
+            var chains = new[] { CreateChain(), new OptionChain(Canonical, Date, contracts, _symbolProperties) };
+
+            foreach (var chain in chains)
+            {
+                Assert.Throws<ArgumentException>(() => chain.Strangle(10, -5, 5));
+                Assert.Throws<ArgumentException>(() => chain.CallSpread(10, 5, 10));
+                Assert.Throws<ArgumentException>(() => chain.IronCondor(10, 10, 5));
+                Assert.Throws<ArgumentException>(() => chain.CallCalendarSpread(0, 40, 10));
+            }
+        }
+
+        [Test]
+        public void TypeFiltersApplyToTheChainContractsInAnyOrder()
+        {
+            var chain = CreateChain();
+            var expected = CreateUniverse().StandardsOnly().FrontMonth().ToList().Select(x => x.Symbol.Value).ToList();
+
+            // The front month, 2016-03-04, is a weekly and 2016-03-18 the first standard expiry
+            Assert.AreEqual(2 * Strikes.Length, expected.Count);
+            CollectionAssert.AreEquivalent(expected, chain.StandardsOnly().FrontMonth().Select(x => x.Symbol.Value));
+            Assert.AreEqual(0, chain.FrontMonth().StandardsOnly().Count);
+            Assert.IsTrue(chain.FrontMonth().WeeklysOnly().All(x => x.Expiry == Expiries[0]));
+            Assert.Throws<InvalidOperationException>(() => CreateUniverse().FrontMonth().StandardsOnly());
+        }
+
+        [Test]
+        public void StrategyFiltersAreAvailableFromPython()
+        {
+            var chain = CreateChain();
+            var expectedIronCondor = chain.IronCondor(10, 5, 10).Select(x => x.Symbol.Value).ToList();
+            var expectedNakedPut = chain.NakedPut(10, -5).Select(x => x.Symbol.Value).ToList();
+            Assert.AreEqual(4, expectedIronCondor.Count);
+            Assert.AreEqual(1, expectedNakedPut.Count);
+
+            using (Py.GIL())
+            {
+                using var module = PyModule.FromString(nameof(OptionChainTests) + "Strategies", @"
+from AlgorithmImports import *
+
+def iron_condor(chain):
+    return chain.iron_condor(10, 5, 10)
+
+def naked_put(chain):
+    return chain.naked_put(min_days_till_expiry=10, strike_from_atm=-5)
+");
+                using var pyChain = chain.ToPython();
+
+                using var ironCondor = module.GetAttr("iron_condor").Invoke(pyChain);
+                CollectionAssert.AreEquivalent(expectedIronCondor, ironCondor.As<OptionChain>().Select(x => x.Symbol.Value).ToList());
+
+                using var nakedPut = module.GetAttr("naked_put").Invoke(pyChain);
+                CollectionAssert.AreEqual(expectedNakedPut, nakedPut.As<OptionChain>().Select(x => x.Symbol.Value).ToList());
+            }
+        }
+
+        private class TestAuxData : BaseData
+        {
+        }
+
+        private static TestCaseData Case(string name, Func<OptionFilterUniverse, OptionFilterUniverse> universeFilter,
+            Func<OptionChain, OptionChain> chainFilter, bool empty = false)
+        {
+            return new TestCaseData(universeFilter, chainFilter, empty).SetName("{m}(" + name + ")");
+        }
+
+        private OptionFilterUniverse CreateUniverse(List<OptionUniverse> data = null, BaseData underlying = null, DateTime? date = null)
+        {
+            data ??= _data;
+            underlying ??= _underlying;
+            var universe = new OptionFilterUniverse(_option, data, underlying);
+            universe.Refresh(data, underlying, date ?? Date);
+            return universe;
+        }
+
+        private OptionChain CreateChain()
+        {
+            return new OptionChain(Canonical, Date, _data, _symbolProperties);
+        }
+
+        private static Option CreateOption()
+        {
+            var exchangeHours = MarketHoursDatabase.FromDataFolder().GetExchangeHours(Canonical.ID.Market, Canonical, Canonical.SecurityType);
+            return new Option(
+                exchangeHours,
+                new SubscriptionDataConfig(typeof(TradeBar), Canonical, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, true, false, false),
+                new Cash(Currencies.USD, 0, 1m),
+                new OptionSymbolProperties(SymbolProperties.GetDefault(Currencies.USD)),
+                ErrorCurrencyConverter.Instance,
+                RegisteredSecurityDataTypesProvider.Null);
+        }
+
+        /// <summary>
+        /// Creates option universe data for every expiry/strike/right combination, with synthetic but monotonic
+        /// greeks, implied volatility and open interest so every range filter has a distinct answer
+        /// </summary>
+        private static (List<OptionUniverse>, BaseData) CreateUniverseData(DateTime date, decimal spot, DateTime[] expiries, decimal[] strikes)
+        {
+            var contracts = new List<(Symbol, decimal, decimal, Greeks)>();
+            var i = 0;
+            foreach (var expiry in expiries)
+            {
+                foreach (var strike in strikes)
+                {
+                    foreach (var right in new[] { OptionRight.Call, OptionRight.Put })
+                    {
+                        var symbol = Symbol.CreateOption(Canonical.Underlying, Canonical.ID.Market, OptionStyle.American, right, strike, expiry);
+                        var callDelta = Math.Clamp(0.5m + (spot - strike) / 20m, 0.05m, 0.95m);
+                        var delta = right == OptionRight.Call ? callDelta : callDelta - 1;
+                        var greeks = new Greeks(delta, 0.01m + 0.001m * i, 5 + i, -(0.5m + 0.1m * i) * 365m, 1 + i, 0);
+                        contracts.Add((symbol, 100 * (i + 1), 0.15m + 0.01m * i, greeks));
+                        i++;
+                    }
+                }
+            }
+
+            return CreateUniverseData(Canonical, date, spot, contracts);
+        }
+
+        /// <summary>
+        /// Creates option universe data by writing a universe file with the same code the data generator uses,
+        /// <see cref="OptionUniverse.ToCsv"/>, and reading it back with <see cref="OptionUniverse.Reader"/>,
+        /// so the tests follow the file format instead of hard coding it
+        /// </summary>
+        /// <param name="canonical">The canonical option symbol</param>
+        /// <param name="date">The universe file date</param>
+        /// <param name="spot">The underlying price, no underlying row is written when null</param>
+        /// <param name="contracts">The contract rows to write</param>
+        internal static (List<OptionUniverse> contracts, BaseData underlying) CreateUniverseData(Symbol canonical, DateTime date, decimal? spot,
+            IEnumerable<(Symbol symbol, decimal openInterest, decimal impliedVolatility, Greeks greeks)> contracts)
+        {
+            var rows = contracts.ToList();
+            var csv = new StringBuilder();
+            csv.AppendLine("#" + OptionUniverse.CsvHeader(canonical.SecurityType));
+            if (spot.HasValue)
+            {
+                csv.AppendLine(OptionUniverse.ToCsv(canonical.Underlying, spot.Value, spot.Value, spot.Value, spot.Value, 1000, null, null, null));
+            }
+            var i = 0;
+            foreach (var (symbol, openInterest, impliedVolatility, greeks) in rows)
+            {
+                var price = 1 + i++;
+                csv.AppendLine(OptionUniverse.ToCsv(symbol, price, price, price, price, i, openInterest, impliedVolatility, greeks));
+            }
+
+            var config = new SubscriptionDataConfig(typeof(OptionUniverse), canonical, Resolution.Daily, TimeZones.NewYork, TimeZones.NewYork, true, true, false);
+            var data = new List<OptionUniverse>();
+            BaseData underlying = null;
+            var factory = new OptionUniverse();
+            using var stream = new MemoryStream(Encoding.UTF8.GetBytes(csv.ToString()));
+            using var reader = new StreamReader(stream);
+            while (!reader.EndOfStream)
+            {
+                var line = (OptionUniverse)factory.Reader(config, reader, date, false);
+                if (line == null)
+                {
+                    continue;
+                }
+                if (line.Symbol.HasUnderlying)
+                {
+                    // the underlying row comes first in the file and is attached to each contract, like the universe collection does
+                    line.Underlying = underlying;
+                    data.Add(line);
+                }
+                else
+                {
+                    underlying = line;
+                }
+            }
+
+            // Fail here if the serializer and the reader ever drift apart, rather than silently filtering the wrong values
+            Assert.AreEqual(rows.Count, data.Count);
+            for (var j = 0; j < rows.Count; j++)
+            {
+                Assert.AreEqual(rows[j].symbol, data[j].Symbol);
+                Assert.AreEqual(rows[j].openInterest, data[j].OpenInterest);
+                Assert.AreEqual(rows[j].impliedVolatility, data[j].ImpliedVolatility);
+                Assert.AreEqual(rows[j].greeks.Delta, data[j].Greeks.Delta);
+                Assert.AreEqual(rows[j].greeks.Theta, data[j].Greeks.Theta);
+                Assert.AreEqual(rows[j].greeks.Rho, data[j].Greeks.Rho);
+            }
+            Assert.AreEqual(spot ?? 0, underlying?.Price ?? 0);
+
+            return (data, underlying);
+        }
+    }
+}
diff --git a/Tests/Common/Securities/Options/OptionFilterUniverseTests.cs b/Tests/Common/Securities/Options/OptionFilterUniverseTests.cs
index 4a24e92ea195..bec1e639c4fd 100644
--- a/Tests/Common/Securities/Options/OptionFilterUniverseTests.cs
+++ b/Tests/Common/Securities/Options/OptionFilterUniverseTests.cs
@@ -230,6 +230,18 @@ public void OptionUnivereDataFiltersAreNotSupportedForFutureOptions()
             });
         }
 
+        [Test]
+        public void TypeFiltersMustBeAppliedBeforeExpiryFilters()
+        {
+            var universe = new OptionFilterUniverse(GetOption(), _testOptionsData, _underlying);
+            var count = universe.Count;
+
+            universe.FrontMonth();
+
+            Assert.Less(universe.Count, count);
+            Assert.Throws<InvalidOperationException>(() => universe.StandardsOnly());
+        }
+
         [Test]
         public void CountReturnsTheNumberOfContractsInTheUniverse()
         {
diff --git a/Tests/Engine/DataFeeds/TimeSliceTests.cs b/Tests/Engine/DataFeeds/TimeSliceTests.cs
index 95ef83abccbf..66ac87a81a82 100644
--- a/Tests/Engine/DataFeeds/TimeSliceTests.cs
+++ b/Tests/Engine/DataFeeds/TimeSliceTests.cs
@@ -178,6 +178,37 @@ public void OptionsDataHasVolume()
             }
         }
 
+        [TestCase(SecurityType.Option)]
+        [TestCase(SecurityType.Future)]
+        public void ChainExchangeTimeIsInTheExchangeTimeZone(SecurityType securityType)
+        {
+            var symbol = securityType == SecurityType.Option ? Symbols.SPY_C_192_Feb19_2016 : Symbols.Fut_SPY_Mar19_2016;
+            var config = new SubscriptionDataConfig(typeof(TradeBar), symbol, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, true, true, false);
+            var security = GetSecurity(config);
+            // 15:00 in New York on 2016-02-18 is already 05:00 on 2016-02-19 in Tokyo; the bars end at the slice time
+            var utcTime = new DateTime(2016, 2, 18, 20, 0, 0);
+            var time = utcTime.ConvertFromUtc(TimeZones.NewYork).AddMinutes(-1);
+
+            var packets = new List<DataFeedPacket>();
+            if (security is Option option)
+            {
+                var underlying = option.Underlying;
+                packets.Add(new DataFeedPacket(underlying, underlying.SubscriptionDataConfig,
+                    new List<BaseData> { new TradeBar(time, underlying.Symbol, 100, 100, 110, 106, 100) }));
+            }
+            packets.Add(new DataFeedPacket(security, config, new List<BaseData> { new TradeBar(time, symbol, 100, 100, 110, 106, 100) }));
+
+            var slice = new TimeSliceFactory(TimeZones.Tokyo).Create(utcTime, packets,
+                SecurityChangesTests.CreateNonInternal(Enumerable.Empty<Security>(), Enumerable.Empty<Security>()),
+                new Dictionary<Universe, BaseDataCollection>()).Slice;
+            var (chainTime, exchangeTime) = securityType == SecurityType.Option
+                ? (slice.OptionChains.Values.Single().Time, slice.OptionChains.Values.Single().ExchangeTime)
+                : (slice.FutureChains.Values.Single().Time, slice.FutureChains.Values.Single().ExchangeTime);
+
+            Assert.AreEqual(new DateTime(2016, 2, 19, 5, 0, 0), chainTime);
+            Assert.AreEqual(new DateTime(2016, 2, 18, 15, 0, 0), exchangeTime);
+        }
+
         [Test]
         public void SuspiciousTicksAreNotAddedToConsolidatorUpdateData()
         {
@@ -266,16 +297,16 @@ private Security GetSecurity(SubscriptionDataConfig config)
             if (config.Symbol.SecurityType == SecurityType.Option)
             {
                 var option = new Option(
-                    SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
+                    SecurityExchangeHours.AlwaysOpen(config.ExchangeTimeZone),
                     config,
                     new Cash(Currencies.USD, 0, 1m),
                     new OptionSymbolProperties(SymbolProperties.GetDefault(Currencies.USD)),
                     ErrorCurrencyConverter.Instance,
                     RegisteredSecurityDataTypesProvider.Null);
                 var underlyingConfig = new SubscriptionDataConfig(typeof(TradeBar), config.Symbol.Underlying, Resolution.Second,
-                    TimeZones.Utc, TimeZones.Utc, true, true, false);
+                    config.ExchangeTimeZone, config.ExchangeTimeZone, true, true, false);
                 var equity = new Equity(
-                    SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
+                    SecurityExchangeHours.AlwaysOpen(config.ExchangeTimeZone),
                     underlyingConfig,
                     new Cash(Currencies.USD, 0, 1m),
                     SymbolProperties.GetDefault(Currencies.USD),
@@ -289,7 +320,7 @@ private Security GetSecurity(SubscriptionDataConfig config)
             if (config.Symbol.SecurityType == SecurityType.Future)
             {
                 return new Future(
-                    SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
+                    SecurityExchangeHours.AlwaysOpen(config.ExchangeTimeZone),
                     config,
                     new Cash(Currencies.USD, 0, 1m),
                     SymbolProperties.GetDefault(Currencies.USD),
@@ -298,7 +329,7 @@ private Security GetSecurity(SubscriptionDataConfig config)
             }
 
             return new Security(
-                SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
+                SecurityExchangeHours.AlwaysOpen(config.ExchangeTimeZone),
                 config,
                 new Cash(Currencies.USD, 0, 1m),
                 SymbolProperties.GetDefault(Currencies.USD),