Add support for some CME currencies FOPs (#8939)

* Add support for some CME currencies FOPs

Support ADU (6A), GBU (6B), CAU (6C), EUU (6E), JPU (6J), CHU (6S)

* Cleanup

* Consider holidays in FOPs expiry function

.devcontainer/devcontainer.json

@@ -1,33 +1,43 @@
 {
 	"name": "Lean Development Container",
-
 	"workspaceMount": "source=${localWorkspaceFolder},target=/Lean,type=bind",
 	"workspaceFolder": "/Lean",
-
 	// Use devcontainer Dockerfile that is based on Lean foundation image
-	"build": { "dockerfile": "Dockerfile" },
-	
-	// Set *default* container specific settings.json values on container create.
-	"settings": { 
-		"terminal.integrated.profiles.linux": {
-			"bash": {
-				"path": "bash",
-				"icon": "terminal-bash"
+	"build": {
+		"dockerfile": "Dockerfile"
+	},
+	//See https://containers.dev/implementors/json_reference/ for a comprehensive json schema used to define this file.
+	"customizations": {
+		"vscode": {
+			// Add the IDs of extensions you want installed when the container is created.
+			"extensions": [
+				"ms-dotnettools.csdevkit",
+				"ms-python.python",
+				"eamodio.gitlens",
+				"yzhang.markdown-all-in-one",
+				"SonarSource.sonarlint-vscode"
+			],
+			// Set *default* vscode specific settings.json values on container create.
+			"settings": {
+				"terminal.integrated.profiles.linux": {
+					"bash": {
+						"path": "bash",
+						"icon": "terminal-bash"
+					}
+				}
 			}
 		}
 	},
-
-	// Add the IDs of extensions you want installed when the container is created.
-	"extensions": ["ms-dotnettools.csharp", "ms-python.python", "ms-python.vscode-pylance", "formulahendry.dotnet-test-explorer", "eamodio.gitlens", "yzhang.markdown-all-in-one"],
-
+	//use the same network configuration as the host machine, ensuring no problems with firewalls, proxies etc.
+	"runArgs": [
+		"--network=host"
+	],
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	// "forwardPorts": [],
-
 	// Uncomment the next line to run commands after the container is created - for example installing curl.
 	"postCreateCommand": "dotnet nuget add source /Lean/LocalPackages;chmod u+x /Lean/.vscode/launch_research.sh;dos2unix /Lean/.vscode/launch_research.sh",
-
 	// Add mounts to docker container
-	"mounts": [ 
+	"mounts": [
 		// Example data mount from local machine, must use target directory in Config.json
 		// "source=C:/Users/XXXXXXXXXXXX/Lean/Data,target=/Data,type=bind,consistency=cached" 
 	]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,4 +1,11 @@
-<!--- This template provides sections for bugs and features. Please delete any irrelevant sections before submitting -->
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
 
 #### Expected Behavior
 <!--- Required. Describe the behavior you expect to see for your case. -->
@@ -24,4 +31,4 @@
 <!--- Required for Bugs, feature request can delete the line below. -->
 - [ ] I have provided detailed steps to reproduce the issue
 
-<!--- Template inspired by https://github.com/stevemao/github-issue-templates -->
+<!--- Template inspired by https://github.com/stevemao/github-issue-templates -->

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,26 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+#### Expected Behavior
+<!--- Required. Describe the behavior you expect to see for your case. -->
+
+#### Actual Behavior
+<!--- Required. Describe the actual behavior for your case. -->
+
+#### Potential Solution
+<!--- Optional. Describe any potential solutions and/or thoughts as to what may be causing the difference between expected and actual behavior. -->
+
+#### Checklist
+<!--- Confirm that you've provided all the required information. -->
+<!--- Required fields --->
+- [ ] I have completely filled out this template
+- [ ] I have confirmed that this issue exists on the current `master` branch
+- [ ] I have confirmed that this is not a duplicate issue by searching [issues](https://github.com/QuantConnect/Lean/issues)
+
+<!--- Template inspired by https://github.com/stevemao/github-issue-templates -->

.github/workflows/api-tests.yml

@@ -9,14 +9,19 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     # Only run on push events (not on pull_request) for security reasons in order to be able to use secrets
     if: ${{ github.event_name == 'push' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
       - name: Run API Tests
         uses: addnab/docker-run-action@v3
         with:
@@ -27,4 +32,4 @@ jobs:
             # Build
             dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
             # Run Projects tests
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --blame-hang-timeout 300seconds --blame-crash --filter "FullyQualifiedName=QuantConnect.Tests.API.ProjectTests|ObjectStoreTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --blame-hang-timeout 7minutes --blame-crash --logger "console;verbosity=detailed" --filter "FullyQualifiedName=QuantConnect.Tests.API.ProjectTests|FullyQualifiedName=QuantConnect.Tests.API.ObjectStoreTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)

.github/workflows/gh-actions.yml

@@ -9,12 +9,20 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+        with:
+          fetch-depth: 0  # Ensures we fetch all history
+
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:
@@ -22,9 +30,15 @@ jobs:
           options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w -e GITHUB_REF=${{ github.ref }} -e PYPI_API_TOKEN=${{ secrets.PYPI_API_TOKEN }} -e ADDITIONAL_STUBS_REPOS=${{ secrets.ADDITIONAL_STUBS_REPOS }} -e QC_GIT_TOKEN=${{ secrets.QC_GIT_TOKEN }}
           shell: bash
           run: |
+            # Add exception
+            git config --global --add safe.directory /__w/Lean/Lean
+            # Get Last Commit of the Current Tag
+            TAG_COMMIT=$(git rev-parse HEAD) && echo "CURRENT BRANCH LAST COMMIT $TAG_COMMIT"
+            # Get Last Commit of the master
+            MASTER_COMMIT=$(git rev-parse origin/master) && echo "MASTER BRANCH LAST COMMIT $MASTER_COMMIT"
             # Build
             dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln && \
             # Run Tests
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --blame-hang-timeout 300seconds --blame-crash --filter "TestCategory!=TravisExclude&TestCategory!=ResearchRegressionTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) && \
             # Generate & Publish python stubs
-            echo "GITHUB_REF $GITHUB_REF" && if [[ $GITHUB_REF = refs/tags/* ]]; then (chmod +x ci_build_stubs.sh && ./ci_build_stubs.sh -t -g -p); else echo "Skipping stub generation"; fi
+            echo "GITHUB_REF $GITHUB_REF" && if [[ $GITHUB_REF = refs/tags/* && "$TAG_COMMIT" = "$MASTER_COMMIT" ]]; then echo "Generating stubs" && (chmod +x ci_build_stubs.sh && ./ci_build_stubs.sh -t -g -p); else echo "Skipping stub generation"; fi

.github/workflows/rebase-org-branches.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v2
         with:

.github/workflows/regression-tests.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:

.github/workflows/report-generator.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:

.github/workflows/research-regression-tests.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:
@@ -25,7 +30,7 @@ jobs:
             # install dependencies
             pip3 install papermill==2.4.0 clr-loader==0.1.6
             # install kernel
-            dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.340501
+            dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.607001
             # Add dotnet tools to Path
             export PATH="$HOME/.dotnet/tools:$PATH"
             # activate kernel for jupyter

.github/workflows/syntax-tests.yml

@@ -0,0 +1,32 @@
+name: Syntax Tests
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
+      - name: Run Syntax Test
+        uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w
+          shell: bash
+          run: |
+            pip install --no-cache-dir quantconnect-stubs types-requests==2.32.* types-pytz==2025.2.0.* mypy==1.15.0 && \
+            python run_syntax_check.py

.github/workflows/virtual-environments.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:
@@ -48,10 +53,12 @@ jobs:
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowProbabilityTest" --blame-hang-timeout 120seconds --blame-crash && \
             # Run Hvplot Python Package Test
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.HvplotTest" --blame-hang-timeout 120seconds --blame-crash && \
-            # Run Keras Python Package Test
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.KerasTest" --blame-hang-timeout 120seconds --blame-crash && \
             # Run Transformers
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Transformers" --blame-hang-timeout 120seconds --blame-crash && \
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.XTransformers" --blame-hang-timeout 120seconds --blame-crash && \
             # Run Shap
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ShapTest" --blame-hang-timeout 120seconds --blame-crash
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ShapTest|KerasTest|PyvinecopulibTest" --blame-hang-timeout 120seconds --blame-crash && \
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Mlforecast" --blame-hang-timeout 120seconds --blame-crash && \
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.MlxtendTest|Thinc" --blame-hang-timeout 120seconds --blame-crash && \
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ModuleVersionTestExplicit" --blame-hang-timeout 120seconds --blame-crash && \
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Neuralforecast" --blame-hang-timeout 120seconds --blame-crash

.gitignore

@@ -279,4 +279,5 @@ QuantConnect.Lean.sln.DotSettings*
 Research/Notebooks
 
 #Docker result files
-Results/
+Results/
+QuantConnect.Lean.sln.DotSettings

.vs/readme.md

@@ -12,16 +12,16 @@ This document contains information regarding ways to use Visual Studio to work w
 
 <h2>Option 1: Lean CLI</h2>
 
-To use Lean CLI follow the instructions for installation and tutorial for usage in our [documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli).
+To use Lean CLI follow the instructions for installation and tutorial for usage in our [documentation](https://www.quantconnect.com/docs/v2/lean-cli/key-concepts/getting-started).
 
 <br />
 
 <h2>Option 2: Install Locally</h2>
 
-1. Install [.Net 6](https://dotnet.microsoft.com/download) for the project
+1. Install [.Net 9](https://dotnet.microsoft.com/en-us/download/dotnet/9.0) for the project
 
-2. (Optional) Get [Python 3.8.13](https://www.python.org/downloads/release/python-3813/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-38) for your platform
+2. (Optional) Get [Python 3.11.11](https://www.python.org/downloads/release/python-31111/) for running Python algorithms
+    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-311) for your platform
 
 3. Get [Visual Studio](https://visualstudio.microsoft.com/vs/)
 
@@ -35,7 +35,7 @@ Your environment is prepared and ready to run lean
 
 <h1>How to use Lean</h1>
 
-This section will cover configuring, launching and debugging lean. This is only applicable to option 2 from above. This does not apply to Lean CLI, please refer to [CLI documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli)
+This section will cover configuring, launching and debugging lean. This is only applicable to option 2 from above. This does not apply to Lean CLI, please refer to [CLI documentation](https://www.quantconnect.com/docs/v2/lean-cli/key-concepts/getting-started)
 
 <br />
 

.vscode/readme.md

@@ -51,10 +51,10 @@ If you would like to mount any additional local files to your container, checkou
 
 <h2>Option 3: Install Dependencies Locally</h2>
 
-1. Install [.NET 6](https://dotnet.microsoft.com/en-us/download/dotnet/6.0) for the project
+1. Install [.NET 9](https://dotnet.microsoft.com/en-us/download/dotnet/9.0) for the project
 
-2. (Optional) Get [Python 3.8.13](https://www.python.org/downloads/release/python-3813/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-38) for your platform
+2. (Optional) Get [Python 3.11.11](https://www.python.org/downloads/release/python-31111/) for running Python algorithms
+    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-311) for your platform
 
 3. Get [Visual Studio Code](https://code.visualstudio.com/download)
     - Get the Extension [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) for C# Debugging

Algorithm.CSharp/AccumulativeInsightPortfolioRegressionAlgorithm.cs

@@ -115,6 +115,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$26000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "119.89%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d06c26f557b83d8d42ac808fe2815a1e"}
         };
     }

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -151,6 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$120000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Portfolio Turnover", "41.18%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "713c956deb193bed2290e9f379c0f9f9"}
         };
     }

Algorithm.CSharp/AddAndRemoveOptionContractRegressionAlgorithm.cs

@@ -41,9 +41,11 @@ namespace QuantConnect.Algorithm.CSharp
             var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
 
             _contract = OptionChain(aapl)
-                .OrderBy(x => x.ID.Symbol)
-                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call
-                    && optionContract.ID.OptionStyle == OptionStyle.American);
+                .OrderBy(symbol => symbol.ID.OptionRight)
+                .ThenBy(symbol => symbol.ID.StrikePrice)
+                .ThenBy(symbol => symbol.ID.Date)
+                .ThenBy(symbol => symbol.ID)
+                .FirstOrDefault(optionContract => optionContract.ID.OptionRight == OptionRight.Call);
             AddOptionContract(_contract);
         }
 
@@ -128,6 +130,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AddAndRemoveSecuritySameLoopRegressionAlgorithm.cs

@@ -125,6 +125,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AddBetaIndicatorNewAssetsRegressionAlgorithm.cs

@@ -0,0 +1,152 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); 
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Brokerages;
+
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test to explain how Beta indicator works
+    /// </summary>
+    public class AddBetaIndicatorNewAssetsRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Beta _beta;
+        private SimpleMovingAverage _sma;
+        private decimal _lastSMAValue;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 05, 08);
+            SetEndDate(2017, 06, 15);
+            SetCash(10000);
+
+            AddCrypto("BTCUSD", Resolution.Daily);
+            AddEquity("SPY", Resolution.Daily);
+
+            EnableAutomaticIndicatorWarmUp = true;
+            _beta = B("BTCUSD", "SPY", 3, Resolution.Daily);
+            _sma = SMA("SPY", 3, Resolution.Daily);
+            _lastSMAValue = 0;
+
+            if (!_beta.IsReady)
+            {
+                throw new RegressionTestException("Beta indicator was expected to be ready");
+            }
+        }
+
+        public override void OnData(Slice slice)
+        {
+            var price = Securities["BTCUSD"].Price;
+
+            if (!Portfolio.Invested)
+            {
+                var quantityToBuy = (int)(Portfolio.Cash * 0.05m / price);
+                Buy("BTCUSD", quantityToBuy);
+            }
+
+            if (Math.Abs(_beta.Current.Value) > 2)
+            {
+                Liquidate("BTCUSD");
+                Log("Liquidated BTCUSD due to high Beta");
+            }
+
+            Log($"Beta between BTCUSD and SPY is: {_beta.Current.Value}");
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            var order = Transactions.GetOrderById(orderEvent.OrderId);
+            var goUpwards = _lastSMAValue < _sma.Current.Value;
+            _lastSMAValue = _sma.Current.Value;
+
+            if (order.Status == OrderStatus.Filled)
+            {
+                if (order.Type == OrderType.Limit && Math.Abs(_beta.Current.Value - 1) < 0.2m && goUpwards)
+                {
+                    Transactions.CancelOpenOrders(order.Symbol);
+                }
+            }
+
+            if (order.Status == OrderStatus.Canceled)
+            {
+                Log(orderEvent.ToString());
+            }
+        }
+
+        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 };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 5798;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 77;
+
+        /// <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", "436"},
+            {"Average Win", "0.28%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "1.926%"},
+            {"Drawdown", "1.000%"},
+            {"Expectancy", "1.650"},
+            {"Start Equity", "10000.00"},
+            {"End Equity", "10411.11"},
+            {"Net Profit", "4.111%"},
+            {"Sharpe Ratio", "0.332"},
+            {"Sortino Ratio", "0.313"},
+            {"Probabilistic Sharpe Ratio", "74.084%"},
+            {"Loss Rate", "90%"},
+            {"Win Rate", "10%"},
+            {"Profit-Loss Ratio", "25.26"},
+            {"Alpha", "0.003"},
+            {"Beta", "0.001"},
+            {"Annual Standard Deviation", "0.01"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-0.495"},
+            {"Tracking Error", "0.111"},
+            {"Treynor Ratio", "2.716"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$87000.00"},
+            {"Lowest Capacity Asset", "BTCUSD 2XR"},
+            {"Portfolio Turnover", "2.22%"},
+            {"Drawdown Recovery", "139"},
+            {"OrderListHash", "9fce77ef8817cf0159897fc64d01f5e9"}
+        };
+    }
+}

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -47,7 +47,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             if (!_beta.IsReady)
             {
-                throw new RegressionTestException("_beta indicator was expected to be ready");
+                throw new RegressionTestException("Beta indicator was expected to be ready");
             }
         }
 
@@ -60,7 +60,7 @@ namespace QuantConnect.Algorithm.CSharp
                 LimitOrder("IBM", 10, price * 0.1m);
                 StopMarketOrder("IBM", 10, price / 0.1m);
             }
-            
+
             if (_beta.Current.Value < 0m || _beta.Current.Value > 2.80m)
             {
                 throw new RegressionTestException($"_beta value was expected to be between 0 and 2.80 but was {_beta.Current.Value}");
@@ -145,6 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$35000000.00"},
             {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Portfolio Turnover", "1.51%"},
+            {"Drawdown Recovery", "2"},
             {"OrderListHash", "1db1ce949db995bba20ed96ea5e2438a"}
         };
     }

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -49,7 +49,7 @@ namespace QuantConnect.Algorithm.CSharp
                 contractDepthOffset: 0
             );
 
-            _futureContract = AddFutureContract(FutureChainProvider.GetFutureContractList(_continuousContract.Symbol, Time).First());
+            _futureContract = AddFutureContract(FuturesChain(_continuousContract.Symbol).First());
         }
 
         /// <summary>
@@ -115,12 +115,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 73;
+        public long DataPoints => 61;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 1;
 
         /// <summary>
         /// Final status of the algorithm
@@ -158,7 +158,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$5500000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "66.80%"},
-            {"OrderListHash", "579e2e83dd7e5e7648c47e9eff132460"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "39f1e15c27212d8fdd58aeb7fb2b93cc"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -164,12 +164,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 311879;
+        public long DataPoints => 311881;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 2;
 
         /// <summary>
         /// Final status of the algorithm
@@ -207,6 +207,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$22000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
             {"Portfolio Turnover", "122.11%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d744fa8beaa60546c84924ed68d945d9"}
         };
     }

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -93,12 +93,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 12169;
+        public long DataPoints => 9922;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 2;
 
         /// <summary>
         /// Final status of the algorithm
@@ -113,7 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "20"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "386219349.202%"},
+            {"Compounding Annual Return", "88398927.578%"},
             {"Drawdown", "5.200%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
@@ -136,6 +136,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "ES 31C3JQS9D84PW|ES XCZJLC9NOB29"},
             {"Portfolio Turnover", "495.15%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "85257286f088992d599c1ad0799a6237"}
         };
     }

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -108,7 +108,7 @@ namespace QuantConnect.Algorithm.CSharp
                 return;
             }
 
-            foreach (var chain in slice.OptionChains.Values)
+            foreach (var chain in slice.OptionChains.Values.OrderBy(x => x.Symbol.Underlying.ID.Date))
             {
                 var futureInvested = false;
                 var optionInvested = false;
@@ -220,7 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 608377;
+        public long DataPoints => 319494;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -240,7 +240,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "347.065%"},
+            {"Compounding Annual Return", "309.669%"},
             {"Drawdown", "0.900%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
@@ -263,6 +263,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$760000.00"},
             {"Lowest Capacity Asset", "ES XCZJLDQX2SRO|ES XCZJLC9NOB29"},
             {"Portfolio Turnover", "32.31%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "7a04f66a30d793bf187c2695781ad3ee"}
         };
     }

Algorithm.CSharp/AddFutureUniverseSelectionModelRegressionAlgorithm.cs

@@ -0,0 +1,131 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Interfaces;
+using System;
+using QuantConnect.Securities;
+using QuantConnect.Data.UniverseSelection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to use the FutureUniverseSelectionModel to select futures contracts for a given underlying asset.
+    /// The model is set to update daily, and the algorithm ensures that the selected contracts meet specific criteria.
+    /// This also includes a check to ensure that only future contracts are added to the algorithm's universe.
+    /// </summary>
+    public class AddFutureUniverseSelectionModelRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 10, 10);
+
+            SetUniverseSelection(new FutureUniverseSelectionModel(
+                TimeSpan.FromDays(1),
+                time => new List<Symbol> {
+                    QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME)
+                }
+            ));
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (changes.AddedSecurities.Count > 0)
+            {
+                foreach (var security in changes.AddedSecurities)
+                {
+                    if (security.Symbol.SecurityType != SecurityType.Future)
+                    {
+                        throw new RegressionTestException($"Expected future security, but found '{security.Symbol.SecurityType}'");
+                    }
+                    if (security.Symbol.ID.Symbol != "ES")
+                    {
+                        throw new RegressionTestException($"Expected future symbol 'ES', but found '{security.Symbol.ID.Symbol}");
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (ActiveSecurities.Count == 0)
+            {
+                throw new RegressionTestException("No active securities found. Expected at least one active security");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 26094;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-66.775"},
+            {"Tracking Error", "0.243"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -160,7 +160,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$5700000.00"},
             {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
             {"Portfolio Turnover", "0.55%"},
-            {"OrderListHash", "24191a4a3bf11c07622a21266618193d"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "fc5ab25181a01ca5ce39212f60eb0ecd"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -117,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
                                                       && optionContract.ID.OptionStyle == OptionStyle.American);
                 AddOptionContract(option);
 
-                foreach (var symbol in new[] { option.Symbol, option.Underlying.Symbol })
+                foreach (var symbol in new[] { option.Symbol, option.UnderlyingSymbol })
                 {
                     var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
 
@@ -212,7 +212,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$2800000.00"},
             {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
             {"Portfolio Turnover", "1.14%"},
-            {"OrderListHash", "cde7b518b7ad6d86cff6e5e092d9a413"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "90aa4bf345a6ba5ea2b0b14e32d1598f"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractTwiceRegressionAlgorithm.cs

@@ -159,6 +159,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$5000000.00"},
             {"Lowest Capacity Asset", "AAPL VXBK4R62CXGM|AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "22.70%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "29fd1b75f6db05dd823a6db7e8bd90a9"}
         };
     }

Algorithm.CSharp/AddOptionUniverseSelectionModelRegressionAlgorithm.cs

@@ -0,0 +1,146 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Interfaces;
+using System;
+using QuantConnect.Data.UniverseSelection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to use the OptionUniverseSelectionModel to select options contracts based on specified conditions.
+    /// The model is updated daily and selects different options based on the current date.
+    /// The algorithm ensures that only valid option contracts are selected for the universe.
+    /// </summary>
+    public class AddOptionUniverseSelectionModelRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private int _optionCount;
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 05);
+            SetEndDate(2014, 06, 06);
+
+            UniverseSettings.Resolution = Resolution.Minute;
+            SetUniverseSelection(new OptionUniverseSelectionModel(
+                TimeSpan.FromDays(1),
+                SelectOptionChainSymbols
+            ));
+        }
+
+        private static IEnumerable<Symbol> SelectOptionChainSymbols(DateTime utcTime)
+        {
+            var newYorkTime = utcTime.ConvertFromUtc(TimeZones.NewYork);
+            if (newYorkTime.Date < new DateTime(2014, 06, 06))
+            {
+                yield return QuantConnect.Symbol.Create("TWX", SecurityType.Option, Market.USA);
+            }
+
+            if (newYorkTime.Date >= new DateTime(2014, 06, 06))
+            {
+                yield return QuantConnect.Symbol.Create("AAPL", SecurityType.Option, Market.USA);
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (changes.AddedSecurities.Count > 0)
+            {
+                foreach (var security in changes.AddedSecurities)
+                {
+                    var symbol = security.Symbol.Underlying == null ? security.Symbol : security.Symbol.Underlying;
+                    if (symbol != "AAPL" && symbol != "TWX")
+                    {
+                        throw new RegressionTestException($"Unexpected security {security.Symbol}");
+                    }
+                    _optionCount += (security.Symbol.SecurityType == SecurityType.Option) ? 1 : 0;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (ActiveSecurities.Count == 0)
+            {
+                throw new RegressionTestException("No active securities found. Expected at least one active security");
+            }
+            if (_optionCount == 0)
+            {
+                throw new RegressionTestException("The option count should be greater than 0");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1658167;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/AddOptionWithOnMarketOpenOnlyFilterRegressionAlgorithm.cs

@@ -120,6 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AddRemoveOptionUniverseRegressionAlgorithm.cs

@@ -248,7 +248,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$4000.00"},
             {"Lowest Capacity Asset", "GOOCV 305RBQ2BZBZT2|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "2.58%"},
-            {"OrderListHash", "09f766c470a8bcf4bb6862da52bf25a7"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "12037c87de17d6e62eadd99c70a0685e"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityCacheRegressionAlgorithm.cs

@@ -59,7 +59,7 @@ namespace QuantConnect.Algorithm.CSharp
 
                 var ticket = MarketOrder("AIG", 1);
 
-                if (ticket.Status != OrderStatus.Invalid)
+                if (ticket.Status != OrderStatus.Invalid || aig.HasData || aig.Price != 0)
                 {
                     throw new RegressionTestException("Expected order to always be invalid because there is no data yet!");
                 }
@@ -126,6 +126,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$830000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "20.49%"},
+            {"Drawdown Recovery", "2"},
             {"OrderListHash", "6ebe462373e2ecc22de8eb2fe114d704"}
         };
     }

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -153,7 +153,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$4700000.00"},
             {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Portfolio Turnover", "29.88%"},
-            {"OrderListHash", "6061ecfbb89eb365dff913410d279b7c"}
+            {"Drawdown Recovery", "2"},
+            {"OrderListHash", "f04b3521256c7d6740966bc3df34e7b1"}
         };
     }
 }

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -105,6 +105,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$38000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "59.74%"},
+            {"Drawdown Recovery", "3"},
             {"OrderListHash", "5d7657ec9954875eca633bed711085d3"}
         };
     }

Algorithm.CSharp/AddTwoAndRemoveOneOptionContractRegressionAlgorithm.cs

@@ -144,6 +144,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$6200000.00"},
             {"Lowest Capacity Asset", "AAPL VXBK4QA5EM92|AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "90.27%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "a111609c2c64554268539b5798e5b31f"}
         };
     }

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -124,6 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$980000000.00"},
             {"Lowest Capacity Asset", "FB V6OIPNZEM8V9"},
             {"Portfolio Turnover", "25.56%"},
+            {"Drawdown Recovery", "1"},
             {"OrderListHash", "5ee20c8556d706ab0a63ae41b6579c62"}
         };
     }

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -135,6 +135,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$680000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "7.48%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "2c814c55e7d7c56482411c065b861b33"}
         };
     }

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -199,6 +199,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$42000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "99.56%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "60f03c8c589a4f814dc4e8945df23207"}
         };
     }

Algorithm.CSharp/AlgorithmModeAndDeploymentTargetAlgorithm.cs

@@ -113,6 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -281,6 +281,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$61000000000.00"},
             {"Lowest Capacity Asset", "NB R735QTJ8XC9X"},
             {"Portfolio Turnover", "3.62%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "0ea806c53bfa2bdca2504ba7155ef130"}
         };
     }

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -119,6 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$16000000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "0.02%"},
+            {"Drawdown Recovery", "50"},
             {"OrderListHash", "685c37df6e4c49b75792c133be189094"}
         };
     }

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2013, 10, 10);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
-            _symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
+            _symbol = FuturesChain(SP500).First();
 
             // Test case: custom IndicatorBase<QuoteBar> indicator using Future unsubscribed symbol
             var indicator1 = new CustomIndicator();
@@ -151,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 84;
+        public int AlgorithmHistoryDataPoints => 85;
 
         /// <summary>
         /// Final status of the algorithm
@@ -189,6 +189,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "351.80%"},
+            {"Drawdown Recovery", "1"},
             {"OrderListHash", "dfd9a280d3c6470b305c03e0b72c234e"}
         };
     }

Algorithm.CSharp/AutomaticIndicatorWarmupOptionIndicatorsMirrorContractsRegressionAlgorithm.cs

@@ -82,7 +82,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 21;
+        public int AlgorithmHistoryDataPoints => 18;
 
         /// <summary>
         /// Final status of the algorithm
@@ -120,6 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/AutomaticIndicatorWarmupRegressionAlgorithm.cs

@@ -151,6 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$56000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "19.93%"},
+            {"Drawdown Recovery", "3"},
             {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
         };
     }

Algorithm.CSharp/AuxiliaryDataHandlersRegressionAlgorithm.cs

@@ -162,6 +162,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -339,7 +339,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "17.02%"},
-            {"OrderListHash", "b1e5e72fb766ab894204bc4b1300912b"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "a7ce5ff2bbe0fe273cf1631ea5a73fa6"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -115,6 +115,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "€85000.00"},
             {"Lowest Capacity Asset", "BTCEUR 2XR"},
             {"Portfolio Turnover", "107.64%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "6819dc936b86af6e4b89b6017b7d5284"}
         };
     }

Algorithm.CSharp/BasicSetAccountCurrencyWithAmountAlgorithm.cs

@@ -85,6 +85,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "€85000.00"},
             {"Lowest Capacity Asset", "BTCEUR 2XR"},
             {"Portfolio Turnover", "107.64%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "3d450fd418a0e845b3eaaac17fcd13fc"}
         };
     }

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -118,6 +118,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$56000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "19.93%"},
+            {"Drawdown Recovery", "3"},
             {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
         };
     }

Algorithm.CSharp/BasicTemplateAxosAlgorithm.cs

@@ -112,6 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$150000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "4.98%"},
+            {"Drawdown Recovery", "3"},
             {"OrderListHash", "8774049eb5141a2b6956d9432426f837"}
         };
     }

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -123,7 +123,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 2217299;
+        public long DataPoints => 504530;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -166,7 +166,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$890000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "2.32%"},
-            {"OrderListHash", "f60fc7dcba2c1ff077afeb191aee5008"}
+            {"Drawdown Recovery", "34"},
+            {"OrderListHash", "1504a8892da8d8c0650018732f315753"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -167,11 +167,7 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     if (Portfolio.CashBook["LTC"].Amount > 0)
                     {
-                        // The following two statements currently behave differently if we have initial holdings:
-                        // https://github.com/QuantConnect/Lean/issues/1860
-
                         Liquidate("LTCUSD");
-                        // SetHoldings("LTCUSD", 0);
                     }
                 }
             }
@@ -244,6 +240,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTCEUR 2XR"},
             {"Portfolio Turnover", "118.08%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "26b9a07ace86b6a0e0eb2ff8c168cee0"}
         };
     }

Algorithm.CSharp/BasicTemplateCryptoFutureAlgorithm.cs

@@ -276,6 +276,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$500000000.00"},
             {"Lowest Capacity Asset", "ADAUSDT 18R"},
             {"Portfolio Turnover", "0.16%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "dcc4f964b5549c753123848c32eaee41"}
         };
     }

Algorithm.CSharp/BasicTemplateCryptoFutureHourlyAlgorithm.cs

@@ -239,6 +239,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$370000000.00"},
             {"Lowest Capacity Asset", "ADAUSDT 18R"},
             {"Portfolio Turnover", "0.12%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "50a51d06d03a5355248a6bccef1ca521"}
         };
     }

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -109,6 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$1200000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "10.01%"},
+            {"Drawdown Recovery", "1"},
             {"OrderListHash", "70f21e930175a2ec9d465b21edc1b6d9"}
         };
     }

Algorithm.CSharp/BasicTemplateEurexFuturesAlgorithm.cs

@@ -56,7 +56,7 @@ namespace QuantConnect.Algorithm.CSharp
             _continuousContract.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(180));
             _mappedSymbol = _continuousContract.Mapped;
 
-            var benchmark = AddIndex("SX5E", market: Market.EUREX);
+            var benchmark = AddIndex("SX5E");
             SetBenchmark(benchmark.Symbol);
 
             var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
@@ -190,12 +190,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 133945;
+        public long DataPoints => 94326;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 26;
+        public int AlgorithmHistoryDataPoints => 0;
 
         /// <summary>
         /// Final status of the algorithm
@@ -233,7 +233,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "€2300000000.00"},
             {"Lowest Capacity Asset", "FESX YJHOAMPYKRS5"},
             {"Portfolio Turnover", "0.40%"},
-            {"OrderListHash", "54040d29a467becaedcf59d79323321b"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "ac9acc478ba1afe53993cdbb92f8ec6e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFrameworkAlgorithm.cs

@@ -130,6 +130,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$27000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "59.86%"},
+            {"Drawdown Recovery", "3"},
             {"OrderListHash", "f209ed42701b0419858e0100595b40c0"}
         };
     }

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -176,7 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1190;
+        public long DataPoints => 727;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -219,7 +219,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "0.13%"},
-            {"OrderListHash", "273dd05b937c075b75baf8af46d3c7de"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "a6ccce3a1a7f549f887d83e84bfa878d"}
         };
-    }  
+    }
 }

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -149,7 +149,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 75403;
+        public long DataPoints => 40308;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -169,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "2700"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-99.777%"},
+            {"Compounding Annual Return", "-99.597%"},
             {"Drawdown", "4.400%"},
             {"Expectancy", "-0.724"},
             {"Start Equity", "1000000"},
@@ -192,6 +192,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$14000.00"},
             {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
             {"Portfolio Turnover", "9912.69%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "6e0f767a46a54365287801295cf7bb75"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -18,8 +18,8 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
-using QuantConnect.Orders;
 using QuantConnect.Securities;
 using QuantConnect.Securities.Future;
 
@@ -104,6 +104,16 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
 
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (changes.RemovedSecurities.Count > 0 &&
+                Portfolio.Invested &&
+                Securities.Values.Where(x => x.Invested).All(x => x.Exchange.Hours.IsOpen(Time, true)))
+            {
+                Liquidate();
+            }
+        }
+
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>
@@ -117,7 +127,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 12452;
+        public virtual long DataPoints => 5861;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -134,33 +144,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "32"},
+            {"Total Orders", "34"},
             {"Average Win", "0.33%"},
             {"Average Loss", "-0.04%"},
-            {"Compounding Annual Return", "0.110%"},
+            {"Compounding Annual Return", "0.106%"},
             {"Drawdown", "0.300%"},
-            {"Expectancy", "0.184"},
+            {"Expectancy", "0.178"},
             {"Start Equity", "1000000"},
-            {"End Equity", "1001108"},
-            {"Net Profit", "0.111%"},
-            {"Sharpe Ratio", "-1.688"},
-            {"Sortino Ratio", "-0.772"},
-            {"Probabilistic Sharpe Ratio", "14.944%"},
+            {"End Equity", "1001066.2"},
+            {"Net Profit", "0.107%"},
+            {"Sharpe Ratio", "-1.695"},
+            {"Sortino Ratio", "-0.804"},
+            {"Probabilistic Sharpe Ratio", "14.797%"},
             {"Loss Rate", "88%"},
             {"Win Rate", "12%"},
-            {"Profit-Loss Ratio", "8.47"},
+            {"Profit-Loss Ratio", "9.01"},
             {"Alpha", "-0.007"},
             {"Beta", "0.002"},
             {"Annual Standard Deviation", "0.004"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.353"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "-4.099"},
-            {"Total Fees", "$72.00"},
+            {"Treynor Ratio", "-4.112"},
+            {"Total Fees", "$76.30"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Portfolio Turnover", "0.87%"},
-            {"OrderListHash", "168731c8f3a19f230cc1410818b3b573"}
+            {"Portfolio Turnover", "0.92%"},
+            {"Drawdown Recovery", "69"},
+            {"OrderListHash", "ddaa9dd20647fdbc4811d6e64bb30a40"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -136,7 +136,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 57759;
+        public virtual long DataPoints => 24883;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -179,6 +179,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$17000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
             {"Portfolio Turnover", "43.23%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "c0fc1bcdc3008a8d263521bbc9d7cdbd"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 163415;
+        public override long DataPoints => 70262;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -74,6 +74,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$52000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
             {"Portfolio Turnover", "43.77%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "dcdaafcefa47465962ace2759ed99c91"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -140,12 +140,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 48690;
+        public virtual long DataPoints => 25316;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public virtual int AlgorithmHistoryDataPoints => 5305;
+        public virtual int AlgorithmHistoryDataPoints => 6075;
 
         /// <summary>
         /// Final status of the algorithm
@@ -183,6 +183,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm.cs

@@ -47,7 +47,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 147771;
+        public override long DataPoints => 76063;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -90,6 +90,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketAlgorithm.cs

@@ -149,7 +149,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 224662;
+        public long DataPoints => 117079;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -192,6 +192,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$130000.00"},
             {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
             {"Portfolio Turnover", "32523.20%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "0664a72652a19956ea3c4915269cc4b9"}
         };
     }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -14,14 +14,7 @@
  *
 */
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -43,40 +36,41 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 14790;
+        public override long DataPoints => 5965;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "36"},
+            {"Total Orders", "32"},
             {"Average Win", "0.33%"},
-            {"Average Loss", "-0.03%"},
-            {"Compounding Annual Return", "0.102%"},
+            {"Average Loss", "-0.04%"},
+            {"Compounding Annual Return", "0.110%"},
             {"Drawdown", "0.300%"},
-            {"Expectancy", "0.171"},
+            {"Expectancy", "0.184"},
             {"Start Equity", "1000000"},
-            {"End Equity", "1001024.4"},
-            {"Net Profit", "0.102%"},
-            {"Sharpe Ratio", "-1.702"},
-            {"Sortino Ratio", "-0.836"},
-            {"Probabilistic Sharpe Ratio", "14.653%"},
-            {"Loss Rate", "89%"},
-            {"Win Rate", "11%"},
-            {"Profit-Loss Ratio", "9.54"},
+            {"End Equity", "1001108"},
+            {"Net Profit", "0.111%"},
+            {"Sharpe Ratio", "-1.688"},
+            {"Sortino Ratio", "-0.772"},
+            {"Probabilistic Sharpe Ratio", "14.944%"},
+            {"Loss Rate", "88%"},
+            {"Win Rate", "12%"},
+            {"Profit-Loss Ratio", "8.47"},
             {"Alpha", "-0.007"},
             {"Beta", "0.002"},
             {"Annual Standard Deviation", "0.004"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.353"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "-4.126"},
-            {"Total Fees", "$80.60"},
+            {"Treynor Ratio", "-4.099"},
+            {"Total Fees", "$72.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Portfolio Turnover", "0.97%"},
-            {"OrderListHash", "52c852d720692fab1e12212b2aba03d4"}
+            {"Portfolio Turnover", "0.87%"},
+            {"Drawdown Recovery", "69"},
+            {"OrderListHash", "741a26424d2210171ad849d92fc75d23"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 228834;
+        public override long DataPoints => 67924;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -74,7 +74,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
             {"Portfolio Turnover", "56.73%"},
-            {"OrderListHash", "424536177e9be5895bab50638ef43a9d"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "6ce7812de5c98744cc35169a86a24325"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateHourlyAlgorithm.cs

@@ -118,7 +118,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$110000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Portfolio Turnover", "19.96%"},
-            {"OrderListHash", "966f8355817adbc8c724d1062691a60b"}
+            {"Drawdown Recovery", "2"},
+            {"OrderListHash", "60747dce5c2aed393b7dccc258d2c9b5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -170,6 +170,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
             {"Portfolio Turnover", "23.97%"},
+            {"Drawdown Recovery", "9"},
             {"OrderListHash", "51f1bc2ea080df79748dc66c2520b782"}
         };
     }

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -70,7 +70,7 @@ namespace QuantConnect.Algorithm.CSharp
             }
 
             var openInterest = Securities[SpxOption].Cache.GetAll<OpenInterest>();
-            if (openInterest.Single().EndTime != new DateTime(2021, 1, 15, 23, 0, 0))
+            if (openInterest.Single().EndTime != new DateTime(2021, 1, 15, 15, 15, 0))
             {
                 throw new ArgumentException($"Unexpected open interest time: {openInterest.Single().EndTime}");
             }
@@ -106,7 +106,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 121;
+        public override long DataPoints => 122;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -126,7 +126,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "11"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "621.484%"},
+            {"Compounding Annual Return", "653.545%"},
             {"Drawdown", "0%"},
             {"Expectancy", "0"},
             {"Start Equity", "1000000"},
@@ -149,6 +149,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
             {"Portfolio Turnover", "2.42%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "61e8517ac3da6bed414ef23d26736fef"}
         };
     }

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -66,7 +66,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$300000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
             {"Portfolio Turnover", "24.63%"},
-            {"OrderListHash", "44325fc1fdebb8e54f64a3f6e8a4bcd7"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "5595ab834c2584c1d124ad575e88cc1a"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -67,7 +67,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 356;
+        public override long DataPoints => 360;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -110,7 +110,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
             {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "285cec32c0947f0e8cf90ccb672cfa43"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "8340619d603921c1ce261287890b9c1c"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -81,7 +81,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
             {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "75e6584cb26058b09720c3a828b9fbda"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "1c5f424cfe62777733ee68a20320bb8d"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndiaAlgorithm.cs

@@ -128,7 +128,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₹61000000000.00"},
             {"Lowest Capacity Asset", "YESBANK UL"},
             {"Portfolio Turnover", "0.00%"},
-            {"OrderListHash", "7a0257f08e3bb9143b825e07ab47fea0"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "06f782c83dd633dac6f228b91273ba26"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndiaIndexAlgorithm.cs

@@ -152,7 +152,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₹84000.00"},
             {"Lowest Capacity Asset", "JUNIORBEES UL"},
             {"Portfolio Turnover", "0.04%"},
-            {"OrderListHash", "79ab9ec506959c562be8b3cdbb174c39"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "8790bec8175539e6d92e01608ac57733"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionEquityStrategyAlgorithm.cs

@@ -145,6 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$69000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "61.31%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "35d406df401e5b27244e20f5ec57346e"}
         };
     }

Algorithm.CSharp/BasicTemplateOptionStrategyAlgorithm.cs

@@ -155,6 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$4000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "338.60%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "301c15063f6e269023d144ca69a765da"}
         };
     }

Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs

@@ -152,6 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$1300000.00"},
             {"Lowest Capacity Asset", "GOOCV 30AKMEIPOSS1Y|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "10.71%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "8a36462ee0349c04d01d464e592dd347"}
         };
     }

Algorithm.CSharp/BasicTemplateOptionsConsolidationAlgorithm.cs

@@ -145,6 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", ""},
             {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }

Algorithm.CSharp/BasicTemplateOptionsDailyAlgorithm.cs

@@ -165,7 +165,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$72000.00"},
             {"Lowest Capacity Asset", "AAPL W78ZEO2985GM|AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "0.02%"},
-            {"OrderListHash", "b3125e0af79da0f5eea4cfda09806324"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "5e20fad3461ac9998afe8d76ad43b25c"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -142,7 +142,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "15.08%"},
-            {"OrderListHash", "db6a1134ad325bce31c2bdd2e87ff5f4"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "f68f6d64a5721ee148bc3c643f8d1b7f"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -182,7 +182,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "13.50%"},
-            {"OrderListHash", "cf14a7ce9c86e6844051820fd4c9394c"}
+            {"Drawdown Recovery", "2"},
+            {"OrderListHash", "d40c84371facba5dac8a2c919ea75807"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsHourlyAlgorithm.cs

@@ -152,6 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$1000.00"},
             {"Lowest Capacity Asset", "AAPL 2ZTXYMUAHCIAU|AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "2.28%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "7804b3dcf20d3096a2265a289fa81cd3"}
         };
     }

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsAlgorithm.cs

@@ -121,20 +121,20 @@ namespace QuantConnect.Algorithm.CSharp
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Orders", "5"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.69%"},
+            {"Average Win", "0.63%"},
+            {"Average Loss", "-0.03%"},
             {"Compounding Annual Return", "54.478%"},
             {"Drawdown", "0.400%"},
-            {"Expectancy", "-0.5"},
+            {"Expectancy", "23.219"},
             {"Start Equity", "1000000"},
             {"End Equity", "1006025"},
             {"Net Profit", "0.602%"},
             {"Sharpe Ratio", "2.62"},
             {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "63.221%"},
-            {"Loss Rate", "50%"},
-            {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "0"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "23.22"},
             {"Alpha", "0.067"},
             {"Beta", "-0.013"},
             {"Annual Standard Deviation", "0.004"},
@@ -146,7 +146,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$580000.00"},
             {"Lowest Capacity Asset", "SPXW 31K54PVWHUJHQ|SPX 31"},
             {"Portfolio Turnover", "0.40%"},
-            {"OrderListHash", "07a085baedb37bb7c8d460558ea77e88"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "db5e3681c5fa1888262f2370a9b14c11"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsStrategyAlgorithm.cs

@@ -127,11 +127,11 @@ namespace QuantConnect.Algorithm.CSharp
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Orders", "10"},
-            {"Average Win", "0.47%"},
+            {"Average Win", "0.46%"},
             {"Average Loss", "-0.01%"},
             {"Compounding Annual Return", "101.998%"},
             {"Drawdown", "0.100%"},
-            {"Expectancy", "24.484"},
+            {"Expectancy", "24.137"},
             {"Start Equity", "1000000"},
             {"End Equity", "1009050"},
             {"Net Profit", "0.905%"},
@@ -140,7 +140,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Probabilistic Sharpe Ratio", "95.546%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "49.97"},
+            {"Profit-Loss Ratio", "49.27"},
             {"Alpha", "-2.01"},
             {"Beta", "0.307"},
             {"Annual Standard Deviation", "0.021"},
@@ -152,7 +152,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$13000000.00"},
             {"Lowest Capacity Asset", "SPXW XKX6S2GM9PGU|SPX 31"},
             {"Portfolio Turnover", "0.28%"},
-            {"OrderListHash", "c1a9bc141ae25c9542b93a887e79dafe"}
+            {"Drawdown Recovery", "2"},
+            {"OrderListHash", "17764ae9e216d003b1f3ce68d15b68ef"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateTradableIndexAlgorithm.cs

@@ -89,6 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
             {"Portfolio Turnover", "24.03%"},
+            {"Drawdown Recovery", "9"},
             {"OrderListHash", "fcd6fddb0a315e21095c2b35eb633e2b"}
         };
     }

Algorithm.CSharp/BinanceCashAccountFeeRegressionAlgorithm.cs

@@ -84,6 +84,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₮220000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 18N"},
             {"Portfolio Turnover", "22.80%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "80711e4c1e3c0da20152da8fafc3fd66"}
         };
     }

Algorithm.CSharp/BinanceMarginAccountFeeRegressionAlgorithm.cs

@@ -84,6 +84,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₮12000000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 18N"},
             {"Portfolio Turnover", "22.80%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "80711e4c1e3c0da20152da8fafc3fd66"}
         };
     }

Algorithm.CSharp/BitfinexCashAccountFeeRegressionAlgorithm.cs

@@ -83,6 +83,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$2000.00"},
             {"Lowest Capacity Asset", "BTCUSD E3"},
             {"Portfolio Turnover", "0.28%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "899ef4e299a6cc73c1bd96fb9993db0e"}
         };
     }

Algorithm.CSharp/BitfinexMarginAccountFeeRegressionAlgorithm.cs

@@ -83,6 +83,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$640000.00"},
             {"Lowest Capacity Asset", "BTCUSD E3"},
             {"Portfolio Turnover", "0.28%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "899ef4e299a6cc73c1bd96fb9993db0e"}
         };
     }

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -119,6 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Portfolio Turnover", "69.06%"},
+            {"Drawdown Recovery", "2"},
             {"OrderListHash", "44a85134cd1c91c9720549bc0e007f80"}
         };
     }

Algorithm.CSharp/BybitCryptoFuturesRegressionAlgorithm.cs

@@ -264,6 +264,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 2V3"},
             {"Portfolio Turnover", "1.08%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "0157a5c7c2c8a8c13e984b72721aa0ca"}
         };
     }

Algorithm.CSharp/BybitCryptoRegressionAlgorithm.cs

@@ -154,7 +154,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0%"},
             {"Expectancy", "0"},
             {"Start Equity", "117171.12"},
-            {"End Equity", "117244.50"},
+            {"End Equity", "117244.52"},
             {"Net Profit", "0%"},
             {"Sharpe Ratio", "0"},
             {"Sortino Ratio", "0"},
@@ -173,7 +173,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₮560000.00"},
             {"Lowest Capacity Asset", "BTCUSDT 2UZ"},
             {"Portfolio Turnover", "44.04%"},
-            {"OrderListHash", "7426da82dca9e493acbc53c7b9f449f0"}
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "47580e88a8cc54b04f3b2bcb5d501150"}
         };
     }
 }

Algorithm.CSharp/BybitCustomDataCryptoRegressionAlgorithm.cs

@@ -185,6 +185,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "₮0"},
             {"Lowest Capacity Asset", "BTCUSDT.CustomCryptoData 2US"},
             {"Portfolio Turnover", "34.30%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "52ddb7dfcaaf1ea4f70cc614c49f0cd0"}
         };
     }

Algorithm.CSharp/CallbackCommandRegressionAlgorithm.cs

@@ -0,0 +1,167 @@
+/*
+ * 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 QuantConnect.Commands;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting the behavior of different callback commands call
+    /// </summary>
+    public class CallbackCommandRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+
+            AddEquity("SPY");
+            AddEquity("BAC");
+            AddEquity("IBM");
+            AddCommand<BoolCommand>();
+            AddCommand<VoidCommand>();
+
+            var potentialCommand = new VoidCommand
+            {
+                Target = new[] { "BAC" },
+                Quantity = 10,
+                Parameters = new() { { "tag", "Signal X" } }
+            };
+            var commandLink = Link(potentialCommand);
+            Notify.Email("email@address", "Trade Command Event", $"Signal X trade\nFollow link to trigger: {commandLink}");
+
+            var commandLink2 = Link(new { Symbol = "SPY", Parameters = new Dictionary<string, int>() { { "Quantity", 10 } } });
+            Notify.Email("email@address", "Untyped Command Event", $"Signal Y trade\nFollow link to trigger: {commandLink2}");
+
+            // We need to create a project on QuantConnect to test the BroadcastCommand method
+            // and use the ProjectId in the BroadcastCommand call
+            ProjectId = 21805137;
+
+            // All live deployments receive the broadcasts below
+            var broadcastResult = BroadcastCommand(potentialCommand);
+            var broadcastResult2 = BroadcastCommand(new { Symbol = "SPY", Parameters = new Dictionary<string, int>() { { "Quantity", 10 } } });
+        }
+
+        /// <summary>
+        /// Handle generic command callback
+        /// </summary>
+        public override bool? OnCommand(dynamic data)
+        {
+            Buy(data.Symbol, data.parameters["quantity"]);
+            return true;
+        }
+
+        private class VoidCommand : Command
+        {
+            public DateTime TargetTime { get; set; }
+            public string[] Target { get; set; }
+            public decimal Quantity { get; set; }
+            public Dictionary<string, string> Parameters { get; set; }
+            public override bool? Run(IAlgorithm algorithm)
+            {
+                if (TargetTime != algorithm.Time)
+                {
+                    return null;
+                }
+
+                ((QCAlgorithm)algorithm).Order(Target[0], Quantity, tag: Parameters["tag"]);
+                return null;
+            }
+        }
+        private class BoolCommand : Command
+        {
+            public bool? Result { get; set; }
+            public override bool? Run(IAlgorithm algorithm)
+            {
+                var shouldTrade = MyCustomMethod();
+                if (shouldTrade.HasValue && shouldTrade.Value)
+                {
+                    ((QCAlgorithm)algorithm).Buy("IBM", 1);
+                }
+                return shouldTrade;
+            }
+
+            private bool? MyCustomMethod()
+            {
+                return Result;
+            }
+        }
+
+        /// <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; }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 3943;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "271.453%"},
+            {"Drawdown", "2.200%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "101691.92"},
+            {"Net Profit", "1.692%"},
+            {"Sharpe Ratio", "8.854"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.005"},
+            {"Beta", "0.996"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-14.565"},
+            {"Tracking Error", "0.001"},
+            {"Treynor Ratio", "1.97"},
+            {"Total Fees", "$3.44"},
+            {"Estimated Strategy Capacity", "$56000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Portfolio Turnover", "19.93%"},
+            {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
+        };
+    }
+}

Algorithm.CSharp/CanLiquidateWithOrderPropertiesRegressionAlgorithm.cs

@@ -117,6 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$130000000.00"},
             {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Portfolio Turnover", "37.56%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "e9e8a07dc58bff7198181f9fafb58834"}
         };
     }

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -168,6 +168,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$370000.00"},
             {"Lowest Capacity Asset", "ETHUSD 2XR"},
             {"Portfolio Turnover", "104.59%"},
+            {"Drawdown Recovery", "0"},
             {"OrderListHash", "5277847166fcd10cde634e3986e1d285"}
         };
     }