Modify advance decline indicators (#7032)

* Apply splits to TradeBuilder

* Minor tests changes

* Minor changes

* Add regression algorithm

.devcontainer/Dockerfile

@@ -0,0 +1,8 @@
+# Use QuantConnect Research as the base
+FROM quantconnect/research:latest
+
+# Install dos2unix utility for converting pesky windows formatting when needed
+RUN apt-get update && apt-get install -y dos2unix
+
+# Install QuantConnect Stubs for Python Autocomplete
+RUN pip install --no-cache-dir quantconnect-stubs

.devcontainer/devcontainer.json

@@ -0,0 +1,34 @@
+{
+	"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"
+			}
+		}
+	},
+
+	// 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 '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; dos2unix /Lean/.vscode/launch_research.sh",
+
+	// Add mounts to docker container
+	"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/workflows/benchmarks.yml

@@ -0,0 +1,39 @@
+name: Benchmarks
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: self-hosted
+    container:
+        image: quantconnect/lean:foundation
+        volumes:
+          - /nas:/Data
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Checkout Lean Master
+        uses: actions/checkout@v2
+        with:
+          repository: QuantConnect/Lean
+          path: LeanMaster
+          ref: 'master'
+      - name: Build Lean Master
+        run: dotnet build --verbosity q /p:Configuration=Release /p:WarningLevel=1 LeanMaster/QuantConnect.Lean.sln
+
+      - name: Run Benchmarks Master
+        run: cp run_benchmarks.py LeanMaster/run_benchmarks.py && cd LeanMaster && python run_benchmarks.py /Data && cd ../
+
+      - name: Build
+        run: dotnet build --verbosity q /p:Configuration=Release /p:WarningLevel=1 QuantConnect.Lean.sln
+
+      - name: Run Benchmarks
+        run: python run_benchmarks.py /Data
+
+      - name: Compare Benchmarks
+        run: python compare_benchmarks.py LeanMaster/benchmark_results.json benchmark_results.json

.github/workflows/gh-actions.yml

@@ -19,7 +19,7 @@ jobs:
         run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
 
       - name: Run Tests
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "TestCategory!=TravisExclude&TestCategory!=ResearchRegressionTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
+        run: 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\"\)
 
       - name: Generate & Publish python stubs
         if: startsWith(github.ref, 'refs/tags/')

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

@@ -0,0 +1,21 @@
+name: Rebase Organization Branches
+
+on:
+  push:
+    branches:
+      - 'master'
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Rebase Organization Branches
+        run: |
+          chmod +x rebase_organization_branches.sh
+          ./rebase_organization_branches.sh
+        env:
+          QC_GIT_TOKEN: ${{ secrets.QC_GIT_TOKEN }}

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

@@ -17,10 +17,10 @@ jobs:
 
       - name: install dependencies
         run: |
-          pip3 install papermill clr-loader
+          pip3 install papermill==2.4.0 clr-loader==0.1.6
 
       - name: install kernel
-        run: dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.317502
+        run: dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.340501
 
       - name: Add dotnet tools to Path
         run: echo "$HOME/.dotnet/tools" >> $GITHUB_PATH

.github/workflows/virtual-environments.yml

@@ -0,0 +1,64 @@
+name: Python Virtual Environments
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    container:
+        image: quantconnect/lean:foundation
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Build
+        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+
+      - name: Python Virtual Environment System Packages
+        run: python -m venv /lean-testenv --system-site-packages && . /lean-testenv/bin/activate && pip install --no-cache-dir lean==1.0.99 && deactivate
+
+      - name: Run Virtual Environment Test System Packages
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonVirtualEnvironmentTests.AssertVirtualEnvironment"
+
+      - name: Python Virtual Environment
+        run: rm -rf /lean-testenv && python -m venv /lean-testenv && . /lean-testenv/bin/activate && pip install --no-cache-dir lean==1.0.99 && deactivate
+
+      - name: Run Virtual Environment Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonVirtualEnvironmentTests.AssertVirtualEnvironment"
+
+      - name: Run Python Package Tests
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run Pomegranate & Tigramite Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.PomegranateTest|Tigramite" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run StableBaselines Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StableBaselinesTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run AxPlatform Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.AxPlatformTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run NBeats Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.NBeatsTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run TensorlyTest Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorlyTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run TensorflowProbability, NeuralTangents, Ignite Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowProbabilityTest|TensorflowTest|NeuralTangentsTest|IgniteTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run Hvplot Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.HvplotTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run Hvplot Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.StellargraphTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run Keras Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.KerasTest" --blame-hang-timeout 120seconds --blame-crash
+
+      - name: Run Keras Python Package Test
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ScikerasTest" --blame-hang-timeout 120seconds --blame-crash

.vs/readme.md

@@ -18,10 +18,10 @@ To use Lean CLI follow the instructions for installation and tutorial for usage
 
 <h2>Option 2: Install Locally</h2>
 
-1. Install [.Net 5](https://dotnet.microsoft.com/download) for the project
+1. Install [.Net 6](https://dotnet.microsoft.com/download) for the project
 
-2. (Optional) Get [Python 3.6.8](https://www.python.org/downloads/release/python-368/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-36) for your platform
+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
 
 3. Get [Visual Studio](https://visualstudio.microsoft.com/vs/)
 

.vscode/launch.json

@@ -3,8 +3,8 @@
         VS Code Launch configurations for the LEAN engine
 
         Launch:
-        Builds the project with dotnet 5 and then launches the program using coreclr; supports debugging.
-        In order to use this you need dotnet 5 on your system path, As well as the C# extension from the 
+        Builds the project with dotnet 6 and then launches the program using coreclr; supports debugging.
+        In order to use this you need dotnet 6 on your system path, As well as the C# extension from the 
         marketplace.
 
         Attach to Python:
@@ -26,7 +26,7 @@
             "program": "${workspaceFolder}/Launcher/bin/Debug/QuantConnect.Lean.Launcher.dll",
             "args": [
                 "--config",
-                "${workspaceFolder}/Launcher/config.json"
+                "${workspaceFolder}/Launcher/bin/Debug/config.json"
             ],
             "cwd": "${workspaceFolder}/Launcher/bin/Debug/",
             "stopAtEntry": false,

.vscode/launch_research.sh

@@ -0,0 +1,15 @@
+# Realpath polyfill, notably absent macOS and some debian distros
+absolute_path() {
+  echo "$(cd "$(dirname "${1}")" && pwd)/$(basename "${1}")"
+}
+
+# Get build directory from args position 1, or use default
+DEFAULT_BUILD_DIR=../Launcher/bin/Debug/
+BUILD_DIR=${1:-$DEFAULT_BUILD_DIR}
+BUILD_DIR=$(absolute_path "${BUILD_DIR}")
+
+#Add our build directory to python path for python kernel
+export PYTHONPATH="${PYTHONPATH}:${BUILD_DIR}"
+
+# Launch jupyter-lab
+jupyter-lab --allow-root --no-browser --notebook-dir=$BUILD_DIR --LabApp.token=''

.vscode/readme.md

@@ -4,6 +4,8 @@ This document contains information regarding ways to use Visual Studio Code to w
 
 - Using Lean CLI -> A great tool for working with your algorithms locally, while still being able to deploy to the cloud and have access to Lean data. It is also able to run algorithms locally through our official docker images **Recommended for algorithm development.
 
+- Using a Lean Dev container -> A docker environment with all dependencies pre-installed to allow seamless Lean development across platforms. Great for open source contributors.
+
 - Locally installing all dependencies to run Lean with Visual Studio Code on your OS.
 
 <br />
@@ -12,32 +14,63 @@ This document contains information regarding ways to use Visual Studio Code to 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 Dependencies Locally</h2>
+<h2>Option 2: Lean Development Container</h2>
 
-1. Install [.Net 5](https://dotnet.microsoft.com/download) for the project
+Before anything we need to ensure a few things have been done for either option:
 
-2. (Optional) Get [Python 3.6.8](https://www.python.org/downloads/release/python-368/) for running Python algorithms
-    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-36) for your platform
+1. Get [Visual Studio Code](https://code.visualstudio.com/download)
+    - Get [Remote Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) Extension
+
+2. Get [Docker](https://docs.docker.com/get-docker/):
+    - Follow the instructions for your Operating System
+    - New to Docker? Try [docker getting-started](https://docs.docker.com/get-started/)
+
+3. Pull Lean’s latest research image from a terminal
+    - `docker pull quantconnect/research:latest`
+
+4. Get Lean into VS Code
+    - Download the repo or clone it using: `git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)`
+    - Open the folder using VS Code
+
+5. Open Development Container
+    - In VS Code, either:
+        - Select "Reopen in Container" from pop up box.
+
+            OR
+
+        - Ctrl+Shift+P (Command Palette) and select "Remote-Containers: Rebuild and Reopen in Container"
+
+You should now be in the development container, give VS Code a moment to prepare and you will be ready to go!
+If you would like to mount any additional local files to your container, checkout [devcontainer.json "mounts" section](https://containers.dev/implementors/json_reference/) for an example! Upon any mount changes you must rebuild the container using Command Palette as in step 5.
+
+<br />
+
+<h2>Option 3: Install Dependencies Locally</h2>
+
+1. Install [.NET 6](https://dotnet.microsoft.com/en-us/download/dotnet/6.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
 
 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
     - Get the Extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) for Python Debugging
 
 4. Get Lean into VS Code
-    - Download the repo or clone it using: _git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
+    - Download the repo or clone it using: `git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)`
     - Open the folder using VS Code
 
-Your environment is prepared and ready to run lean
+Your environment is prepared and ready to run Lean.
 
 <br />
 
 <h1>How to use Lean</h1>
 
-This section will cover configuring, building, 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, building, 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 />
 
@@ -73,7 +106,6 @@ In VS Code run build task (Ctrl+Shift+B or "Terminal" dropdown); there are a few
 
 - __Build__ - basic build task, just builds Lean once
 - __Rebuild__ - rebuild task, completely rebuilds the project. Use if having issues with debugging symbols being loaded for your algorithms.
-- __Autobuilder__ - Starts a script that builds then waits for files to change and rebuilds appropriately
 - __Clean__ - deletes out all project build files
 
 <br />
@@ -123,5 +155,6 @@ _Figure 2: Python Debugger Messages_
 <h1>Common Issues</h1>
 Here we will cover some common issues with setting this up. This section will expand as we get user feedback!
 
+- The "project file cannot be loaded" and "nuget packages not found" errors occurs when the project files are open by another process in the host. Closing all applications and/or restarting the computer solve the issue.
 - Autocomplete and reference finding with omnisharp can sometimes bug, if this occurs use the command palette to restart omnisharp. (Ctrl+Shift+P "OmniSharp: Restart OmniSharp")
 - Any error messages about building in VSCode that point to comments in JSON. Either select **ignore** or follow steps described [here](https://stackoverflow.com/questions/47834825/in-vs-code-disable-error-comments-are-not-permitted-in-json) to remove the errors entirely.

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "files.eol": "\n",
+    "python.analysis.extraPaths": [
+        "/Lean/Algorithm.Python",
+        "/opt/miniconda3/lib/python3.8/site-packages"
+    ]
+}

.vscode/tasks.json

@@ -50,6 +50,18 @@
                 "reveal": "silent"
             },
             "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "start research",
+            "type": "shell",
+            "dependsOn": ["build"],
+            "group": "build",
+            "isBackground": true,
+            "command" : "${workspaceFolder}/.vscode/launch_research.sh",
+            "args" : [
+                "${workspaceFolder}/Launcher/bin/Debug"
+            ],
+            "problemMatcher": "$msCompile"
         }
     ]
 }

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -116,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 59;
+        public long DataPoints => 63;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -131,31 +131,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.03%"},
-            {"Compounding Annual Return", "-2.503%"},
+            {"Compounding Annual Return", "-2.594%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.032%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Net Profit", "-0.034%"},
+            {"Sharpe Ratio", "-7.854"},
+            {"Probabilistic Sharpe Ratio", "1.216%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
+            {"Alpha", "-0.022"},
+            {"Beta", "0.004"},
+            {"Annual Standard Deviation", "0.003"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-0.678"},
-            {"Tracking Error", "0.243"},
-            {"Treynor Ratio", "0"},
-            {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$2100000.00"},
+            {"Information Ratio", "-0.768"},
+            {"Tracking Error", "0.241"},
+            {"Treynor Ratio", "-4.689"},
+            {"Total Fees", "$8.60"},
+            {"Estimated Strategy Capacity", "$5500000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.419"},
+            {"Fitness Score", "0.417"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-81.557"},
-            {"Portfolio Turnover", "0.837"},
+            {"Return Over Maximum Drawdown", "-81.518"},
+            {"Portfolio Turnover", "0.834"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -169,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "68775c18eb40c1bde212653faec4016e"}
+            {"OrderListHash", "802a335b5c355e83b8cd2174f053c1b9"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         public override void Initialize()
         {
             SetStartDate(2020, 1, 4);
-            SetEndDate(2020, 1, 6);
+            SetEndDate(2020, 1, 8);
 
             _es20h20 = AddFutureContract(
                 QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 3, 20)),
@@ -51,8 +51,9 @@ namespace QuantConnect.Algorithm.CSharp
                 QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2020, 6, 19)),
                 Resolution.Minute).Symbol;
 
+            // Get option contract lists for 2020/01/05 (Time.AddDays(1)) because Lean has local data for that date
             var optionChains = OptionChainProvider.GetOptionContractList(_es20h20, Time.AddDays(1))
-                .Concat(OptionChainProvider.GetOptionContractList(_es19m20, Time));
+                .Concat(OptionChainProvider.GetOptionContractList(_es19m20, Time.AddDays(1)));
 
             foreach (var optionContract in optionChains)
             {
@@ -163,7 +164,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 210329;
+        public long DataPoints => 311879;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -178,31 +179,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "116.059%"},
-            {"Drawdown", "0.600%"},
+            {"Compounding Annual Return", "5512.811%"},
+            {"Drawdown", "1.000%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.635%"},
-            {"Sharpe Ratio", "17.16"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Net Profit", "5.333%"},
+            {"Sharpe Ratio", "64.137"},
+            {"Probabilistic Sharpe Ratio", "95.977%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2.25"},
-            {"Beta", "-1.665"},
-            {"Annual Standard Deviation", "0.071"},
-            {"Annual Variance", "0.005"},
-            {"Information Ratio", "5.319"},
-            {"Tracking Error", "0.114"},
-            {"Treynor Ratio", "-0.735"},
-            {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$24000000.00"},
+            {"Alpha", "25.72"},
+            {"Beta", "2.914"},
+            {"Annual Standard Deviation", "0.423"},
+            {"Annual Variance", "0.179"},
+            {"Information Ratio", "66.11"},
+            {"Tracking Error", "0.403"},
+            {"Treynor Ratio", "9.315"},
+            {"Total Fees", "$8.60"},
+            {"Estimated Strategy Capacity", "$22000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
             {"Fitness Score", "1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "2.133"},
+            {"Portfolio Turnover", "2.035"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -216,7 +217,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "35738733ff791eeeaf508faec804cab0"}
+            {"OrderListHash", "e7021bd385f366771ae00abd3a46a22e"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -93,7 +93,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 46583;
+        public long DataPoints => 12164;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -108,31 +108,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "20"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-47.647%"},
-            {"Drawdown", "3.200%"},
+            {"Compounding Annual Return", "386219349.202%"},
+            {"Drawdown", "5.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-0.530%"},
-            {"Sharpe Ratio", "-8.194"},
+            {"Net Profit", "11.912%"},
+            {"Sharpe Ratio", "1604181.92"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-1.345"},
-            {"Beta", "1.391"},
-            {"Annual Standard Deviation", "0.06"},
-            {"Annual Variance", "0.004"},
-            {"Information Ratio", "-66.031"},
-            {"Tracking Error", "0.017"},
-            {"Treynor Ratio", "-0.351"},
-            {"Total Fees", "$37.00"},
-            {"Estimated Strategy Capacity", "$3400000.00"},
+            {"Alpha", "2144881.34"},
+            {"Beta", "31.223"},
+            {"Annual Standard Deviation", "1.337"},
+            {"Annual Variance", "1.788"},
+            {"Information Ratio", "1657259.526"},
+            {"Tracking Error", "1.294"},
+            {"Treynor Ratio", "68696.045"},
+            {"Total Fees", "$35.70"},
+            {"Estimated Strategy Capacity", "$2600000.00"},
             {"Lowest Capacity Asset", "ES 31C3JQS9D84PW|ES XCZJLC9NOB29"},
-            {"Fitness Score", "0.5"},
+            {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-94.467"},
-            {"Portfolio Turnover", "5.578"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -146,7 +146,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7fbb8c0a1f5eee780f0b37efafbbdc4b"}
+            {"OrderListHash", "64221a660525c4259d5bd852eef1299c"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -43,7 +43,7 @@ namespace QuantConnect.Algorithm.CSharp
         public override void Initialize()
         {
             SetStartDate(2020, 1, 4);
-            SetEndDate(2020, 1, 6);
+            SetEndDate(2020, 1, 8);
 
             _es = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME);
             _es.SetFilter((futureFilter) =>
@@ -164,8 +164,6 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void OnEndOfAlgorithm()
         {
-            base.OnEndOfAlgorithm();
-
             if (!_optionFilterRan)
             {
                 throw new InvalidOperationException("Option chain filter was never ran");
@@ -222,7 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 779544;
+        public long DataPoints => 612882;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -237,31 +235,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-10.708%"},
-            {"Drawdown", "0.200%"},
+            {"Compounding Annual Return", "347.065%"},
+            {"Drawdown", "0.900%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-0.093%"},
-            {"Sharpe Ratio", "-10.594"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Net Profit", "1.951%"},
+            {"Sharpe Ratio", "15.548"},
+            {"Probabilistic Sharpe Ratio", "95.977%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.261"},
-            {"Beta", "0.244"},
-            {"Annual Standard Deviation", "0.01"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-22.456"},
-            {"Tracking Error", "0.032"},
-            {"Treynor Ratio", "-0.454"},
-            {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$41000.00"},
-            {"Lowest Capacity Asset", "ES 31C3JQTOYO9T0|ES XCZJLC9NOB29"},
-            {"Fitness Score", "0.273"},
+            {"Alpha", "1.885"},
+            {"Beta", "1.066"},
+            {"Annual Standard Deviation", "0.155"},
+            {"Annual Variance", "0.024"},
+            {"Information Ratio", "13.528"},
+            {"Tracking Error", "0.142"},
+            {"Treynor Ratio", "2.258"},
+            {"Total Fees", "$3.57"},
+            {"Estimated Strategy Capacity", "$760000.00"},
+            {"Lowest Capacity Asset", "ES XCZJLDQX2SRO|ES XCZJLC9NOB29"},
+            {"Fitness Score", "0.403"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-123.159"},
-            {"Portfolio Turnover", "0.547"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.403"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -275,7 +273,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9347e3b610cfa21f7cbd968a0135c8af"}
+            {"OrderListHash", "738240babf741f1bf79f85ea5026ec4c"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -170,7 +170,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "4f50b8360ea317ef974801649088bd06"}
+            {"OrderListHash", "568fe7c2a11960436660db1231f2cfd2"}
         };
     }
 }

Algorithm.CSharp/AddOptionWithOnMarketOpenOnlyFilterRegressionAlgorithm.cs

@@ -0,0 +1,147 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm asserting that using OnlyApplyFilterAtMarketOpen along with other dynamic filters will make the filters be applied only on market
+    /// open, regardless of the order of configuration of the filters
+    /// </summary>
+    public class AddOptionWithOnMarketOpenOnlyFilterRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2014, 6, 5);
+            SetEndDate(2014, 6, 10);
+
+            // OnlyApplyFilterAtMarketOpen as first filter
+            AddOption("AAPL", Resolution.Minute).SetFilter(u =>
+                u.OnlyApplyFilterAtMarketOpen()
+                 .Strikes(-5, 5)
+                 .Expiration(0, 100)
+                 .IncludeWeeklys());
+
+            // OnlyApplyFilterAtMarketOpen as last filter
+            AddOption("TWX", Resolution.Minute).SetFilter(u =>
+                u.Strikes(-5, 5)
+                 .Expiration(0, 100)
+                 .IncludeWeeklys()
+                 .OnlyApplyFilterAtMarketOpen());
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            // This will be the first call, the underlying securities are added.
+            if (changes.AddedSecurities.All(s => s.Type != SecurityType.Option))
+            {
+                return;
+            }
+
+            var changeOptions = changes.AddedSecurities.Concat(changes.RemovedSecurities)
+                                                                        .Where(s => s.Type == SecurityType.Option);
+
+            // Susbtract one minute to get the actual market open. If market open is at 9:30am, this will be invoked at 9:31am
+            var expectedTime = Time.TimeOfDay - TimeSpan.FromMinutes(1);
+            var allOptionsWereChangedOnMarketOpen = changeOptions.All(s =>
+            {
+                var firstMarketSegment = s.Exchange.Hours.MarketHours[Time.DayOfWeek].Segments
+                                                         .First(segment => segment.State == MarketHoursState.Market);
+
+                return firstMarketSegment.Start == expectedTime;
+            });
+
+            if (!allOptionsWereChangedOnMarketOpen)
+            {
+                throw new Exception("Expected options filter to be run only on market open");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all time slices of algorithm
+        /// </summary>
+        public long DataPoints => 6023980;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "-10.144"},
+            {"Tracking Error", "0.033"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/AlphaStreamsDifferentAccountCurrencyBasicTemplateAlgorithm.cs

@@ -44,7 +44,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 6214;
+        public override long DataPoints => 6202;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -59,7 +59,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0.01%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-78.502%"},
+            {"Compounding Annual Return", "-78.519%"},
             {"Drawdown", "3.100%"},
             {"Expectancy", "7.797"},
             {"Net Profit", "-1.134%"},

Algorithm.CSharp/Alphas/ShareClassMeanReversionAlpha.cs

@@ -31,7 +31,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
     /// A number of companies publicly trade two different classes of shares
     /// in US equity markets. If both assets trade with reasonable volume, then
     /// the underlying driving forces of each should be similar or the same. Given
-    /// this, we can create a relatively dollar-netural long/short portfolio using
+    /// this, we can create a relatively dollar-neutral long/short portfolio using
     /// the dual share classes. Theoretically, any deviation of this portfolio from
     /// its mean-value should be corrected, and so the motivating idea is based on
     /// mean-reversion. Using a Simple Moving Average indicator, we can

Algorithm.CSharp/Alphas/VixDualThrustAlpha.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             int barsToConsolidate = 1
             )
         {
-            // coefficient that used to determinte upper and lower borders of a breakout channel
+            // coefficient that used to determine upper and lower borders of a breakout channel
             _k1 = k1;
             _k2 = k2;
 
@@ -202,7 +202,7 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
                 SymbolData symbolData;
                 if (_symbolDataBySymbol.TryGetValue(removed.Symbol, out symbolData))
                 {
-                    // unsibscribe consolidator from data updates
+                    // unsubscribe consolidator from data updates
                     algorithm.SubscriptionManager.RemoveConsolidator(removed.Symbol, symbolData.GetConsolidator());
 
                     // remove item from dictionary collection

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -34,8 +34,8 @@ namespace QuantConnect.Algorithm.CSharp
         {
             UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
             EnableAutomaticIndicatorWarmUp = true;
-            SetStartDate(2013, 10, 07);
-            SetEndDate(2013, 10, 09);
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 10, 10);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
             _symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
@@ -146,7 +146,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 14531;
+        public long DataPoints => 6426;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -161,31 +161,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-100.000%"},
-            {"Drawdown", "19.800%"},
+            {"Compounding Annual Return", "733913.744%"},
+            {"Drawdown", "15.900%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-10.353%"},
-            {"Sharpe Ratio", "-1.379"},
+            {"Net Profit", "6.828%"},
+            {"Sharpe Ratio", "203744786353.302"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "3.004"},
-            {"Beta", "5.322"},
-            {"Annual Standard Deviation", "0.725"},
-            {"Annual Variance", "0.525"},
-            {"Information Ratio", "-0.42"},
-            {"Tracking Error", "0.589"},
-            {"Treynor Ratio", "-0.188"},
-            {"Total Fees", "$20.35"},
-            {"Estimated Strategy Capacity", "$13000000.00"},
+            {"Alpha", "456382350698.561"},
+            {"Beta", "9.229"},
+            {"Annual Standard Deviation", "2.24"},
+            {"Annual Variance", "5.017"},
+            {"Information Ratio", "228504036840.953"},
+            {"Tracking Error", "1.997"},
+            {"Treynor Ratio", "49450701625.718"},
+            {"Total Fees", "$23.65"},
+            {"Estimated Strategy Capacity", "$200000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.125"},
+            {"Fitness Score", "0.518"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-2.162"},
-            {"Return Over Maximum Drawdown", "-8.144"},
-            {"Portfolio Turnover", "3.184"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-7.708"},
+            {"Portfolio Turnover", "5.277"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -199,7 +199,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7ff48adafe9676f341e64ac9388d3c2c"}
+            {"OrderListHash", "dd38e7b94027d20942a5aa9ac31a9a7f"}
         };
     }
 }

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -296,7 +296,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1748811;
+        public long DataPoints => 1341291;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -349,7 +349,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "f67306bc706a2cf66288f1cadf6148ed"}
+            {"OrderListHash", "85cbf92f01c2c91b5f710b7eeefecbe1"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateCfdAlgorithm.cs

@@ -0,0 +1,72 @@
+/*
+ * 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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm demonstrating CFD asset types and requesting history.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="history" />
+    /// <meta name="tag" content="cfd" />
+    public class BasicTemplateCfdAlgorithm : QCAlgorithm
+    {
+        private Symbol _symbol;
+
+        /// <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()
+        {
+            SetAccountCurrency("EUR");
+
+            SetStartDate(2019, 2, 20);
+            SetEndDate(2019, 2, 21);
+            SetCash("EUR", 100000);
+
+            _symbol = AddCfd("DE30EUR").Symbol;
+
+            // Historical Data
+            var history = History(_symbol, 60, Resolution.Daily);
+            Log($"Received {history.Count()} bars from CFD historical data call.");
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            // Access Data
+            if (slice.QuoteBars.ContainsKey(_symbol))
+            {
+                var quoteBar = slice.QuoteBars[_symbol];
+                Log($"{quoteBar.EndTime} :: {quoteBar.Close}");
+            }
+
+            if (!Portfolio.Invested)
+                SetHoldings(_symbol, 1);
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($"{Time} {orderEvent.ToString()}");
+        }
+    }
+}

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -83,7 +83,8 @@ namespace QuantConnect.Algorithm.CSharp
                 Liquidate();
             }
 
-            if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped)
+            // We check exchange hours because the contract mapping can call OnData outside of regular hours.
+            if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped && _continuousContract.Exchange.ExchangeOpen)
             {
                 Log($"{Time} - rolling position from {_currentContract.Symbol} to {_continuousContract.Mapped}");
 
@@ -117,7 +118,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 875590;
+        public long DataPoints => 709638;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -131,31 +132,31 @@ namespace QuantConnect.Algorithm.CSharp
         {
             {"Total Trades", "2"},
             {"Average Win", "0%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-0.007%"},
+            {"Average Loss", "-0.02%"},
+            {"Compounding Annual Return", "-0.033%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.004%"},
-            {"Sharpe Ratio", "-0.369"},
-            {"Probabilistic Sharpe Ratio", "10.640%"},
+            {"Net Profit", "-0.017%"},
+            {"Sharpe Ratio", "-1.173"},
+            {"Probabilistic Sharpe Ratio", "0.011%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "-0"},
-            {"Beta", "0"},
+            {"Beta", "-0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.751"},
+            {"Information Ratio", "-2.752"},
             {"Tracking Error", "0.082"},
-            {"Treynor Ratio", "-0.616"},
-            {"Total Fees", "$3.70"},
+            {"Treynor Ratio", "1.883"},
+            {"Total Fees", "$4.30"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.007"},
+            {"Fitness Score", "0.006"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-0.738"},
+            {"Return Over Maximum Drawdown", "-1.996"},
             {"Portfolio Turnover", "0.01"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -170,7 +171,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "bd7fbe57802dfedb36c85609b7234016"}
+            {"OrderListHash", "1fd4b49e9450800981c6dead2bbca995"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -0,0 +1,182 @@
+/*
+ * 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.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Indicators;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+using Futures = QuantConnect.Securities.Futures;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Basic Continuous Futures Template Algorithm with extended market hours
+    /// </summary>
+    public class BasicTemplateContinuousFutureWithExtendedMarketAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Future _continuousContract;
+        private Security _currentContract;
+        private SimpleMovingAverage _fast;
+        private SimpleMovingAverage _slow;
+
+        /// <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, 7, 1);
+            SetEndDate(2014, 1, 1);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.LastTradingDay,
+                contractDepthOffset: 0,
+                extendedMarketHours: true
+            );
+
+            _fast = SMA(_continuousContract.Symbol, 3, Resolution.Daily);
+            _slow = SMA(_continuousContract.Symbol, 10, Resolution.Daily);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            foreach (var changedEvent in data.SymbolChangedEvents.Values)
+            {
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
+
+            if (!IsMarketOpen(_continuousContract.Symbol))
+            {
+                return;
+            }
+
+            if (!Portfolio.Invested)
+            {
+                if(_fast > _slow)
+                {
+                    _currentContract = Securities[_continuousContract.Mapped];
+                    Buy(_currentContract.Symbol, 1);
+                }
+            }
+            else if(_fast < _slow)
+            {
+                Liquidate();
+            }
+
+            if (_currentContract != null && _currentContract.Symbol != _continuousContract.Mapped)
+            {
+                Log($"{Time} - rolling position from {_currentContract.Symbol} to {_continuousContract.Mapped}");
+
+                var currentPositionSize = _currentContract.Holdings.Quantity;
+                Liquidate(_currentContract.Symbol);
+                Buy(_continuousContract.Mapped, currentPositionSize);
+                _currentContract = Securities[_continuousContract.Mapped];
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($"{orderEvent}");
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            Debug($"{Time}-{changes}");
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 2202510;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.02%"},
+            {"Compounding Annual Return", "-0.033%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-0.017%"},
+            {"Sharpe Ratio", "-1.173"},
+            {"Probabilistic Sharpe Ratio", "0.011%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0"},
+            {"Beta", "-0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-2.752"},
+            {"Tracking Error", "0.082"},
+            {"Treynor Ratio", "1.883"},
+            {"Total Fees", "$4.30"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.006"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-1.985"},
+            {"Portfolio Turnover", "0.01"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "adb237703e65b93da5961c0085109732"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

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

Algorithm.CSharp/BasicTemplateCryptoFutureAlgorithm.cs

@@ -0,0 +1,292 @@
+/*
+ * 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.Data;
+using QuantConnect.Orders;
+using QuantConnect.Brokerages;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.CryptoFuture;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Minute resolution regression algorithm trading Coin and USDT binance futures long and short asserting the behavior
+    /// </summary>
+    public class BasicTemplateCryptoFutureAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, int> _interestPerSymbol = new();
+        private CryptoFuture _btcUsd;
+        private CryptoFuture _adaUsdt;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        /// <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(2022, 12, 13); // Set Start Date
+            SetEndDate(2022, 12, 13); // Set End Date
+
+            SetTimeZone(NodaTime.DateTimeZone.Utc);
+
+            try
+            {
+                SetBrokerageModel(BrokerageName.BinanceFutures, AccountType.Cash);
+            }
+            catch (InvalidOperationException)
+            {
+                // expected, we don't allow cash account type
+            }
+            SetBrokerageModel(BrokerageName.BinanceFutures, AccountType.Margin);
+
+            _btcUsd = AddCryptoFuture("BTCUSD");
+            _adaUsdt = AddCryptoFuture("ADAUSDT");
+
+            _fast = EMA(_btcUsd.Symbol, 30, Resolution.Minute);
+            _slow = EMA(_btcUsd.Symbol, 60, Resolution.Minute);
+
+            _interestPerSymbol[_btcUsd.Symbol] = 0;
+            _interestPerSymbol[_adaUsdt.Symbol] = 0;
+
+            // Default USD cash, set 1M but it wont be used
+            SetCash(1000000);
+
+            // the amount of BTC we need to hold to trade 'BTCUSD'
+            _btcUsd.BaseCurrency.SetAmount(0.005m);
+            // the amount of USDT we need to hold to trade 'ADAUSDT'
+            _adaUsdt.QuoteCurrency.SetAmount(200);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            var interestRates = data.Get<MarginInterestRate>();
+            foreach (var interestRate in interestRates)
+            {
+                _interestPerSymbol[interestRate.Key]++;
+
+                var cachedInterestRate = Securities[interestRate.Key].Cache.GetData<MarginInterestRate>();
+                if (cachedInterestRate != interestRate.Value)
+                {
+                    throw new Exception($"Unexpected cached margin interest rate for {interestRate.Key}!");
+                }
+            }
+
+            if (_fast > _slow)
+            {
+                if (!Portfolio.Invested && Transactions.OrdersCount == 0)
+                {
+                    var ticket = Buy(_btcUsd.Symbol, 50);
+                    if (ticket.Status != OrderStatus.Invalid)
+                    {
+                        throw new Exception($"Unexpected valid order {ticket}, should fail due to margin not sufficient");
+                    }
+
+                    Buy(_btcUsd.Symbol, 1);
+
+                    var marginUsed = Portfolio.TotalMarginUsed;
+                    var btcUsdHoldings = _btcUsd.Holdings;
+
+                    // Coin futures value is 100 USD
+                    var holdingsValueBtcUsd = 100;
+
+                    if (Math.Abs(btcUsdHoldings.TotalSaleVolume - holdingsValueBtcUsd) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {btcUsdHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost - holdingsValueBtcUsd) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {btcUsdHoldings.HoldingsCost}");
+                    }
+                    // margin used is based on the maintenance rate
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _btcUsd.BuyingPowerModel.GetMaintenanceMargin(_btcUsd) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    Buy(_adaUsdt.Symbol, 1000);
+
+                    marginUsed = Portfolio.TotalMarginUsed - marginUsed;
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 1000;
+
+                    if (Math.Abs(adaUsdtHoldings.TotalSaleVolume - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {adaUsdtHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _adaUsdt.BuyingPowerModel.GetMaintenanceMargin(_adaUsdt) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+
+                    if (Portfolio.TotalProfit != 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+            else
+            {
+                // let's revert our position and double
+                if (Time.Hour > 10 && Transactions.OrdersCount == 3)
+                {
+                    Sell(_btcUsd.Symbol, 3);
+
+                    var btcUsdHoldings = _btcUsd.Holdings;
+
+                    if (Math.Abs(btcUsdHoldings.AbsoluteHoldingsCost - 100 * 2) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {btcUsdHoldings.HoldingsCost}");
+                    }
+
+                    Sell(_adaUsdt.Symbol, 3000);
+
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 2000;
+
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+                    // we barely did any difference on the previous trade
+                    if ((5 - Math.Abs(Portfolio.TotalProfit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_interestPerSymbol[_adaUsdt.Symbol] != 1)
+            {
+                throw new Exception($"Unexpected interest rate count {_interestPerSymbol[_adaUsdt.Symbol]}");
+            }
+
+            if (_interestPerSymbol[_btcUsd.Symbol] != 3)
+            {
+                throw new Exception($"Unexpected interest rate count {_interestPerSymbol[_btcUsd.Symbol]}");
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 7205;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "4"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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.65"},
+            {"Estimated Strategy Capacity", "$630000000.00"},
+            {"Lowest Capacity Asset", "ADAUSDT 18R"},
+            {"Fitness Score", "0.001"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.001"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d4520985f69c915060f6bee3b7926cf5"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateCryptoFutureHourlyAlgorithm.cs

@@ -0,0 +1,255 @@
+/*
+ * 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.Data;
+using QuantConnect.Orders;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Brokerages;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.CryptoFuture;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Hourly regression algorithm trading ADAUSDT binance futures long and short asserting the behavior
+    /// </summary>
+    public class BasicTemplateCryptoFutureHourlyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, int> _interestPerSymbol = new();
+        private CryptoFuture _adaUsdt;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+        /// <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(2022, 12, 13);
+            SetEndDate(2022, 12, 13);
+
+            SetTimeZone(NodaTime.DateTimeZone.Utc);
+
+            try
+            {
+                SetBrokerageModel(BrokerageName.BinanceCoinFutures, AccountType.Cash);
+            }
+            catch (InvalidOperationException)
+            {
+                // expected, we don't allow cash account type
+            }
+            SetBrokerageModel(BrokerageName.BinanceCoinFutures, AccountType.Margin);
+
+            _adaUsdt = AddCryptoFuture("ADAUSDT", Resolution.Hour);
+
+            _fast = EMA(_adaUsdt.Symbol, 3, Resolution.Hour);
+            _slow = EMA(_adaUsdt.Symbol, 6, Resolution.Hour);
+
+            _interestPerSymbol[_adaUsdt.Symbol] = 0;
+
+            // Default USD cash, set 1M but it wont be used
+            SetCash(1000000);
+
+            // the amount of USDT we need to hold to trade 'ADAUSDT'
+            _adaUsdt.QuoteCurrency.SetAmount(200);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            var interestRates = data.Get<MarginInterestRate>();
+            foreach (var interestRate in interestRates)
+            {
+                _interestPerSymbol[interestRate.Key]++;
+
+                var cachedInterestRate = Securities[interestRate.Key].Cache.GetData<MarginInterestRate>();
+                if (cachedInterestRate != interestRate.Value)
+                {
+                    throw new Exception($"Unexpected cached margin interest rate for {interestRate.Key}!");
+                }
+            }
+
+            if (_fast > _slow)
+            {
+                if (!Portfolio.Invested && Transactions.OrdersCount == 0)
+                {
+                    var ticket = Buy(_adaUsdt.Symbol, 100000);
+                    if(ticket.Status != OrderStatus.Invalid)
+                    {
+                        throw new Exception($"Unexpected valid order {ticket}, should fail due to margin not sufficient");
+                    }
+
+                    Buy(_adaUsdt.Symbol, 1000);
+
+                    var marginUsed = Portfolio.TotalMarginUsed;
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 1000;
+
+                    if (Math.Abs(adaUsdtHoldings.TotalSaleVolume - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected TotalSaleVolume {adaUsdtHoldings.TotalSaleVolume}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost * 0.05m - marginUsed) > 1
+                        || _adaUsdt.BuyingPowerModel.GetMaintenanceMargin(_adaUsdt) != marginUsed)
+                    {
+                        throw new Exception($"Unexpected margin used {marginUsed}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+
+                    if (Portfolio.TotalProfit != 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+            }
+            else
+            {
+                // let's revert our position and double
+                if (Time.Hour > 10 && Transactions.OrdersCount == 2)
+                {
+                    Sell(_adaUsdt.Symbol, 3000);
+
+                    var adaUsdtHoldings = _adaUsdt.Holdings;
+
+                    // USDT/BUSD futures value is based on it's price
+                    var holdingsValueUsdt = _adaUsdt.Price * _adaUsdt.SymbolProperties.ContractMultiplier * 2000;
+
+                    if (Math.Abs(adaUsdtHoldings.AbsoluteHoldingsCost - holdingsValueUsdt) > 1)
+                    {
+                        throw new Exception($"Unexpected holdings cost {adaUsdtHoldings.HoldingsCost}");
+                    }
+
+                    // position just opened should be just spread here
+                    var profit = Portfolio.TotalUnrealizedProfit;
+                    if ((5 - Math.Abs(profit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalUnrealizedProfit {Portfolio.TotalUnrealizedProfit}");
+                    }
+                    // we barely did any difference on the previous trade
+                    if ((5 - Math.Abs(Portfolio.TotalProfit)) < 0)
+                    {
+                        throw new Exception($"Unexpected TotalProfit {Portfolio.TotalProfit}");
+                    }
+                }
+
+                if (Time.Hour >= 22 && Transactions.OrdersCount == 3)
+                {
+                    Liquidate();
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_interestPerSymbol[_adaUsdt.Symbol] != 1)
+            {
+                throw new Exception($"Unexpected interest rate count {_interestPerSymbol[_adaUsdt.Symbol]}");
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 50;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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.61"},
+            {"Estimated Strategy Capacity", "$520000000.00"},
+            {"Lowest Capacity Asset", "ADAUSDT 18R"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "-364.224"},
+            {"Portfolio Turnover", "0.001"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "17f99ecc3f35f94fff1ea5694c40d32c"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateFutureOptionAlgorithm.cs

@@ -0,0 +1,95 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm demonstrating FutureOption asset types and requesting history.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="history" />
+    /// <meta name="tag" content="future option" />
+    public class BasicTemplateFutureOptionAlgorithm : QCAlgorithm
+    {
+        private Symbol _symbol;
+
+        /// <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(2022, 1, 1);
+            SetEndDate(2022, 2, 1);
+            SetCash(100000);
+
+            var gold_futures = AddFuture(Futures.Metals.Gold, Resolution.Minute);
+            gold_futures.SetFilter(0, 180);
+            _symbol = gold_futures.Symbol;
+            AddFutureOption(_symbol, universe => universe.Strikes(-5, +5)
+                                                        .CallsOnly()
+                                                        .BackMonth()
+                                                        .OnlyApplyFilterAtMarketOpen());
+
+            // Historical Data
+            var history = History(_symbol, 60, Resolution.Daily);
+            Log($"Received {history.Count()} bars from {_symbol} FutureOption historical data call.");
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            // Access Data
+            foreach(var kvp in slice.OptionChains)
+            {
+                var underlyingFutureContract = kvp.Key.Underlying;
+                var chain = kvp.Value;
+
+                if (chain.Count() == 0) continue;
+
+                foreach(var contract in chain)
+                {
+                    Log($@"Canonical Symbol: {kvp.Key}; 
+                        Contract: {contract}; 
+                        Right: {contract.Right}; 
+                        Expiry: {contract.Expiry}; 
+                        Bid price: {contract.BidPrice}; 
+                        Ask price: {contract.AskPrice}; 
+                        Implied Volatility: {contract.ImpliedVolatility}");
+                }
+
+                if (!Portfolio.Invested)
+                {
+                    var atmStrike = chain.OrderBy(x => Math.Abs(chain.Underlying.Price - x.Strike)).First().Strike;
+                    var selectedContract = chain.Where(x => x.Strike == atmStrike).OrderByDescending(x => x.Expiry).First();
+                    MarketOrder(selectedContract.Symbol, 1);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($"{Time} {orderEvent.ToString()}");
+        }
+    }
+}

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -0,0 +1,235 @@
+/*
+ * 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.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Indicators;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Example algorithm for trading continuous future
+    /// </summary>
+    public class BasicTemplateFutureRolloverAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, SymbolData> _symbolDataBySymbol = new();
+
+        /// <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, 8);
+            SetEndDate(2013, 12, 10);
+            SetCash(1000000);
+
+            var futures = new List<string> {
+                Futures.Indices.SP500EMini
+            };
+
+            foreach (var future in futures)
+            {
+                // Requesting data
+                var continuousContract = AddFuture(future,
+                    resolution: Resolution.Daily,
+                    extendedMarketHours: true,
+                    dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                    dataMappingMode: DataMappingMode.OpenInterest,
+                    contractDepthOffset: 0
+                );
+
+                var symbolData = new SymbolData(this, continuousContract);
+                _symbolDataBySymbol.Add(continuousContract.Symbol, symbolData);
+            }
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            foreach (var kvp in _symbolDataBySymbol)
+            {
+                var symbol = kvp.Key;
+                var symbolData = kvp.Value;
+
+                // Call SymbolData.Update() method to handle new data slice received
+                symbolData.Update(slice);
+
+                // Check if information in SymbolData class and new slice data are ready for trading
+                if (!symbolData.IsReady || !slice.Bars.ContainsKey(symbol))
+                {
+                    return;
+                }
+
+                var emaCurrentValue = symbolData.EMA.Current.Value;
+                if (emaCurrentValue < symbolData.Price && !symbolData.IsLong)
+                {
+                    MarketOrder(symbolData.Mapped, 1);
+                }
+                else if (emaCurrentValue > symbolData.Price && !symbolData.IsShort)
+                {
+                    MarketOrder(symbolData.Mapped, -1);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Abstracted class object to hold information (state, indicators, methods, etc.) from a Symbol/Security in a multi-security algorithm
+        /// </summary>
+        public class SymbolData
+        {
+            private QCAlgorithm _algorithm;
+            private Future _future;
+            public ExponentialMovingAverage EMA;
+            public decimal Price;
+            public bool IsLong;
+            public bool IsShort;
+            public Symbol Symbol => _future.Symbol;
+            public Symbol Mapped => _future.Mapped;
+
+            /// <summary>
+            /// Check if symbolData class object are ready for trading
+            /// </summary>
+            public bool IsReady => Mapped != null && EMA.IsReady;
+
+            /// <summary>
+            /// Constructor to instantiate the information needed to be hold
+            /// </summary>
+            public SymbolData(QCAlgorithm algorithm, Future future)
+            {
+                _algorithm = algorithm;
+                _future = future;
+                EMA = algorithm.EMA(future.Symbol, 20, Resolution.Daily);
+
+                Reset();
+            }
+
+            /// <summary>
+            /// Handler of new slice of data received
+            /// </summary>
+            public void Update(Slice slice)
+            {
+                if (slice.SymbolChangedEvents.TryGetValue(Symbol, out var changedEvent))
+                {
+                    var oldSymbol = changedEvent.OldSymbol;
+                    var newSymbol = changedEvent.NewSymbol;
+                    var tag = $"Rollover - Symbol changed at {_algorithm.Time}: {oldSymbol} -> {newSymbol}";
+                    var quantity = _algorithm.Portfolio[oldSymbol].Quantity;
+
+                    // Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
+                    _algorithm.Liquidate(oldSymbol, tag: tag);
+                    _algorithm.MarketOrder(newSymbol, quantity, tag: tag);
+
+                    Reset();
+                }
+
+                Price = slice.Bars.ContainsKey(Symbol) ? slice.Bars[Symbol].Price : Price;
+                IsLong = _algorithm.Portfolio[Mapped].IsLong;
+                IsShort = _algorithm.Portfolio[Mapped].IsShort;
+            }
+
+            /// <summary>
+            /// Reset RollingWindow/indicator to adapt to newly mapped contract, then warm up the RollingWindow/indicator
+            /// </summary>
+            private void Reset()
+            {
+                EMA.Reset();
+                _algorithm.WarmUpIndicator(Symbol, EMA, Resolution.Daily);
+            }
+
+            /// <summary>
+            /// Disposal method to remove consolidator/update method handler, and reset RollingWindow/indicator to free up memory and speed
+            /// </summary>
+            public void Dispose()
+            {
+                EMA.Reset();
+            }
+        }
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1345;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 4;
+
+        /// <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 Trades", "2"},
+            {"Average Win", "0.53%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "3.011%"},
+            {"Drawdown", "0.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.528%"},
+            {"Sharpe Ratio", "1.999"},
+            {"Probabilistic Sharpe Ratio", "83.704%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.023"},
+            {"Beta", "-0.004"},
+            {"Annual Standard Deviation", "0.011"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-4.774"},
+            {"Tracking Error", "0.084"},
+            {"Treynor Ratio", "-4.853"},
+            {"Total Fees", "$4.30"},
+            {"Estimated Strategy Capacity", "$5900000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "1792.236"},
+            {"Portfolio Turnover", "0.002"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "40e4b91ec89383f6501d9ba324e50eb9"}
+        };
+    }  
+}

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -59,7 +59,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             // set our expiry filter for this futures chain
             // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria 
+            // The following statements yield the same filtering criteria
             futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
             futureGold.SetFilter(0, 182);
 
@@ -151,46 +151,46 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 203367;
+        public long DataPoints => 68645;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 518;
+        public int AlgorithmHistoryDataPoints => 340;
 
         /// <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 Trades", "8220"},
+            {"Total Trades", "2700"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-100.000%"},
-            {"Drawdown", "13.500%"},
-            {"Expectancy", "-0.818"},
-            {"Net Profit", "-13.517%"},
-            {"Sharpe Ratio", "-98.781"},
+            {"Compounding Annual Return", "-99.777%"},
+            {"Drawdown", "4.400%"},
+            {"Expectancy", "-0.724"},
+            {"Net Profit", "-4.430%"},
+            {"Sharpe Ratio", "-31.389"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "89%"},
-            {"Win Rate", "11%"},
-            {"Profit-Loss Ratio", "0.69"},
-            {"Alpha", "-1.676"},
-            {"Beta", "0.042"},
-            {"Annual Standard Deviation", "0.01"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-73.981"},
-            {"Tracking Error", "0.233"},
-            {"Treynor Ratio", "-23.975"},
-            {"Total Fees", "$15207.00"},
-            {"Estimated Strategy Capacity", "$8000.00"},
+            {"Loss Rate", "83%"},
+            {"Win Rate", "17%"},
+            {"Profit-Loss Ratio", "0.65"},
+            {"Alpha", "-3.059"},
+            {"Beta", "0.128"},
+            {"Annual Standard Deviation", "0.031"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-81.232"},
+            {"Tracking Error", "0.212"},
+            {"Treynor Ratio", "-7.618"},
+            {"Total Fees", "$6237.00"},
+            {"Estimated Strategy Capacity", "$14000.00"},
             {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Fitness Score", "0.033"},
+            {"Fitness Score", "0.001"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-8.62"},
-            {"Return Over Maximum Drawdown", "-7.81"},
-            {"Portfolio Turnover", "302.321"},
+            {"Sortino Ratio", "-58.8"},
+            {"Return Over Maximum Drawdown", "-32.114"},
+            {"Portfolio Turnover", "98.477"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -204,7 +204,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "35b3f4b7a225468d42ca085386a2383e"}
+            {"OrderListHash", "8f92e1528c6477a156449fd1e86527e7"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -19,7 +19,9 @@ 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
 {
@@ -31,14 +33,16 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="futures" />
     public class BasicTemplateFuturesDailyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private Symbol _contractSymbol;
         protected virtual Resolution Resolution => Resolution.Daily;
+        protected virtual bool ExtendedMarketHours => false;
 
         // S&P 500 EMini futures
         private const string RootSP500 = Futures.Indices.SP500EMini;
 
         // Gold futures
         private const string RootGold = Futures.Metals.Gold;
+        private Future _futureSP500;
+        private Future _futureGold;
 
         /// <summary>
         /// Initialize your algorithm and add desired assets.
@@ -49,14 +53,14 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2014, 10, 10);
             SetCash(1000000);
 
-            var futureSP500 = AddFuture(RootSP500, Resolution);
-            var futureGold = AddFuture(RootGold, Resolution);
+            _futureSP500 = AddFuture(RootSP500, Resolution, extendedMarketHours: ExtendedMarketHours);
+            _futureGold = AddFuture(RootGold, Resolution, extendedMarketHours: ExtendedMarketHours);
 
             // set our expiry filter for this futures chain
             // SetFilter method accepts TimeSpan objects or integer for days.
-            // The following statements yield the same filtering criteria 
-            futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
-            futureGold.SetFilter(0, 182);
+            // The following statements yield the same filtering criteria
+            _futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
+            _futureGold.SetFilter(0, 182);
         }
 
         /// <summary>
@@ -76,15 +80,17 @@ namespace QuantConnect.Algorithm.CSharp
                         select futuresContract
                     ).FirstOrDefault();
 
-                    // if found, trade it
-                    if (contract != null && IsMarketOpen(contract.Symbol))
+                    // if found, trade it.
+                    // Also check if exchange is open for regular or extended hours. Since daily data comes at 8PM, this allows us prevent the
+                    // algorithm from trading on friday when there is not after-market.
+                    if (contract != null && Securities[contract.Symbol].Exchange.Hours.IsOpen(Time, true))
                     {
-                        _contractSymbol = contract.Symbol;
-                        MarketOrder(_contractSymbol, 1);
+                        MarketOrder(contract.Symbol, 1);
                     }
                 }
             }
-            else
+            // Same as above, check for cases like trading on a friday night.
+            else if (Securities.Values.Where(x => x.Invested).All(x => x.Exchange.Hours.IsOpen(Time, true)))
             {
                 Liquidate();
             }
@@ -111,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 13559;
+        public virtual long DataPoints => 15217;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -123,34 +129,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "152"},
+            {"Total Trades", "118"},
             {"Average Win", "0.09%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.638%"},
-            {"Drawdown", "0.600%"},
-            {"Expectancy", "-0.871"},
-            {"Net Profit", "-0.643%"},
-            {"Sharpe Ratio", "-2.323"},
+            {"Compounding Annual Return", "-0.479%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "-0.835"},
+            {"Net Profit", "-0.483%"},
+            {"Sharpe Ratio", "-1.938"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "99%"},
-            {"Win Rate", "1%"},
-            {"Profit-Loss Ratio", "8.83"},
-            {"Alpha", "-0.004"},
+            {"Loss Rate", "98%"},
+            {"Win Rate", "2%"},
+            {"Profit-Loss Ratio", "8.76"},
+            {"Alpha", "-0.003"},
             {"Beta", "-0.001"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.408"},
+            {"Information Ratio", "-1.397"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "3.612"},
-            {"Total Fees", "$281.20"},
+            {"Treynor Ratio", "5.665"},
+            {"Total Fees", "$263.30"},
             {"Estimated Strategy Capacity", "$1000.00"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Fitness Score", "0.013"},
+            {"Fitness Score", "0.01"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.45"},
+            {"Sortino Ratio", "-1.059"},
             {"Return Over Maximum Drawdown", "-0.992"},
-            {"Portfolio Turnover", "0.04"},
+            {"Portfolio Turnover", "0.031"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -164,7 +170,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "909088689d7030fa33c5da3c15fba98e"}
+            {"OrderListHash", "b75b224669c374dcbacc33f946a1cc7c"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -31,9 +31,12 @@ namespace QuantConnect.Algorithm.CSharp
     /// </summary>
     public class BasicTemplateFuturesFrameworkAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
+        protected virtual bool ExtendedMarketHours => false;
+
         public override void Initialize()
         {
             UniverseSettings.Resolution = Resolution.Minute;
+            UniverseSettings.ExtendedMarketHours = ExtendedMarketHours;
 
             SetStartDate(2013, 10, 07);
             SetEndDate(2013, 10, 11);
@@ -123,70 +126,70 @@ namespace QuantConnect.Algorithm.CSharp
         /// <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;
+        public virtual bool CanRunLocally { get; } = true;
 
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 123378;
+        public virtual long DataPoints => 43786;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public virtual int AlgorithmHistoryDataPoints => 0;
 
         /// <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>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-92.656%"},
-            {"Drawdown", "5.000%"},
+            {"Compounding Annual Return", "-81.734%"},
+            {"Drawdown", "4.100%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-3.312%"},
-            {"Sharpe Ratio", "-6.305"},
-            {"Probabilistic Sharpe Ratio", "9.342%"},
+            {"Net Profit", "-2.169%"},
+            {"Sharpe Ratio", "-10.195"},
+            {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-1.465"},
-            {"Beta", "0.312"},
-            {"Annual Standard Deviation", "0.134"},
-            {"Annual Variance", "0.018"},
-            {"Information Ratio", "-14.77"},
-            {"Tracking Error", "0.192"},
-            {"Treynor Ratio", "-2.718"},
-            {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$52000000.00"},
+            {"Alpha", "-1.206"},
+            {"Beta", "0.238"},
+            {"Annual Standard Deviation", "0.072"},
+            {"Annual Variance", "0.005"},
+            {"Information Ratio", "-15.404"},
+            {"Tracking Error", "0.176"},
+            {"Treynor Ratio", "-3.077"},
+            {"Total Fees", "$4.62"},
+            {"Estimated Strategy Capacity", "$17000000.00"},
             {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
-            {"Fitness Score", "0.009"},
-            {"Kelly Criterion Estimate", "-112.972"},
-            {"Kelly Criterion Probability Value", "0.671"},
-            {"Sortino Ratio", "-8.425"},
-            {"Return Over Maximum Drawdown", "-35.219"},
-            {"Portfolio Turnover", "0.548"},
-            {"Total Insights Generated", "6"},
-            {"Total Insights Closed", "5"},
-            {"Total Insights Analysis Completed", "5"},
-            {"Long Insight Count", "6"},
+            {"Fitness Score", "0.006"},
+            {"Kelly Criterion Estimate", "-50.022"},
+            {"Kelly Criterion Probability Value", "0.711"},
+            {"Sortino Ratio", "-10.107"},
+            {"Return Over Maximum Drawdown", "-51.815"},
+            {"Portfolio Turnover", "0.54"},
+            {"Total Insights Generated", "5"},
+            {"Total Insights Closed", "4"},
+            {"Total Insights Analysis Completed", "4"},
+            {"Long Insight Count", "5"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$-96.12923"},
-            {"Total Accumulated Estimated Alpha Value", "$-15.621"},
-            {"Mean Population Estimated Insight Value", "$-3.1242"},
-            {"Mean Population Direction", "0%"},
+            {"Estimated Monthly Alpha Value", "$-4434.791"},
+            {"Total Accumulated Estimated Alpha Value", "$-720.6535"},
+            {"Mean Population Estimated Insight Value", "$-180.1634"},
+            {"Mean Population Direction", "25%"},
             {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Direction", "25%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "18ffd3a774c68da83d867e3b09e3e05d"}
+            {"OrderListHash", "323b899ae80aa839e320806411665ce7"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm.cs

@@ -0,0 +1,95 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Algorithm.Framework.Alphas;
+using QuantConnect.Algorithm.Framework.Execution;
+using QuantConnect.Algorithm.Framework.Portfolio;
+using QuantConnect.Algorithm.Framework.Risk;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Basic template futures framework algorithm uses framework components to define an algorithm
+    /// that trades futures.
+    /// </summary>
+    public class BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm : BasicTemplateFuturesFrameworkAlgorithm
+    {
+        protected override bool ExtendedMarketHours => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 123753;
+
+        /// <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 Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "-92.667%"},
+            {"Drawdown", "5.000%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-3.314%"},
+            {"Sharpe Ratio", "-6.303"},
+            {"Probabilistic Sharpe Ratio", "9.333%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-1.465"},
+            {"Beta", "0.312"},
+            {"Annual Standard Deviation", "0.134"},
+            {"Annual Variance", "0.018"},
+            {"Information Ratio", "-14.77"},
+            {"Tracking Error", "0.192"},
+            {"Treynor Ratio", "-2.718"},
+            {"Total Fees", "$4.62"},
+            {"Estimated Strategy Capacity", "$52000000.00"},
+            {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
+            {"Fitness Score", "0.009"},
+            {"Kelly Criterion Estimate", "-112.972"},
+            {"Kelly Criterion Probability Value", "0.671"},
+            {"Sortino Ratio", "-8.421"},
+            {"Return Over Maximum Drawdown", "-35.2"},
+            {"Portfolio Turnover", "0.548"},
+            {"Total Insights Generated", "6"},
+            {"Total Insights Closed", "5"},
+            {"Total Insights Analysis Completed", "5"},
+            {"Long Insight Count", "6"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$-96.12923"},
+            {"Total Accumulated Estimated Alpha Value", "$-15.621"},
+            {"Mean Population Estimated Insight Value", "$-3.1242"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "18ffd3a774c68da83d867e3b09e3e05d"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -36,6 +36,9 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="futures" />
     public class BasicTemplateFuturesHistoryAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
+        protected virtual bool ExtendedMarketHours => false;
+        protected virtual int ExpectedHistoryCallCount => 42;
+
         // S&P 500 EMini futures
         private string [] roots = new []
         {
@@ -44,7 +47,6 @@ namespace QuantConnect.Algorithm.CSharp
         };
 
         private int _successCount = 0;
-
         public override void Initialize()
         {
             SetStartDate(2013, 10, 8);
@@ -54,7 +56,7 @@ namespace QuantConnect.Algorithm.CSharp
             foreach (var root in roots)
             {
                 // set our expiry filter for this futures chain
-                AddFuture(root, Resolution.Minute).SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
+                AddFuture(root, Resolution.Minute, extendedMarketHours: ExtendedMarketHours).SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
             }
 
             SetBenchmark(d => 1000000);
@@ -74,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void OnEndOfAlgorithm()
         {
-            if (_successCount < 49)
+            if (_successCount < ExpectedHistoryCallCount)
             {
                 throw new Exception($"Scheduled Event did not assert history call as many times as expected: {_successCount}/49");
             }
@@ -118,7 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
@@ -128,27 +130,27 @@ namespace QuantConnect.Algorithm.CSharp
         /// <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;
+        public virtual bool CanRunLocally { get; } = true;
 
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
-        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+        public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 133616;
+        public virtual long DataPoints => 44184;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 5539;
+        public virtual int AlgorithmHistoryDataPoints => 4818;
 
         /// <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>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "0"},
             {"Average Win", "0%"},

Algorithm.CSharp/BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm.cs

@@ -0,0 +1,106 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to get access to futures history for a given root symbol with extended market hours.
+    /// It also shows how you can prefilter contracts easily based on expirations, and inspect the futures
+    /// chain to pick a specific contract to trade.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="history and warm up" />
+    /// <meta name="tag" content="history" />
+    /// <meta name="tag" content="futures" />
+    public class BasicTemplateFuturesHistoryWithExtendedMarketHoursAlgorithm : BasicTemplateFuturesHistoryAlgorithm
+    {
+        protected override bool ExtendedMarketHours => true;
+        protected override int ExpectedHistoryCallCount => 49;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 134096;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 5539;
+
+        /// <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 Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -31,14 +31,8 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="futures" />
     public class BasicTemplateFuturesHourlyAlgorithm : BasicTemplateFuturesDailyAlgorithm
     {
-        private Symbol _contractSymbol;
         protected override Resolution Resolution => Resolution.Hour;
 
-        /// <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 override bool CanRunLocally { get; } = true;
-
         /// <summary>
         /// This is used by the regression test system to indicate which languages this algorithm is written in.
         /// </summary>
@@ -47,46 +41,41 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 205645;
-
-        /// <summary>
-        /// Data Points count of the algorithm history
-        /// </summary>
-        public override int AlgorithmHistoryDataPoints => 0;
+        public override long DataPoints => 96027;
 
         /// <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 Trades", "1988"},
-            {"Average Win", "0.01%"},
-            {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-4.120%"},
-            {"Drawdown", "4.200%"},
-            {"Expectancy", "-0.870"},
-            {"Net Profit", "-4.150%"},
-            {"Sharpe Ratio", "-6.061"},
-            {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "97%"},
-            {"Win Rate", "3%"},
-            {"Profit-Loss Ratio", "2.92"},
-            {"Alpha", "-0.027"},
-            {"Beta", "-0.006"},
-            {"Annual Standard Deviation", "0.005"},
+            {"Total Trades", "638"},
+            {"Average Win", "0.02%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-1.610%"},
+            {"Drawdown", "1.600%"},
+            {"Expectancy", "-0.841"},
+            {"Net Profit", "-1.622%"},
+            {"Sharpe Ratio", "-5.105"},
+            {"Probabilistic Sharpe Ratio", "0.000%"},
+            {"Loss Rate", "96%"},
+            {"Win Rate", "4%"},
+            {"Profit-Loss Ratio", "3.21"},
+            {"Alpha", "-0.01"},
+            {"Beta", "-0.003"},
+            {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.66"},
+            {"Information Ratio", "-1.473"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "4.919"},
-            {"Total Fees", "$3677.80"},
-            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Treynor Ratio", "3.179"},
+            {"Total Fees", "$1456.18"},
+            {"Estimated Strategy Capacity", "$6000.00"},
             {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
-            {"Fitness Score", "0.128"},
+            {"Fitness Score", "0.045"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-6.856"},
+            {"Sortino Ratio", "-4.328"},
             {"Return Over Maximum Drawdown", "-0.995"},
-            {"Portfolio Turnover", "0.648"},
+            {"Portfolio Turnover", "0.205"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -100,7 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "87d2b127c9859cad9d2c65ac9d76deb5"}
+            {"OrderListHash", "8842e0b890f721371ebf3c25328dee5b"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketAlgorithm.cs

@@ -0,0 +1,210 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add futures for a given underlying asset.
+    /// It also shows how you can prefilter contracts easily based on expirations, and how you
+    /// can inspect the futures chain to pick a specific contract to trade.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="futures" />
+    public class BasicTemplateFuturesWithExtendedMarketAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contractSymbol;
+
+        // S&P 500 EMini futures
+        private const string RootSP500 = Futures.Indices.SP500EMini;
+        public Symbol SP500 = QuantConnect.Symbol.Create(RootSP500, SecurityType.Future, Market.CME);
+
+        // Gold futures
+        private const string RootGold = Futures.Metals.Gold;
+        public Symbol Gold = QuantConnect.Symbol.Create(RootGold, SecurityType.Future, Market.COMEX);
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 10, 10);
+            SetCash(1000000);
+
+            var futureSP500 = AddFuture(RootSP500, extendedMarketHours: true);
+            var futureGold = AddFuture(RootGold, extendedMarketHours: true);
+
+            // set our expiry filter for this futures chain
+            // SetFilter method accepts TimeSpan objects or integer for days.
+            // The following statements yield the same filtering criteria
+            futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
+            futureGold.SetFilter(0, 182);
+
+            var benchmark = AddEquity("SPY");
+            SetBenchmark(benchmark.Symbol);
+
+            var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
+            SetSecurityInitializer(security => seeder.SeedSecurity(security));
+        }
+
+        /// <summary>
+        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
+        /// </summary>
+        /// <param name="slice">The current slice of data keyed by symbol string</param>
+        public override void OnData(Slice slice)
+        {
+            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
+            {
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
+
+            if (!Portfolio.Invested)
+            {
+                foreach(var chain in slice.FutureChains)
+                {
+                    // find the front contract expiring no earlier than in 90 days
+                    var contract = (
+                        from futuresContract in chain.Value.OrderBy(x => x.Expiry)
+                        where futuresContract.Expiry > Time.Date.AddDays(90)
+                        select futuresContract
+                    ).FirstOrDefault();
+
+                    // if found, trade it
+                    if (contract != null)
+                    {
+                        _contractSymbol = contract.Symbol;
+                        MarketOrder(_contractSymbol, 1);
+                    }
+                }
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            // Get the margin requirements
+            var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
+            var futureMarginModel = buyingPowerModel as FutureMarginModel;
+            if (buyingPowerModel == null)
+            {
+                throw new Exception($"Invalid buying power model. Found: {buyingPowerModel.GetType().Name}. Expected: {nameof(FutureMarginModel)}");
+            }
+            var initialOvernight = futureMarginModel.InitialOvernightMarginRequirement;
+            var maintenanceOvernight = futureMarginModel.MaintenanceOvernightMarginRequirement;
+            var initialIntraday = futureMarginModel.InitialIntradayMarginRequirement;
+            var maintenanceIntraday = futureMarginModel.MaintenanceIntradayMarginRequirement;
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            foreach (var addedSecurity in changes.AddedSecurities)
+            {
+                if (addedSecurity.Symbol.SecurityType == SecurityType.Future
+                    && !addedSecurity.Symbol.IsCanonical()
+                    && !addedSecurity.HasData)
+                {
+                    throw new Exception($"Future contracts did not work up as expected: {addedSecurity.Symbol}");
+                }
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 204087;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 340;
+
+        /// <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 Trades", "8282"},
+            {"Average Win", "0.00%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-100.000%"},
+            {"Drawdown", "13.900%"},
+            {"Expectancy", "-0.824"},
+            {"Net Profit", "-13.874%"},
+            {"Sharpe Ratio", "-19.202"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "89%"},
+            {"Win Rate", "11%"},
+            {"Profit-Loss Ratio", "0.64"},
+            {"Alpha", "2.477"},
+            {"Beta", "-0.215"},
+            {"Annual Standard Deviation", "0.052"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-58.37"},
+            {"Tracking Error", "0.295"},
+            {"Treynor Ratio", "4.66"},
+            {"Total Fees", "$19131.42"},
+            {"Estimated Strategy Capacity", "$130000.00"},
+            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
+            {"Fitness Score", "0.032"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-9.217"},
+            {"Return Over Maximum Drawdown", "-7.692"},
+            {"Portfolio Turnover", "304.869"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "85cdd035d7c7a3da178d1c2dff31f1bd"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -0,0 +1,97 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add futures with daily resolution and extended market hours.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="futures" />
+    public class BasicTemplateFuturesWithExtendedMarketDailyAlgorithm : BasicTemplateFuturesDailyAlgorithm
+    {
+        protected override bool ExtendedMarketHours => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 17431;
+
+        /// <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 Trades", "152"},
+            {"Average Win", "0.09%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-0.644%"},
+            {"Drawdown", "0.600%"},
+            {"Expectancy", "-0.872"},
+            {"Net Profit", "-0.649%"},
+            {"Sharpe Ratio", "-2.343"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "99%"},
+            {"Win Rate", "1%"},
+            {"Profit-Loss Ratio", "8.76"},
+            {"Alpha", "-0.004"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.002"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.409"},
+            {"Tracking Error", "0.089"},
+            {"Treynor Ratio", "3.618"},
+            {"Total Fees", "$338.96"},
+            {"Estimated Strategy Capacity", "$1000.00"},
+            {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
+            {"Fitness Score", "0.013"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-1.464"},
+            {"Return Over Maximum Drawdown", "-0.992"},
+            {"Portfolio Turnover", "0.04"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "48bfc4d255420cb589e00cf582554e0a"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -0,0 +1,95 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regressions tests the BasicTemplateFuturesDailyAlgorithm with hour data and extended market hours
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="futures" />
+    public class BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm : BasicTemplateFuturesHourlyAlgorithm
+    {
+        protected override bool ExtendedMarketHours => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 248521;
+
+        /// <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 Trades", "1982"},
+            {"Average Win", "0.01%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-4.666%"},
+            {"Drawdown", "4.700%"},
+            {"Expectancy", "-0.911"},
+            {"Net Profit", "-4.700%"},
+            {"Sharpe Ratio", "-5.792"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "2.04"},
+            {"Alpha", "-0.031"},
+            {"Beta", "-0.008"},
+            {"Annual Standard Deviation", "0.005"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.701"},
+            {"Tracking Error", "0.09"},
+            {"Treynor Ratio", "4.096"},
+            {"Total Fees", "$4521.78"},
+            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
+            {"Fitness Score", "0.131"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-6.211"},
+            {"Return Over Maximum Drawdown", "-0.995"},
+            {"Portfolio Turnover", "0.649"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "2402a307b20aee195b77b8478d7ca64d"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -34,7 +34,7 @@ namespace QuantConnect.Algorithm.CSharp
         protected Symbol SpxOption;
         private ExponentialMovingAverage _emaSlow;
         private ExponentialMovingAverage _emaFast;
-        
+
         protected virtual Resolution Resolution => Resolution.Minute;
         protected virtual int StartDay => 4;
 
@@ -112,7 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 16690;
+        public virtual long DataPoints => 16049;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,34 +124,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "4"},
+            {"Total Trades", "3"},
             {"Average Win", "0%"},
-            {"Average Loss", "-53.10%"},
-            {"Compounding Annual Return", "-92.544%"},
-            {"Drawdown", "10.100%"},
+            {"Average Loss", "-2.45%"},
+            {"Compounding Annual Return", "-62.036%"},
+            {"Drawdown", "9.300%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-9.915%"},
-            {"Sharpe Ratio", "-3.845"},
-            {"Probabilistic Sharpe Ratio", "0.053%"},
+            {"Net Profit", "-3.051%"},
+            {"Sharpe Ratio", "-4.466"},
+            {"Probabilistic Sharpe Ratio", "0.781%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.558"},
-            {"Beta", "0.313"},
-            {"Annual Standard Deviation", "0.112"},
-            {"Annual Variance", "0.013"},
-            {"Information Ratio", "-6.652"},
-            {"Tracking Error", "0.125"},
-            {"Treynor Ratio", "-1.379"},
+            {"Alpha", "-0.172"},
+            {"Beta", "0.076"},
+            {"Annual Standard Deviation", "0.029"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-6.723"},
+            {"Tracking Error", "0.099"},
+            {"Treynor Ratio", "-1.733"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$13000000.00"},
+            {"Estimated Strategy Capacity", "$9100000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.039"},
+            {"Fitness Score", "0.025"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.763"},
-            {"Return Over Maximum Drawdown", "-9.371"},
-            {"Portfolio Turnover", "0.278"},
+            {"Sortino Ratio", "-3.11"},
+            {"Return Over Maximum Drawdown", "-21.007"},
+            {"Portfolio Turnover", "0.332"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -165,7 +165,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "0668385036aba3e95127607dfc2f1a59"}
+            {"OrderListHash", "905811fc779835bf0c514963a20e40f9"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -1,6 +1,22 @@
+/*
+ * 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 System.Collections.Generic;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -12,10 +28,10 @@ namespace QuantConnect.Algorithm.CSharp
         protected override Resolution Resolution => Resolution.Daily;
         protected override int StartDay => 1;
 
-        // two complete weeks starting from the 5th plus the 18th bar
-        protected virtual int ExpectedBarCount => 2 * 5 + 1;
+        // two complete weeks starting from the 5th. The 18th bar is not included since it is a holiday
+        protected virtual int ExpectedBarCount => 2 * 5;
         protected int BarCounter = 0;
-        
+
         /// <summary>
         /// Purchase a contract when we are not invested, liquidate otherwise
         /// </summary>
@@ -30,7 +46,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 Liquidate();
             }
-            
+
             // Count how many slices we receive with SPX data in it to assert later
             if (slice.ContainsKey(Spx))
             {
@@ -59,7 +75,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 122;
+        public override long DataPoints => 0;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -71,48 +87,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "9"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-39.42%"},
-            {"Compounding Annual Return", "394.321%"},
-            {"Drawdown", "0.200%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "8.219%"},
-            {"Sharpe Ratio", "6.812"},
-            {"Probabilistic Sharpe Ratio", "91.380%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2.236"},
-            {"Beta", "-1.003"},
-            {"Annual Standard Deviation", "0.317"},
-            {"Annual Variance", "0.101"},
-            {"Information Ratio", "5.805"},
-            {"Tracking Error", "0.359"},
-            {"Treynor Ratio", "-2.153"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.027"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "1776.081"},
-            {"Portfolio Turnover", "0.027"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "474e8e0e28ee84c869f8c69ec3efe371"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -8,7 +8,7 @@ namespace QuantConnect.Algorithm.CSharp
     public class BasicTemplateIndexHourlyAlgorithm : BasicTemplateIndexDailyAlgorithm
     {
         protected override Resolution Resolution => Resolution.Hour;
-        protected override int ExpectedBarCount => base.ExpectedBarCount * 8;
+        protected override int ExpectedBarCount => base.ExpectedBarCount * 7;
 
         /// <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.
@@ -23,7 +23,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 408;
+        public override long DataPoints => 391;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -35,34 +35,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "70"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.23%"},
-            {"Compounding Annual Return", "-34.441%"},
-            {"Drawdown", "2.000%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-2.028%"},
-            {"Sharpe Ratio", "-11.139"},
-            {"Probabilistic Sharpe Ratio", "0.000%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.269"},
-            {"Beta", "0.086"},
-            {"Annual Standard Deviation", "0.023"},
-            {"Annual Variance", "0.001"},
-            {"Information Ratio", "-3.624"},
-            {"Tracking Error", "0.094"},
-            {"Treynor Ratio", "-3.042"},
+            {"Total Trades", "71"},
+            {"Average Win", "1.28%"},
+            {"Average Loss", "-0.06%"},
+            {"Compounding Annual Return", "-20.546%"},
+            {"Drawdown", "1.800%"},
+            {"Expectancy", "-0.402"},
+            {"Net Profit", "-0.922%"},
+            {"Sharpe Ratio", "-2.856"},
+            {"Probabilistic Sharpe Ratio", "22.230%"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "19.95"},
+            {"Alpha", "-0.155"},
+            {"Beta", "0.025"},
+            {"Annual Standard Deviation", "0.053"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-2.07"},
+            {"Tracking Error", "0.121"},
+            {"Treynor Ratio", "-6.089"},
             {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$310000.00"},
+            {"Estimated Strategy Capacity", "$200000.00"},
             {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
-            {"Fitness Score", "0.002"},
+            {"Fitness Score", "0.01"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-14.51"},
-            {"Return Over Maximum Drawdown", "-17.213"},
-            {"Portfolio Turnover", "0.299"},
+            {"Sortino Ratio", "-6.834"},
+            {"Return Over Maximum Drawdown", "-10.862"},
+            {"Portfolio Turnover", "0.327"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -76,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "3eb56c551f20e2ffa1c56c47c5ee6667"}
+            {"OrderListHash", "9e974939d13fd3255c6291a65d2c1eb9"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -14,10 +14,9 @@
  *
 */
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using QuantConnect.Data;
+using System.Collections.Generic;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -68,7 +67,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 381;
+        public override long DataPoints => 0;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -80,48 +79,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "9"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-0.091%"},
-            {"Drawdown", "0.000%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.008%"},
-            {"Sharpe Ratio", "-4.033"},
-            {"Probabilistic Sharpe Ratio", "0.013%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.001"},
-            {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-0.447"},
-            {"Tracking Error", "0.136"},
-            {"Treynor Ratio", "-4.612"},
-            {"Total Fees", "$0.00"},
-            {"Estimated Strategy Capacity", "$0"},
-            {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
-            {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "0"},
-            {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-50718.291"},
-            {"Return Over Maximum Drawdown", "-11.386"},
-            {"Portfolio Turnover", "0"},
-            {"Total Insights Generated", "0"},
-            {"Total Insights Closed", "0"},
-            {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "0"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$0"},
-            {"Total Accumulated Estimated Alpha Value", "$0"},
-            {"Mean Population Estimated Insight Value", "$0"},
-            {"Mean Population Direction", "0%"},
-            {"Mean Population Magnitude", "0%"},
-            {"Rolling Averaged Population Direction", "0%"},
-            {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "5f5df233d68d9115a0d81785de54e71d"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 2212;
+        public override long DataPoints => 2143;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -50,33 +50,33 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "70"},
+            {"Total Trades", "72"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "0%"},
+            {"Compounding Annual Return", "-0.006%"},
             {"Drawdown", "0.000%"},
-            {"Expectancy", "0.000"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "36.504%"},
+            {"Expectancy", "-0.486"},
+            {"Net Profit", "0.000%"},
+            {"Sharpe Ratio", "-1.628"},
+            {"Probabilistic Sharpe Ratio", "17.439%"},
             {"Loss Rate", "97%"},
             {"Win Rate", "3%"},
-            {"Profit-Loss Ratio", "34.00"},
-            {"Alpha", "0"},
+            {"Profit-Loss Ratio", "17.50"},
+            {"Alpha", "-0"},
             {"Beta", "-0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-0.449"},
             {"Tracking Error", "0.138"},
-            {"Treynor Ratio", "-0"},
+            {"Treynor Ratio", "1.87"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "SPX XL80P59H5E6M|SPX 31"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "0"},
+            {"Sortino Ratio", "-206998.942"},
+            {"Return Over Maximum Drawdown", "-5.808"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -91,7 +91,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "f21910eb98ceaa39e02020de95354d86"}
+            {"OrderListHash", "0df3713aeb32e9c0738200f2a109e2f9"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateIndiaAlgorithm.cs

@@ -43,13 +43,13 @@ namespace QuantConnect.Algorithm.CSharp
             // Equities Resolutions: Tick, Second, Minute, Hour, Daily.
             AddEquity("YESBANK", Resolution.Minute, Market.India);
 
-            //Set Order Prperties as per the requirements for order placement
+            //Set Order Properties as per the requirements for order placement
             DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE);
             //override default productType value set in config.json if needed - order specific productType value
             //DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE, IndiaOrderProperties.IndiaProductType.CNC);
 
             // General Debug statement for acknowledgement
-            Debug("Intialization Done");
+            Debug("Initialization Done");
         }
 
         /// <summary>

Algorithm.CSharp/BasicTemplateIndiaIndexAlgorithm.cs

@@ -52,7 +52,7 @@ namespace QuantConnect.Algorithm.CSharp
             //Trade Index based ETF
             NiftyETF = AddEquity("JUNIORBEES", Resolution.Minute, Market.India).Symbol;
 
-            //Set Order Prperties as per the requirements for order placement
+            //Set Order Properties as per the requirements for order placement
             DefaultOrderProperties = new IndiaOrderProperties(exchange: Exchange.NSE);
 
             _emaSlow = EMA(Nifty, 80);

Algorithm.CSharp/BasicTemplateIntrinioEconomicData.cs

@@ -31,7 +31,7 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="trading and orders" />
     public class BasicTemplateIntrinioEconomicData : QCAlgorithm
     {
-        // Set your Intrinino user and password.
+        // Set your Intrinio user and password.
         public string _user = "";
         public string _password = "";
 
@@ -55,7 +55,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(year: 2013, month: 12, day: 31); //Set End Date
             SetCash(startingCash: 100000); //Set Strategy Cash
 
-            // Set your Intrinino user and password.
+            // Set your Intrinio user and password.
             IntrinioConfig.SetUserAndPassword(_user, _password);
 
             // Set Intrinio config to make 1 call each minute, default is 1 call each 5 seconds.

Algorithm.CSharp/BasicTemplateMultiAssetAlgorithm.cs

@@ -212,7 +212,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {

Algorithm.CSharp/BasicTemplateOptionEquityStrategyAlgorithm.cs

@@ -82,7 +82,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
@@ -102,7 +102,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884208;
+        public long DataPoints => 475788;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -133,7 +133,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$10.00"},
+            {"Total Fees", "$7.50"},
             {"Estimated Strategy Capacity", "$84000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
@@ -155,7 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "82c29cc9db9a300074d6ff136253f4ac"}
+            {"OrderListHash", "92610619a10e30863020cc84aa30be3b"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionStrategyAlgorithm.cs

@@ -92,7 +92,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
@@ -112,7 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884616;
+        public long DataPoints => 476196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "778"},
+            {"Total Trades", "418"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
             {"Compounding Annual Return", "0%"},
@@ -143,8 +143,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$778.00"},
-            {"Estimated Strategy Capacity", "$1000.00"},
+            {"Total Fees", "$418.00"},
+            {"Estimated Strategy Capacity", "$3000.00"},
             {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
@@ -165,7 +165,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "6a88f302b7f29a2c59e4b1e978161da1"}
+            {"OrderListHash", "7bd09d7b4f8da2b9f594ce077cd6f0ee"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionTradesAlgorithm.cs

@@ -87,7 +87,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {

Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs

@@ -89,7 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 884197;
+        public long DataPoints => 475777;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -162,7 +162,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9d9f9248ee8fe30d87ff0a6f6fea5112"}
+            {"OrderListHash", "838e313ba57850227ec810ed8fb85a23"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsDailyAlgorithm.cs

@@ -81,14 +81,14 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {
             Log(orderEvent.ToString());
 
             // Check for our expected OTM option expiry
-            if (orderEvent.Message == "OTM")
+            if (orderEvent.Message.Contains("OTM", StringComparison.InvariantCulture))
             {
                 // Assert it is at midnight (5AM UTC)
                 if (orderEvent.UtcTime != new DateTime(2016, 1, 16, 5, 0, 0))
@@ -175,7 +175,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "c6d089f1fb86379c74a7413a9c2f8553"}
+            {"OrderListHash", "0b52bbe98ade8e3aab943e64fcf4abfe"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -100,7 +100,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1722373;
+        public long DataPoints => 1322413;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -153,7 +153,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "452e7a36e0a95e33d3457a908add3ead"}
+            {"OrderListHash", "0f8537495f5744c02191656d6b3f9205"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -192,7 +192,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "50.0482%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "87603bd45898dd9c456745fa51f989a5"}
+            {"OrderListHash", "83c9fb13ee32284702779eff8d11c608"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsHourlyAlgorithm.cs

@@ -89,7 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Order fill event handler. On an order fill update the resulting information is passed to this method.
         /// </summary>
-        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <param name="orderEvent">Order event details containing details of the events</param>
         /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
         public override void OnOrderEvent(OrderEvent orderEvent)
         {

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsAlgorithm.cs

@@ -0,0 +1,164 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add and trade SPX index weekly options
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateSPXWeeklyIndexOptionsAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spxOption;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 4);
+            SetEndDate(2021, 1, 10);
+            SetCash(1000000);
+
+            var spx = AddIndex("SPX").Symbol;
+
+            // regular option SPX contracts
+            var spxOptions = AddIndexOption(spx);
+            spxOptions.SetFilter(u => u.Strikes(0, 1).Expiration(0, 30));
+
+            // weekly option SPX contracts
+            var spxw = AddIndexOption(spx, "SPXW");
+            spxw.SetFilter(u => u.Strikes(0, 1)
+                 // single week ahead since there are many SPXW contracts and we want to preserve performance
+                 .Expiration(0, 7)
+                 .IncludeWeeklys());
+
+            _spxOption = spxw.Symbol;
+        }
+
+        /// <summary>
+        /// Index EMA Cross trading underlying.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            OptionChain chain;
+            if (slice.OptionChains.TryGetValue(_spxOption, out chain))
+            {
+                // we find at the money (ATM) put contract with closest expiration
+                var atmContract = chain
+                    .OrderBy(x => x.Expiry)
+                    .ThenBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
+                    .ThenByDescending(x => x.Right)
+                    .FirstOrDefault();
+
+                if (atmContract != null)
+                {
+                    // if found, buy until it expires
+                    MarketOrder(atmContract.Symbol, 1);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(orderEvent.ToString());
+        }
+
+        /// <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 virtual 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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 66015;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "5"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-0.69%"},
+            {"Compounding Annual Return", "58.005%"},
+            {"Drawdown", "0.400%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "0.588%"},
+            {"Sharpe Ratio", "1.448"},
+            {"Probabilistic Sharpe Ratio", "51.980%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.288"},
+            {"Beta", "-0.04"},
+            {"Annual Standard Deviation", "0.004"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-98.963"},
+            {"Tracking Error", "0.072"},
+            {"Treynor Ratio", "-0.149"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$8400000.00"},
+            {"Lowest Capacity Asset", "SPXW 31K54PVWHUJHQ|SPX 31"},
+            {"Fitness Score", "0.006"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "496.165"},
+            {"Return Over Maximum Drawdown", "1786.884"},
+            {"Portfolio Turnover", "0.006"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "174bd0a99916d58ca3f12139306940db"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateSPXWeeklyIndexOptionsStrategyAlgorithm.cs

@@ -0,0 +1,168 @@
+/*
+ * 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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Option;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add and trade SPX index weekly option strategy
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateSPXWeeklyIndexOptionsStrategyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spxOption;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 4);
+            SetEndDate(2021, 1, 10);
+            SetCash(1000000);
+
+            var spx = AddIndex("SPX").Symbol;
+
+            // weekly option SPX contracts
+            var spxw = AddIndexOption(spx, "SPXW");
+            spxw.SetFilter(u => u.Strikes(0, 1)
+                 // single week ahead since there are many SPXW contracts and we want to preserve performance
+                 .Expiration(0, 7)
+                 .IncludeWeeklys());
+
+            _spxOption = spxw.Symbol;
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            OptionChain chain;
+            if (slice.OptionChains.TryGetValue(_spxOption, out chain))
+            {
+                // we find the first expiration group of call options and order them in ascending strike 
+                var contracts = chain
+                    .Where(x => x.Right == OptionRight.Call)
+                    .OrderBy(x => x.Expiry)
+                    .GroupBy(x => x.Expiry)
+                    .First()
+                    .OrderBy(x => x.Strike)
+                    .ToList();
+
+                if (contracts.Count > 1)
+                {
+                    var smallerStrike = contracts[0];
+                    var higherStrike = contracts[1];
+
+                    // if found, buy until it expires
+                    var optionStrategy = OptionStrategies.BearCallSpread(_spxOption, smallerStrike.Strike, higherStrike.Strike, smallerStrike.Expiry);
+                    Buy(optionStrategy, 1);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(orderEvent.ToString());
+            if (orderEvent.Symbol.ID.Symbol != "SPXW")
+            {
+                throw new Exception("Unexpected order event symbol!");
+            }
+        }
+
+        /// <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 virtual 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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 35811;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "4"},
+            {"Average Win", "0.46%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "41.434%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "115.281"},
+            {"Net Profit", "0.445%"},
+            {"Sharpe Ratio", "-7.925"},
+            {"Probabilistic Sharpe Ratio", "1.216%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "231.56"},
+            {"Alpha", "-0.012"},
+            {"Beta", "0.001"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-103.222"},
+            {"Tracking Error", "0.069"},
+            {"Treynor Ratio", "-2.449"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$4100000.00"},
+            {"Lowest Capacity Asset", "SPXW XKX6S2GM9PGU|SPX 31"},
+            {"Fitness Score", "0.001"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.001"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "4adb43a8298b9192e0f45d2ef1e5d370"}
+        };
+    }
+}

Algorithm.CSharp/Benchmarks/BasicTemplateBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -28,7 +28,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         public override void Initialize()
         {
             SetStartDate(2000, 01, 01);
-            SetEndDate(2017, 01, 01);
+            SetEndDate(2022, 01, 01);
             SetBenchmark(dt => 1m);
             AddEquity("SPY");
         }
@@ -42,4 +42,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             }
         }
     }
-}
+}

Algorithm.CSharp/Benchmarks/CoarseFineUniverseSelectionBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -34,7 +34,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             UniverseSettings.Resolution = Resolution.Minute;
 
             SetStartDate(2017, 11, 01);
-            SetEndDate(2018, 01, 01);
+            SetEndDate(2018, 3, 01);
             SetCash(50000);
 
             AddUniverse(CoarseSelectionFunction, FineSelectionFunction);
@@ -98,4 +98,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             _changes = changes;
         }
     }
-}
+}

Algorithm.CSharp/Benchmarks/EmptyEquityAndOptions400Benchmark.cs

@@ -0,0 +1,87 @@
+/*
+ * 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.Data;
+
+namespace QuantConnect.Algorithm.CSharp.Benchmarks
+{
+    /// <summary>
+    /// Benchmark Algorithm: Loading and synchronization of 500 equity minute symbols and their options.
+    /// </summary>
+    public class EmptyEquityAndOptions400Benchmark : QCAlgorithm
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2022, 5, 11);
+            SetEndDate(2022, 5, 12);
+
+            var equity_symbols = new[] {
+
+"MARK", "TSN", "DT", "RDW", "CVE", "NXPI", "FIVN", "CLX", "SPXL", "BKSY", "NUGT", "CF", "NEGG",
+"RH", "SIRI", "ITUB", "CSX", "AUR", "LIDR", "CMPS", "DHI", "GLW", "NTES", "CIFR", "S", "HSBC",
+"HIPO", "WTRH", "AMRN", "BIIB", "RIO", "EDIT", "TEAM", "CNK", "BUD", "MILE", "AEHR", "DOCN",
+"CLSK", "BROS", "MLCO", "SBLK", "ICLN", "OPK", "CNC", "SKX", "SESN", "VRM", "ASML", "BBAI",
+"HON", "MRIN", "BLMN", "NTNX", "POWW", "FOUR", "HOG", "GOGO", "MGNI", "GENI", "XPDI",
+"DG", "PSX", "RRC", "CORT", "MET", "UMC", "INMD", "RBAC", "ISRG", "BOX", "DVAX", "CRVS", "HLT",
+"BKNG", "BENE", "CLVS", "ESSC", "PTRA", "BE", "FPAC", "YETI", "DOCS", "DB", "EBON", "RDS.B",
+"ERIC", "BSIG", "INTU", "MNTS", "BCTX", "BLU", "FIS", "MAC", "WMB", "TTWO", "ARDX", "SWBI",
+"ELY", "INDA", "REAL", "ACI", "APRN", "BHP", "CPB", "SLQT", "ARKF", "TSP", "OKE", "NVTA", "META",
+"CSTM", "KMX", "IBB", "AGEN", "WOOF", "MJ", "HYZN", "RSI", "JCI", "EXC", "HPE", "SI", "WPM",
+"PRTY", "BBD", "FVRR", "CANO", "INDI", "MDLZ", "KOLD", "AMBA", "SOXS", "RSX", "ZEN", "PUBM",
+"VLDR", "CI", "ISEE", "GEO", "BKR", "DHR", "GRPN", "NRXP", "ACN", "MAT", "BODY", "ENDP",
+"SHPW", "AVIR", "GPN", "BILL", "BZ", "CERN", "ARVL", "DNMR", "NTR", "FSM", "BMBL", "PAAS",
+"INVZ", "ANF", "CL", "XP", "CS", "KD", "WW", "AHT", "GRTX", "XLC", "BLDP", "HTA", "APT", "BYSI",
+"ENB", "TRIT", "VTNR", "AVCT", "SLI", "CP", "CAH", "ALLY", "FIGS", "PXD", "TPX", "ZI", "BKLN", "SKIN",
+"LNG", "NU", "CX", "GSM", "NXE", "REI", "MNDT", "IP", "BLOK", "IAA", "TIP", "MCHP", "EVTL", "BIGC",
+"IGV", "LOTZ", "EWC", "DRI", "PSTG", "APLS", "KIND", "BBIO", "APPH", "FIVE", "LSPD", "SHAK",
+"COMM", "NAT", "VFC", "AMT", "VRTX", "RGS", "DD", "GBIL", "LICY", "ACHR", "FLR", "HGEN", "TECL",
+"SEAC", "NVS", "NTAP", "ML", "SBSW", "XRX", "UA", "NNOX", "SFT", "FE", "APP", "KEY", "CDEV",
+"DPZ", "BARK", "SPR", "CNQ", "XL", "AXSM", "ECH", "RNG", "AMLP", "ENG", "BTI", "REKR",
+"STZ", "BK", "HEAR", "LEV", "SKT", "HBI", "ALB", "CAG", "MNKD", "NMM", "BIRD", "CIEN", "SILJ",
+"STNG", "GUSH", "GIS", "PRPL", "SDOW", "GNRC", "ERX", "GES", "CPE", "FBRX", "WM", "ESTC",
+"GOED", "STLD", "LILM", "JNK", "BOIL", "ALZN", "IRBT", "KOPN", "AU", "TPR", "RWLK", "TROX",
+"TMO", "AVDL", "XSPA", "JKS", "PACB", "LOGI", "BLK", "REGN", "CFVI", "EGHT", "ATNF", "PRU",
+"URBN", "KMB", "SIX", "CME", "ENVX", "NVTS", "CELH", "CSIQ", "GSL", "PAA", "WU", "MOMO",
+"TOL", "WEN", "GTE", "EXAS", "GDRX", "PVH", "BFLY", "SRTY", "UDOW", "NCR", "ALTO", "CRTD",
+"GOCO", "ALK", "TTM", "DFS", "VFF", "ANTM", "FREY", "WY", "ACWI", "PNC", "SYY", "SNY", "CRK",
+"SO", "XXII", "PBF", "AER", "RKLY", "SOL", "CND", "MPLX", "JNPR", "FTCV", "CLR", "XHB", "YY",
+"POSH", "HIMS", "LIFE", "XENE", "ADM", "ROST", "MIR", "NRG", "AAP", "SSYS", "KBH", "KKR", "PLAN",
+"DUK", "WIMI", "DBRG", "WSM", "LTHM", "OVV", "CFLT", "EWT", "UNFI", "TX", "EMR", "IMGN", "K",
+"ONON", "UNIT", "LEVI", "ADTX", "UPWK", "DBA", "VOO", "FATH", "URI", "MPW", "JNUG", "RDFN",
+"OSCR", "WOLF", "SYF", "GOGL", "HES", "PHM", "CWEB", "ALDX", "BTWN", "AFL", "PPL", "CIM"
+
+            };
+            Settings.DataSubscriptionLimit = 1000000;
+            SetWarmUp(TimeSpan.FromDays(1));
+            foreach(var ticker in equity_symbols)
+            {
+                var option = AddOption(ticker);
+                option.SetFilter(1, 7, 0, 90);
+            }
+
+            AddEquity("SPY");
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (IsWarmingUp)
+            {
+                return;
+            }
+            Quit("The end!");
+        }
+    }
+}

Algorithm.CSharp/Benchmarks/EmptyMinute400EquityBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -30,8 +30,8 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
     {
         public override void Initialize()
         {
-            SetStartDate(2015, 10, 1);
-            SetEndDate(2015, 11, 15);
+            SetStartDate(2015, 9, 1);
+            SetEndDate(2015, 12, 1);
             foreach (var symbol in Symbols.Equity.All.Take(400))
             {
                 AddSecurity(SecurityType.Equity, symbol);
@@ -402,4 +402,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             #endregion
         }
     }
-}
+}

Algorithm.CSharp/Benchmarks/EmptySingleSecuritySecondEquityBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -27,7 +27,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         public override void Initialize()
         {
             SetStartDate(2008, 01, 01);
-            SetEndDate(2009, 01, 01);
+            SetEndDate(2008, 06, 01);
             SetBenchmark(dt => 1m);
             AddEquity("SPY", Resolution.Second);
         }
@@ -36,4 +36,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         {
         }
     }
-}
+}

Algorithm.CSharp/Benchmarks/HistoryRequestBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -23,7 +23,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         public override void Initialize()
         {
             SetStartDate(2010, 01, 01);
-            SetEndDate(2018, 01, 01);
+            SetEndDate(2022, 01, 01);
             SetCash(10000);
             _symbol = AddEquity("SPY").Symbol;
         }
@@ -38,4 +38,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             var dailyOpen = dailyHistory.Open;
         }
     }
-}
+}

Algorithm.CSharp/Benchmarks/IndicatorRibbonBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -32,7 +32,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         public override void Initialize()
         {
             SetStartDate(2010, 01, 01);
-            SetEndDate(2018, 01, 01);
+            SetEndDate(2022, 01, 01);
 
             AddSecurity(SecurityType.Equity, "SPY", Resolution.Minute);
 
@@ -51,7 +51,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
                 // define an indicator that takes the output of the sma and pipes it into our delay indicator
                 var delayedSma = delay.Of(sma);
 
-                // register our new 'delayedSma' for automaic updates on a daily resolution
+                // register our new 'delayedSma' for automatic updates on a daily resolution
                 RegisterIndicator(_spy, delayedSma, Resolution.Daily, data => data.Value);
 
                 return delayedSma;
@@ -68,4 +68,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             }
         }
     }
-}
+}

Algorithm.CSharp/Benchmarks/ScheduledEventsBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
 /*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
@@ -24,7 +24,7 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         public override void Initialize()
         {
             SetStartDate(2011, 1, 1);
-            SetEndDate(2018, 1, 1);
+            SetEndDate(2022, 1, 1);
             SetCash(100000);
             AddEquity("SPY");
             foreach (int period in Enumerable.Range(0, 300))
@@ -37,4 +37,4 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         public override void OnData(Slice data) { }
         private void Rebalance() { }
     }
-}
+}

Algorithm.CSharp/Benchmarks/StatefulCoarseUniverseSelectionBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -29,8 +29,8 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         {
             UniverseSettings.Resolution = Resolution.Daily;
 
-            SetStartDate(2017, 11, 01);
-            SetEndDate(2018, 01, 01);
+            SetStartDate(2017, 1, 01);
+            SetEndDate(2019, 1, 01);
             SetCash(50000);
 
             AddUniverse(CoarseSelectionFunction);

Algorithm.CSharp/Benchmarks/StatelessCoarseUniverseSelectionBenchmark.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -27,8 +27,8 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
         {
             UniverseSettings.Resolution = Resolution.Daily;
 
-            SetStartDate(2017, 11, 01);
-            SetEndDate(2018, 01, 01);
+            SetStartDate(2017, 1, 01);
+            SetEndDate(2019, 1, 01);
             SetCash(50000);
 
             AddUniverse(CoarseSelectionFunction);

Algorithm.CSharp/BubbleAlgorithm.cs

@@ -166,7 +166,7 @@ namespace QuantConnect.Algorithm.CSharp
                     }
 
                 }
-                // Cape Ratio is missing from orignial data
+                // Cape Ratio is missing from original data
                 // Most recent cape data is most likely to be missing
                 else if (_currCape == 0)
                 {
@@ -246,7 +246,7 @@ namespace QuantConnect.Algorithm.CSharp
         }
 
         /// <summary>
-        /// Reader Method :: using set of arguements we specify read out type. Enumerate
+        /// Reader Method :: using set of arguments we specify read out type. Enumerate
         /// until the end of the data stream or file. E.g. Read CSV file line by line and convert
         /// into data types.
         /// </summary>

Algorithm.CSharp/CallingRFromCSharp.cs

@@ -1,70 +0,0 @@
-/*
-  * 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 QuantConnect.Data;
- using RDotNet;
- using System.Linq;
-
- namespace QuantConnect.Algorithm.CSharp
- {
-    /// <summary>
-    /// Demonstration of the R-integration for calling external statistics operations in QuantConnect.
-    /// </summary>
-    /// <meta name="tag" content="using r" />
-    /// <meta name="tag" content="statistics libraries" />
-    public class CallingRFromCSharp : QCAlgorithm
-     {
-         private Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
-
-         /// <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);  //Set Start Date
-             SetEndDate(2013, 10, 11);    //Set End Date
-             SetCash(100000);             //Set Strategy Cash
-             // Find more symbols here: http://quantconnect.com/data
-             AddEquity("SPY", Resolution.Second);
-
-             var engine = REngine.GetInstance();
-             engine.Evaluate("print('This is from R command.')");
-             // .NET Framework array to R vector.
-             var group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
-             engine.SetSymbol("group1", group1);
-             // Direct parsing from R script.
-             var group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
-             // Test difference of mean and get the P-value.
-             var testResult = engine.Evaluate("t.test(group1, group2)").AsList();
-             var p = testResult["p.value"].AsNumeric().First();
-             // you should always dispose of the REngine properly.
-             // After disposing of the engine, you cannot reinitialize nor reuse it
-             engine.Dispose();
-
-         }
-
-         /// <summary>
-         /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
-         /// </summary>
-         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
-         public override void OnData(Slice data)
-         {
-             if (!Portfolio.Invested)
-             {
-                 SetHoldings(_spy, 1);
-             }
-         }
-     }
- }

Algorithm.CSharp/ComboLegLimitOrderAlgorithm.cs

@@ -0,0 +1,112 @@
+/*
+ * 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 QuantConnect.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test combo leg limit orders
+    /// </summary>
+    public class ComboLegLimitOrderAlgorithm : ComboOrderAlgorithm
+    {
+        protected override IEnumerable<OrderTicket> PlaceComboOrder(List<Leg> legs, int quantity, decimal? limitPrice = null)
+        {
+            return ComboLegLimitOrder(legs, quantity);
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            base.OnEndOfAlgorithm();
+
+            if (FillOrderEvents.Zip(OrderLegs).Any(x => x.Second.OrderPrice < x.First.FillPrice))
+            {
+                throw new Exception($"Limit price expected to be greater that the fill price for each order. Limit prices: {string.Join(",", OrderLegs.Select(x => x.OrderPrice))} Fill prices: {string.Join(",", FillOrderEvents.Select(x => x.FillPrice))}");
+            }
+        }
+
+        /// <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 override bool CanRunLocally => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 475788;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "3"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$7.50"},
+            {"Estimated Strategy Capacity", "$8000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "c0f4b5d5c796e17949f7ec42c6569ce4"}
+        };
+    }
+}

Algorithm.CSharp/ComboLimitOrderAlgorithm.cs

@@ -0,0 +1,179 @@
+/*
+ * 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 QuantConnect.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test combo limit orders
+    /// </summary>
+    public class ComboLimitOrderAlgorithm : ComboOrderAlgorithm
+    {
+        private decimal _limitPrice;
+        private int _comboQuantity;
+
+        private int _fillCount;
+
+        private decimal _liquidatedQuantity;
+
+        private bool _liquidated;
+
+        protected override int ExpectedFillCount
+        {
+            get
+            {
+                // times 2 because of liquidation
+                return OrderLegs.Count * 2;
+            }
+        }
+
+        protected override IEnumerable<OrderTicket> PlaceComboOrder(List<Leg> legs, int quantity, decimal? limitPrice)
+        {
+            _limitPrice = limitPrice.Value;
+            _comboQuantity = quantity;
+
+            legs.ForEach(x => { x.OrderPrice = null; });
+
+            return ComboLimitOrder(legs, quantity, _limitPrice);
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            base.OnOrderEvent(orderEvent);
+
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                _fillCount++;
+                if (_fillCount == OrderLegs.Count)
+                {
+                    Liquidate();
+                }
+                else if (_fillCount < 2 * OrderLegs.Count)
+                {
+                    _liquidatedQuantity += orderEvent.FillQuantity;
+                }
+                else if (_fillCount == 2 * OrderLegs.Count)
+                {
+                    _liquidated = true;
+                    var totalComboQuantity = _comboQuantity * OrderLegs.Select(x => x.Quantity).Sum();
+
+                    if (_liquidatedQuantity != totalComboQuantity)
+                    {
+                        throw new Exception($"Liquidated quantity {_liquidatedQuantity} does not match combo quantity {totalComboQuantity}");
+                    }
+
+                    if (Portfolio.TotalHoldingsValue != 0)
+                    {
+                        throw new Exception($"Portfolio value {Portfolio.TotalPortfolioValue} is not zero");
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            base.OnEndOfAlgorithm();
+
+            if (_limitPrice == null)
+            {
+                throw new Exception("Limit price was not set");
+            }
+
+            var fillPricesSum = FillOrderEvents.Take(OrderLegs.Count).Select(x => x.FillPrice * x.FillQuantity / _comboQuantity).Sum();
+            if (_limitPrice < fillPricesSum)
+            {
+                throw new Exception($"Limit price expected to be greater that the sum of the fill prices ({fillPricesSum}), but was {_limitPrice}");
+            }
+
+            if (!_liquidated)
+            {
+                throw new Exception("Combo order was not liquidated");
+            }
+        }
+
+        /// <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 override bool CanRunLocally => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 475788;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "6"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$17.50"},
+            {"Estimated Strategy Capacity", "$5000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "17a5427a539f2b02a626fda15d6eb13f"}
+        };
+    }
+}

Algorithm.CSharp/ComboMarketOrderAlgorithm.cs

@@ -0,0 +1,101 @@
+/*
+ * 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 QuantConnect.Orders;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test combo market orders
+    /// </summary>
+    public class ComboMarketOrderAlgorithm : ComboOrderAlgorithm
+    {
+        protected override IEnumerable<OrderTicket> PlaceComboOrder(List<Leg> legs, int quantity, decimal? limitPrice = null)
+        {
+            legs.ForEach(x => { x.OrderPrice = null; });
+            return ComboMarketOrder(legs, quantity);
+        }
+
+        /// <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 override bool CanRunLocally => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public override Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 475788;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "3"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$7.50"},
+            {"Estimated Strategy Capacity", "$9000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "47f02f5139c4c4def9b26e8f5433fdcc"}
+        };
+    }
+}

Algorithm.CSharp/ComboOrderAlgorithm.cs

@@ -0,0 +1,139 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that combo orders are filled correctly and at the same time
+    /// </summary>
+    public abstract class ComboOrderAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _optionSymbol;
+
+        protected List<OrderEvent> FillOrderEvents { get; private set; } = new();
+
+        protected List<Leg> OrderLegs { get; private set; }
+
+        protected int ComboOrderQuantity { get; } = 10;
+
+        protected virtual int ExpectedFillCount
+        {
+            get
+            {
+                return OrderLegs.Count;
+            }
+        }
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(10000);
+
+            var equity = AddEquity("GOOG", leverage: 4, fillDataForward: true);
+            var option = AddOption(equity.Symbol, fillDataForward: true);
+            _optionSymbol = option.Symbol;
+
+            option.SetFilter(u => u.Strikes(-2, +2)
+                  .Expiration(0, 180));
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (OrderLegs == null)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var callContracts = chain.Where(contract => contract.Right == OptionRight.Call)
+                        .GroupBy(x => x.Expiry)
+                        .OrderBy(grouping => grouping.Key)
+                        .First()
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    // Let's wait until we have at least three contracts
+                    if (callContracts.Count < 3)
+                    {
+                        return;
+                    }
+
+                    OrderLegs = new List<Leg>()
+                    {
+                        Leg.Create(callContracts[0].Symbol, 1, 16.7m),
+                        Leg.Create(callContracts[1].Symbol, -2, 14.6m),
+                        Leg.Create(callContracts[2].Symbol, 1, 14.0m)
+                    };
+                    PlaceComboOrder(OrderLegs, ComboOrderQuantity, 1.9m);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($" Order Event: {orderEvent}");
+
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                FillOrderEvents.Add(orderEvent);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (OrderLegs == null)
+            {
+                throw new Exception("Combo order legs were not initialized");
+            }
+
+            if (FillOrderEvents.Count != ExpectedFillCount)
+            {
+                throw new Exception($"Expected {ExpectedFillCount} fill order events, found {FillOrderEvents.Count}");
+            }
+
+            var fillTimes = FillOrderEvents.Select(x => x.UtcTime).ToHashSet();
+            if (fillTimes.Count != 1)
+            {
+                throw new Exception($"Expected all fill order events to have the same time, found {string.Join(", ", fillTimes)}");
+            }
+
+            if (FillOrderEvents.Zip(OrderLegs).Any(x => x.First.FillQuantity != x.Second.Quantity * ComboOrderQuantity))
+            {
+                throw new Exception("Fill quantity does not match expected quantity for at least one order leg");
+            }
+        }
+
+        protected abstract IEnumerable<OrderTicket> PlaceComboOrder(List<Leg> legs, int quantity, decimal? limitPrice = null);
+
+        public abstract bool CanRunLocally { get; }
+
+        public abstract Language[] Languages { get; }
+
+        public abstract long DataPoints { get; }
+
+        public abstract int AlgorithmHistoryDataPoints { get; }
+
+        public abstract Dictionary<string, string> ExpectedStatistics { get; }
+    }
+}

Algorithm.CSharp/ComboOrderTicketDemoAlgorithm.cs

@@ -0,0 +1,375 @@
+
+/*
+ * 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.Interfaces;
+using QuantConnect.Orders;
+using System.Linq;
+using QuantConnect.Data.Market;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm for testing submit/update/cancel for combo orders
+    /// </summary>
+    public class ComboOrderTicketDemoAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private readonly List<OrderTicket> _openMarketOrders = new();
+        private readonly List<OrderTicket> _openLegLimitOrders = new();
+        private readonly List<OrderTicket> _openLimitOrders = new();
+
+        private Symbol _optionSymbol;
+        private List<Leg> _orderLegs;
+
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+
+            var equity = AddEquity("GOOG", leverage: 4, fillDataForward: true);
+            var option = AddOption(equity.Symbol, fillDataForward: true);
+            _optionSymbol = option.Symbol;
+
+            option.SetFilter(u => u.Strikes(-2, +2)
+                  .Expiration(0, 180));
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (_orderLegs == null)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && data.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var callContracts = chain.Where(contract => contract.Right == OptionRight.Call)
+                        .GroupBy(x => x.Expiry)
+                        .OrderBy(grouping => grouping.Key)
+                        .First()
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    // Let's wait until we have at least three contracts
+                    if (callContracts.Count < 3)
+                    {
+                        return;
+                    }
+
+                    _orderLegs = new List<Leg>()
+                    {
+                        Leg.Create(callContracts[0].Symbol, 1),
+                        Leg.Create(callContracts[1].Symbol, -2),
+                        Leg.Create(callContracts[2].Symbol, 1),
+                    };
+                }
+            }
+            else
+            {
+                // COMBO MARKET ORDERS
+
+                ComboMarketOrders();
+
+                // COMBO LIMIT ORDERS
+
+                ComboLimitOrders();
+
+                // COMBO LEG LIMIT ORDERS
+
+                ComboLegLimitOrders();
+            }
+        }
+
+        private void ComboMarketOrders()
+        {
+            if (_openMarketOrders.Count != 0 || _orderLegs == null)
+            {
+                return;
+            }
+
+            Log("Submitting combo market orders");
+
+            var tickets = ComboMarketOrder(_orderLegs, 2, asynchronous: false);
+            _openMarketOrders.AddRange(tickets);
+
+            tickets = ComboMarketOrder(_orderLegs, 2, asynchronous: true);
+            _openMarketOrders.AddRange(tickets);
+
+            foreach (var ticket in tickets)
+            {
+                var response = ticket.Cancel("Attempt to cancel combo market order");
+                if (response.IsSuccess)
+                {
+                    throw new Exception("Combo market orders should fill instantly, they should not be cancelable in backtest mode: " + response.OrderId);
+                }
+            }
+        }
+
+        private void ComboLimitOrders()
+        {
+            if (_openLimitOrders.Count == 0)
+            {
+                Log("Submitting ComboLimitOrder");
+
+                var currentPrice = _orderLegs.Sum(leg => leg.Quantity * Securities[leg.Symbol].Close);
+
+                var tickets = ComboLimitOrder(_orderLegs, 2, currentPrice - 2m);
+                _openLimitOrders.AddRange(tickets);
+
+                // These won't fill, we will test cancel with this
+                tickets = ComboLimitOrder(_orderLegs, -2, currentPrice + 3m);
+                _openLimitOrders.AddRange(tickets);
+            }
+            else
+            {
+                var combo1 = _openLimitOrders.Take(_orderLegs.Count).ToList();
+                var combo2 = _openLimitOrders.Skip(_orderLegs.Count).Take(_orderLegs.Count).ToList();
+
+                // check if either is filled and cancel the other
+                if (CheckGroupOrdersForFills(combo1, combo2))
+                {
+                    return;
+                }
+
+                // if neither order has filled, bring in the limits by a penny
+
+                var ticket = combo1[0];
+                var newLimit = Math.Round(ticket.Get(OrderField.LimitPrice) + 0.01m, 2);
+                Debug($"Updating limits - Combo 1 {ticket.OrderId}: {newLimit.ToStringInvariant("0.00")}");
+                ticket.Update(new UpdateOrderFields
+                {
+                    LimitPrice = newLimit,
+                    Tag = "Update #" + (ticket.UpdateRequests.Count + 1)
+                });
+
+                ticket = combo2[0];
+                newLimit = Math.Round(ticket.Get(OrderField.LimitPrice) - 0.01m, 2);
+                Debug($"Updating limits - Combo 2 {ticket.OrderId}: {newLimit.ToStringInvariant("0.00")}");
+                ticket.Update(new UpdateOrderFields
+                {
+                    LimitPrice = newLimit,
+                    Tag = "Update #" + (ticket.UpdateRequests.Count + 1)
+                });
+            }
+        }
+
+        private void ComboLegLimitOrders()
+        {
+            if (_openLegLimitOrders.Count == 0)
+            {
+                Log("Submitting ComboLegLimitOrder");
+
+                // submit a limit order to buy 2 shares at .1% below the bar's close
+                foreach (var leg in _orderLegs)
+                {
+                    var close = Securities[leg.Symbol].Close;
+                    leg.OrderPrice = close * .999m;
+                }
+
+                var tickets = ComboLegLimitOrder(_orderLegs, quantity: 2);
+                _openLegLimitOrders.AddRange(tickets);
+
+                // submit another limit order to sell 2 shares at .1% above the bar's close
+                foreach (var leg in _orderLegs)
+                {
+                    var close = Securities[leg.Symbol].Close;
+                    leg.OrderPrice = close * 1.001m;
+                }
+
+                tickets = ComboLegLimitOrder(_orderLegs, -2);
+                _openLegLimitOrders.AddRange(tickets);
+            }
+            else
+            {
+                var combo1 = _openLegLimitOrders.Take(_orderLegs.Count).ToList();
+                var combo2 = _openLegLimitOrders.Skip(_orderLegs.Count).Take(_orderLegs.Count).ToList();
+
+                // check if either is filled and cancel the other
+                if (CheckGroupOrdersForFills(combo1, combo2))
+                {
+                    return;
+                }
+
+                // if neither order has filled, bring in the limits by a penny
+
+                foreach (var ticket in combo1)
+                {
+                    var newLimit = ticket.Get(OrderField.LimitPrice) + (ticket.Quantity > 0 ? 1m : -1m) * 0.01m;
+                    Debug($"Updating limits - Combo #1: {newLimit.ToStringInvariant("0.00")}");
+
+                    ticket.Update(new UpdateOrderFields
+                    {
+                        LimitPrice = newLimit,
+                        Tag = "Update #" + (ticket.UpdateRequests.Count + 1)
+                    });
+                }
+
+                foreach (var ticket in combo2)
+                {
+                    var newLimit = ticket.Get(OrderField.LimitPrice) + (ticket.Quantity > 0 ? 1m : -1m) * 0.01m;
+                    Debug($"Updating limits - Combo #2: {newLimit.ToStringInvariant("0.00")}");
+
+                    ticket.Update(new UpdateOrderFields
+                    {
+                        LimitPrice = newLimit,
+                        Tag = "Update #" + (ticket.UpdateRequests.Count + 1)
+                    });
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            var order = Transactions.GetOrderById(orderEvent.OrderId);
+
+            if (orderEvent.Quantity == 0)
+            {
+                throw new Exception("OrderEvent quantity is Not expected to be 0, it should hold the current order Quantity");
+            }
+            if (orderEvent.Quantity != order.Quantity)
+            {
+                throw new Exception("OrderEvent quantity should hold the current order Quantity");
+            }
+            if (order is ComboLegLimitOrder && orderEvent.LimitPrice == 0)
+            {
+                throw new Exception("OrderEvent.LimitPrice is not expected to be 0 for ComboLegLimitOrder");
+            }
+        }
+
+        private bool CheckGroupOrdersForFills(List<OrderTicket> combo1, List<OrderTicket> combo2)
+        {
+            if (combo1.All(x => x.Status == OrderStatus.Filled))
+            {
+                if (combo2.Any(x => x.Status.IsOpen()))
+                {
+                    Log(combo1[0].OrderType + ": Canceling combo #2, combo #1 is filled.");
+                    combo2.ForEach(x => x.Cancel("Combo #1 filled."));
+                }
+
+                return true;
+            }
+
+            if (combo2.All(x => x.Status == OrderStatus.Filled))
+            {
+                if (combo1.Any(x => x.Status.IsOpen()))
+                {
+                    Log(combo1[0].OrderType + ": Canceling combo #1, combo #2 is filled.");
+                    combo1.ForEach(x => x.Cancel("Combo #2 filled."));
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var filledOrders = Transactions.GetOrders(x => x.Status == OrderStatus.Filled).ToList();
+            var orderTickets = Transactions.GetOrderTickets().ToList();
+            var openOrders = Transactions.GetOpenOrders();
+            var openOrderTickets = Transactions.GetOpenOrderTickets().ToList();
+            var remainingOpenOrders = Transactions.GetOpenOrdersRemainingQuantity();
+
+            // We expect 3 of the limit orders to be canceled
+            var expectedOrdersCount = 18;
+            var expectedFillsCount = 15;
+            if (filledOrders.Count != expectedFillsCount || orderTickets.Count != expectedOrdersCount)
+            {
+                throw new Exception($"There were expected {expectedFillsCount} filled orders and {expectedOrdersCount} order tickets, but there were {filledOrders.Count} filled orders and {orderTickets.Count} order tickets");
+            }
+            if (openOrders.Count != 0 || openOrderTickets.Count != 0)
+            {
+                throw new Exception($"No open orders or tickets were expected");
+            }
+            if (remainingOpenOrders != 0m)
+            {
+                throw new Exception($"No remaining quantity to be filled from open orders was expected");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 475788;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "15"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$15.00"},
+            {"Estimated Strategy Capacity", "$8000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "06328fbd9bbb25d9ec80b9151a7ceb7b"}
+        };
+    }
+}

Algorithm.CSharp/CompleteOrderTagUpdateAlgorithm.cs

@@ -0,0 +1,216 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm asserting that closed orders can be updated with a new tag
+    /// </summary>
+    public class CompleteOrderTagUpdateAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private static string TagAfterFill = "This is the tag set after order was filled.";
+        private static string TagAfterCanceled = "This is the tag set after order was canceled.";
+
+        private OrderTicket _marketOrderTicket;
+        private OrderTicket _limitOrderTicket;
+
+        private int _quantity = 100;
+
+        private Symbol _spy;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+            SetCash(100000);
+
+            _spy = AddEquity("SPY", Resolution.Minute).Symbol;
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                // a limit order to test the tag update after order was canceled
+                if (_limitOrderTicket == null)
+                {
+                    // low price, we don't want it to fill since we are canceling it
+                    _limitOrderTicket = LimitOrder(_spy, 100, Securities[_spy].Price * 0.1m);
+                    _limitOrderTicket.Cancel();
+                }
+                // a market order to test the tag update after order was filled
+                else
+                {
+                    Buy(_spy, _quantity);
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Canceled)
+            {
+                if (orderEvent.OrderId != _limitOrderTicket.OrderId)
+                {
+                    throw new Exception("The only canceled order should have been the limit order.");
+                }
+
+                // update canceled order tag
+                UpdateOrderTag(_limitOrderTicket, TagAfterCanceled, "Error updating order tag after canceled");
+            }
+            else if (orderEvent.Status == OrderStatus.Filled)
+            {
+                _marketOrderTicket = Transactions.GetOrderTickets(x => x.OrderType == OrderType.Market).Single();
+                if (orderEvent.OrderId != _marketOrderTicket.OrderId)
+                {
+                    throw new Exception("The only filled order should have been the market order.");
+                }
+
+                // try to update a field other than the tag
+                var updateFields = new UpdateOrderFields();
+                updateFields.Quantity = 50;
+                var response = _marketOrderTicket.Update(updateFields);
+                if (response.IsSuccess)
+                {
+                    throw new Exception("The market order quantity should not have been updated.");
+                }
+
+                // update filled order tag
+                UpdateOrderTag(_marketOrderTicket, TagAfterFill, "Error updating order tag after fill");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            // check the filled order
+            AssertOrderTagUpdate(_marketOrderTicket, TagAfterFill, "filled");
+            if (_marketOrderTicket.Quantity != _quantity || _marketOrderTicket.QuantityFilled != _quantity)
+            {
+                throw new Exception("The market order quantity should not have been updated.");
+            }
+
+            // check the canceled order
+            AssertOrderTagUpdate(_limitOrderTicket, TagAfterCanceled, "canceled");
+        }
+
+        private void AssertOrderTagUpdate(OrderTicket ticket, string expectedTag, string orderAction)
+        {
+            if (ticket == null)
+            {
+                throw new Exception($"The order ticket was not set for the {orderAction} order");
+            }
+
+            if (ticket.Tag != expectedTag)
+            {
+                throw new Exception($"Order ticket tag was not updated after order was {orderAction}");
+            }
+
+            var order = Transactions.GetOrderById(ticket.OrderId);
+            if (order.Tag != expectedTag)
+            {
+                throw new Exception($"Order tag was not updated after order was {orderAction}");
+            }
+        }
+
+        private static void UpdateOrderTag(OrderTicket ticket, string tag, string errorMessagePrefix)
+        {
+            var updateFields = new UpdateOrderFields();
+            updateFields.Tag = tag;
+            var response = ticket.Update(updateFields);
+
+            if (response.IsError)
+            {
+                throw new Exception($"{errorMessagePrefix}: {response.ErrorMessage}");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { 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>
+        /// 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 Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "21.706%"},
+            {"Drawdown", "0.300%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.251%"},
+            {"Sharpe Ratio", "5.312"},
+            {"Probabilistic Sharpe Ratio", "67.483%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.115"},
+            {"Beta", "0.144"},
+            {"Annual Standard Deviation", "0.032"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-9.515"},
+            {"Tracking Error", "0.191"},
+            {"Treynor Ratio", "1.182"},
+            {"Total Fees", "$1.00"},
+            {"Estimated Strategy Capacity", "$210000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.036"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "72.372"},
+            {"Portfolio Turnover", "0.036"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "cbf413671bbd919d0113b4f2a6a9608f"}
+        };
+    }
+}

Algorithm.CSharp/ConsolidateRegressionAlgorithm.cs

@@ -30,7 +30,9 @@ namespace QuantConnect.Algorithm.CSharp
     /// </summary>
     public class ConsolidateRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private List<int> _consolidationCount;
+        private List<int> _consolidationCounts;
+        private List<SimpleMovingAverage> _smas;
+        private List<DateTime> _lastSmaUpdates;
         private int _customDataConsolidator;
         private Symbol _symbol;
 
@@ -40,38 +42,37 @@ namespace QuantConnect.Algorithm.CSharp
         public override void Initialize()
         {
             SetStartDate(2013, 10, 08);
-            SetEndDate(2013, 10, 09);
+            SetEndDate(2013, 10, 20);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
             _symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
             AddFutureContract(_symbol);
 
-            _consolidationCount = new List<int> { 0, 0, 0, 0, 0, 0, 0, 0 };
+            _consolidationCounts = Enumerable.Repeat(0, 9).ToList();
+            _smas = _consolidationCounts.Select(_ => new SimpleMovingAverage(10)).ToList();
+            _lastSmaUpdates = _consolidationCounts.Select(_ => DateTime.MinValue).ToList();
 
-            var sma = new SimpleMovingAverage(10);
             Consolidate<QuoteBar>(_symbol, time => new CalendarInfo(time.RoundDown(TimeSpan.FromDays(1)), TimeSpan.FromDays(1)),
-                bar => UpdateQuoteBar(sma, bar, 0));
+                bar => UpdateQuoteBar(bar, 0));
 
-            var sma2 = new SimpleMovingAverage(10);
-            Consolidate<QuoteBar>(_symbol, TimeSpan.FromDays(1), bar => UpdateQuoteBar(sma2, bar, 1));
+            Consolidate<QuoteBar>(_symbol, time => new CalendarInfo(time.RoundDown(TimeSpan.FromDays(1)), TimeSpan.FromDays(1)),
+                TickType.Quote, bar => UpdateQuoteBar(bar, 1));
 
-            var sma3 = new SimpleMovingAverage(10);
-            Consolidate(_symbol, Resolution.Daily, TickType.Quote, (Action<QuoteBar>)(bar => UpdateQuoteBar(sma3, bar, 2)));
+            Consolidate<QuoteBar>(_symbol, TimeSpan.FromDays(1), bar => UpdateQuoteBar(bar, 2));
 
-            var sma4 = new SimpleMovingAverage(10);
-            Consolidate(_symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(sma4, bar, 3));
+            Consolidate(_symbol, Resolution.Daily, TickType.Quote, (Action<QuoteBar>)(bar => UpdateQuoteBar(bar, 3)));
 
-            var sma5 = new SimpleMovingAverage(10);
-            Consolidate<TradeBar>(_symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(sma5, bar, 4));
+            Consolidate(_symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(bar, 4));
+
+            Consolidate<TradeBar>(_symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(bar, 5));
 
             // custom data
-            var sma6 = new SimpleMovingAverage(10);
             var symbol = AddData<CustomDataRegressionAlgorithm.Bitcoin>("BTC", Resolution.Minute).Symbol;
             Consolidate<TradeBar>(symbol, TimeSpan.FromDays(1), bar => _customDataConsolidator++);
 
             try
             {
-                Consolidate<QuoteBar>(symbol, TimeSpan.FromDays(1), bar => { UpdateQuoteBar(sma6, bar, -1); });
+                Consolidate<QuoteBar>(symbol, TimeSpan.FromDays(1), bar => { UpdateQuoteBar(bar, -1); });
                 throw new Exception($"Expected {nameof(ArgumentException)} to be thrown");
             }
             catch (ArgumentException)
@@ -80,41 +81,56 @@ namespace QuantConnect.Algorithm.CSharp
             }
 
             // Test using abstract T types, through defining a 'BaseData' handler
-            var sma7 = new SimpleMovingAverage(10);
-            Consolidate(_symbol, Resolution.Daily, null, (Action<BaseData>)(bar => UpdateBar(sma7, bar, 5)));
+            Consolidate(_symbol, Resolution.Daily, null, (Action<BaseData>)(bar => UpdateBar(bar, 6)));
 
-            var sma8 = new SimpleMovingAverage(10);
-            Consolidate(_symbol, TimeSpan.FromDays(1), null, (Action<BaseData>)(bar => UpdateBar(sma8, bar, 6)));
+            Consolidate(_symbol, TimeSpan.FromDays(1), null, (Action<BaseData>)(bar => UpdateBar(bar, 7)));
 
-            var sma9 = new SimpleMovingAverage(10);
-            Consolidate(_symbol, TimeSpan.FromDays(1), (Action<BaseData>)(bar => UpdateBar(sma9, bar, 7)));
+            Consolidate(_symbol, TimeSpan.FromDays(1), (Action<BaseData>)(bar => UpdateBar(bar, 8)));
         }
-        private void UpdateBar(SimpleMovingAverage sma, BaseData tradeBar, int position)
+        private void UpdateBar(BaseData tradeBar, int position)
         {
             if (!(tradeBar is TradeBar))
             {
                 throw new Exception("Expected a TradeBar");
             }
-            _consolidationCount[position]++;
-            sma.Update(tradeBar.EndTime, tradeBar.Value);
+            _consolidationCounts[position]++;
+            _smas[position].Update(tradeBar.EndTime, tradeBar.Value);
+            _lastSmaUpdates[position] = tradeBar.EndTime;
         }
-        private void UpdateTradeBar(SimpleMovingAverage sma, TradeBar tradeBar, int position)
+        private void UpdateTradeBar(TradeBar tradeBar, int position)
         {
-            _consolidationCount[position]++;
-            sma.Update(tradeBar.EndTime, tradeBar.High);
+            _consolidationCounts[position]++;
+            _smas[position].Update(tradeBar.EndTime, tradeBar.High);
+            _lastSmaUpdates[position] = tradeBar.EndTime;
         }
-        private void UpdateQuoteBar(SimpleMovingAverage sma, QuoteBar quoteBar, int position)
+        private void UpdateQuoteBar(QuoteBar quoteBar, int position)
         {
-            _consolidationCount[position]++;
-            sma.Update(quoteBar.EndTime, quoteBar.High);
+            _consolidationCounts[position]++;
+            _smas[position].Update(quoteBar.EndTime, quoteBar.High);
+            _lastSmaUpdates[position] = quoteBar.EndTime;
         }
 
         public override void OnEndOfAlgorithm()
         {
-            if (_consolidationCount.Any(i => i != 3) || _customDataConsolidator == 0)
+            var expectedConsolidations = 8;
+
+            if (_consolidationCounts.Any(i => i != expectedConsolidations) || _customDataConsolidator == 0)
             {
                 throw new Exception("Unexpected consolidation count");
             }
+
+            for (var i = 0; i < _smas.Count; i++)
+            {
+                if (_smas[i].Samples != expectedConsolidations)
+                {
+                    throw new Exception($"Expected {expectedConsolidations} samples in each SMA but found {_smas[i].Samples} in SMA in index {i}");
+                }
+
+                if (_smas[i].Current.Time != _lastSmaUpdates[i])
+                {
+                    throw new Exception($"Expected SMA in index {i} to have been last updated at {_lastSmaUpdates[i]} but was {_smas[i].Current.Time}");
+                }
+            }
         }
 
         /// <summary>
@@ -142,7 +158,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 8091;
+        public long DataPoints => 12244;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -157,31 +173,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
+            {"Compounding Annual Return", "6636.699%"},
+            {"Drawdown", "15.900%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Net Profit", "16.178%"},
+            {"Sharpe Ratio", "640.32"},
+            {"Probabilistic Sharpe Ratio", "99.824%"},
             {"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", "$20.35"},
-            {"Estimated Strategy Capacity", "$19000000.00"},
+            {"Alpha", "636.128"},
+            {"Beta", "5.924"},
+            {"Annual Standard Deviation", "1.012"},
+            {"Annual Variance", "1.024"},
+            {"Information Ratio", "696.123"},
+            {"Tracking Error", "0.928"},
+            {"Treynor Ratio", "109.405"},
+            {"Total Fees", "$23.65"},
+            {"Estimated Strategy Capacity", "$210000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.138"},
+            {"Fitness Score", "0.811"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-1.727"},
-            {"Return Over Maximum Drawdown", "-12.061"},
-            {"Portfolio Turnover", "4.916"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "511.605"},
+            {"Portfolio Turnover", "0.811"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -195,7 +211,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7c841ca58a4385f42236838e5bf0c382"}
+            {"OrderListHash", "dd38e7b94027d20942a5aa9ac31a9a7f"}
         };
     }
 }

Algorithm.CSharp/ContinuousBackMonthRawFutureRegressionAlgorithm.cs

@@ -134,7 +134,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 815242;
+        public long DataPoints => 689388;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -147,32 +147,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "2"},
-            {"Average Win", "1.21%"},
+            {"Average Win", "1.50%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "2.412%"},
+            {"Compounding Annual Return", "2.993%"},
             {"Drawdown", "1.600%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.209%"},
-            {"Sharpe Ratio", "0.782"},
-            {"Probabilistic Sharpe Ratio", "40.528%"},
+            {"Net Profit", "1.496%"},
+            {"Sharpe Ratio", "0.814"},
+            {"Probabilistic Sharpe Ratio", "42.511%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "-0.005"},
-            {"Beta", "0.099"},
-            {"Annual Standard Deviation", "0.022"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-2.724"},
+            {"Beta", "0.114"},
+            {"Annual Standard Deviation", "0.026"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-2.672"},
             {"Tracking Error", "0.076"},
-            {"Treynor Ratio", "0.171"},
-            {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$810000000.00"},
+            {"Treynor Ratio", "0.184"},
+            {"Total Fees", "$4.30"},
+            {"Estimated Strategy Capacity", "$2200000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.007"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0.587"},
-            {"Return Over Maximum Drawdown", "1.952"},
+            {"Sortino Ratio", "0.275"},
+            {"Return Over Maximum Drawdown", "2.606"},
             {"Portfolio Turnover", "0.01"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -187,7 +187,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "95c62255290b4ad375579b398290230c"}
+            {"OrderListHash", "ebeeac4c57ccacef7b458b6160190f5b"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureBackMonthRegressionAlgorithm.cs

@@ -97,13 +97,16 @@ namespace QuantConnect.Algorithm.CSharp
                 _lastDateLog = Time;
 
                 Log($"{Time}- {Securities[_continuousContract.Symbol].GetLastData()}");
-                if (Portfolio.Invested)
+                if (_continuousContract.Exchange.ExchangeOpen)
                 {
-                    Liquidate();
+                    if (Portfolio.Invested)
+                    {
+                        Liquidate();
+                    }
+                    else
+                    {
+                        Buy(_continuousContract.Mapped, 1);
                 }
-                else
-                {
-                    Buy(_continuousContract.Mapped, 1);
                 }
 
                 if(Time.Month == 1 && Time.Year == 2013)
@@ -147,7 +150,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 875590;
+        public long DataPoints => 709638;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -160,32 +163,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "3"},
-            {"Average Win", "1.21%"},
+            {"Average Win", "1.50%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "2.392%"},
+            {"Compounding Annual Return", "2.959%"},
             {"Drawdown", "1.600%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.199%"},
-            {"Sharpe Ratio", "0.775"},
-            {"Probabilistic Sharpe Ratio", "40.287%"},
+            {"Net Profit", "1.479%"},
+            {"Sharpe Ratio", "0.805"},
+            {"Probabilistic Sharpe Ratio", "42.183%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.006"},
-            {"Beta", "0.099"},
-            {"Annual Standard Deviation", "0.022"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-2.726"},
+            {"Alpha", "-0.005"},
+            {"Beta", "0.114"},
+            {"Annual Standard Deviation", "0.026"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-2.676"},
             {"Tracking Error", "0.076"},
-            {"Treynor Ratio", "0.169"},
-            {"Total Fees", "$5.55"},
-            {"Estimated Strategy Capacity", "$67000000.00"},
+            {"Treynor Ratio", "0.181"},
+            {"Total Fees", "$6.45"},
+            {"Estimated Strategy Capacity", "$180000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.01"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0.516"},
-            {"Return Over Maximum Drawdown", "1.935"},
+            {"Sortino Ratio", "0.32"},
+            {"Return Over Maximum Drawdown", "2.576"},
             {"Portfolio Turnover", "0.016"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -200,7 +203,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "5fc26c7f1f2d9fff97d36a5b58853840"}
+            {"OrderListHash", "88e74055be58b3759f493b2c47e4c097"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureHistoryRegressionAlgorithm.cs

@@ -114,7 +114,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 40881;
+        public virtual long DataPoints => 9949;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <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>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "1"},
             {"Average Win", "0%"},
@@ -145,15 +145,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$1.85"},
-            {"Estimated Strategy Capacity", "$290000000.00"},
+            {"Total Fees", "$2.15"},
+            {"Estimated Strategy Capacity", "$3600000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Fitness Score", "0.408"},
+            {"Fitness Score", "0.414"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.408"},
+            {"Portfolio Turnover", "0.414"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -167,7 +167,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9408389924d9b7333a9f0a4f64b08d27"}
+            {"OrderListHash", "1fcd459f69177160b35f7daf96b01a0d"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureHistoryTimeSpanWarmupRegressionAlgorithm.cs

@@ -0,0 +1,39 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures History Regression algorithm. Asserting and showcasing the behavior of adding a continuous future
+    /// </summary>
+    public class ContinuousFutureHistoryTimeSpanWarmupRegressionAlgorithm : ContinuousFutureHistoryRegressionAlgorithm
+    {
+        public override void Initialize()
+        {
+            base.Initialize();
+            // We want to match the start time of the base algorithm. ES futures data time zone is UTC, algorithm time zone is new york (default).
+            // Base algorithm warmup is 1 bar of daily resolution starts at 8 PM new york time of T-1. So to match the same start time
+            // we go back a 1 day + 4 hours. This is calculated by 'Time.GetStartTimeForTradeBars'
+            SetWarmup(TimeSpan.FromHours(24 + 4));
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 14915;
+    }
+}

Algorithm.CSharp/ContinuousFutureLimitIfTouchedOrderRegressionAlgorithm.cs

@@ -0,0 +1,137 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures Regression algorithm reproducing GH issue #6490 asserting limit if touched order works as expected
+    /// </summary>
+    public class ContinuousFutureLimitIfTouchedOrderRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private OrderTicket _ticket;
+        private Future _continuousContract;
+
+        /// <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, 6);
+            SetEndDate(2013, 10, 10);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.LastTradingDay
+            );
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (_ticket == null)
+            {
+                _ticket = LimitIfTouchedOrder(_continuousContract.Mapped, -1, _continuousContract.Price, _continuousContract.Price);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_ticket == null || _ticket.Status != OrderStatus.Filled)
+            {
+                throw new Exception("Order ticket was not placed or filled!");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 19876;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "-99.258%"},
+            {"Drawdown", "6.300%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "-6.129%"},
+            {"Sharpe Ratio", "-2.182"},
+            {"Probabilistic Sharpe Ratio", "5.175%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.976"},
+            {"Beta", "-0.022"},
+            {"Annual Standard Deviation", "0.449"},
+            {"Annual Variance", "0.202"},
+            {"Information Ratio", "-2.231"},
+            {"Tracking Error", "0.513"},
+            {"Treynor Ratio", "43.626"},
+            {"Total Fees", "$2.15"},
+            {"Estimated Strategy Capacity", "$2600000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.028"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-1.666"},
+            {"Return Over Maximum Drawdown", "-18.301"},
+            {"Portfolio Turnover", "0.206"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "f0e1235ff2d29030e374d966b3e225fa"}
+        };
+    }
+}

Algorithm.CSharp/ContinuousFutureRegressionAlgorithm.cs

@@ -148,6 +148,12 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 throw new Exception($"Unexpected symbol changed events: {_mappings.Count}, was expecting {expectedMappingCounts}");
             }
+
+            var securities = Securities.Values.Where(sec => !sec.IsTradable && !sec.Symbol.IsCanonical() && sec.Symbol.SecurityType == SecurityType.Future).ToList();
+            if (securities.Count != 1)
+            {
+                throw new Exception("We should have a non tradable future contract security!");
+            }
         }
 
         /// <summary>
@@ -163,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 875590;
+        public long DataPoints => 709638;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -176,32 +182,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "3"},
-            {"Average Win", "1.21%"},
+            {"Average Win", "1.50%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "2.392%"},
+            {"Compounding Annual Return", "2.959%"},
             {"Drawdown", "1.600%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.199%"},
-            {"Sharpe Ratio", "0.775"},
-            {"Probabilistic Sharpe Ratio", "40.287%"},
+            {"Net Profit", "1.479%"},
+            {"Sharpe Ratio", "0.805"},
+            {"Probabilistic Sharpe Ratio", "42.183%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.006"},
-            {"Beta", "0.099"},
-            {"Annual Standard Deviation", "0.022"},
-            {"Annual Variance", "0"},
-            {"Information Ratio", "-2.726"},
+            {"Alpha", "-0.005"},
+            {"Beta", "0.114"},
+            {"Annual Standard Deviation", "0.026"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-2.676"},
             {"Tracking Error", "0.076"},
-            {"Treynor Ratio", "0.169"},
-            {"Total Fees", "$5.55"},
-            {"Estimated Strategy Capacity", "$67000000.00"},
+            {"Treynor Ratio", "0.181"},
+            {"Total Fees", "$6.45"},
+            {"Estimated Strategy Capacity", "$180000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.01"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0.516"},
-            {"Return Over Maximum Drawdown", "1.935"},
+            {"Sortino Ratio", "0.32"},
+            {"Return Over Maximum Drawdown", "2.576"},
             {"Portfolio Turnover", "0.016"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -216,7 +222,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "8ad040c62ad255e4f9cd423364147e85"}
+            {"OrderListHash", "88e74055be58b3759f493b2c47e4c097"}
         };
     }
 }

Algorithm.CSharp/ContinuousFuturesDailyRegressionAlgorithm.cs

@@ -0,0 +1,168 @@
+/*
+ * 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.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Continuous Futures Regression algorithm asserting bug fix for GH issue #6840
+    /// </summary>
+    public class ContinuousFuturesDailyRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private SymbolChangedEvent _symbolChangedEvent;
+        private Future _continuousContract;
+        private decimal _previousFactor;
+
+        /// <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, 08);
+            SetEndDate(2013, 12, 25);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.ForwardPanamaCanal,
+                dataMappingMode: DataMappingMode.LastTradingDay,
+                contractDepthOffset: 0,
+                resolution: Resolution.Daily
+            );
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            foreach (var changedEvent in data.SymbolChangedEvents.Values)
+            {
+                if (changedEvent.Symbol == _continuousContract.Symbol)
+                {
+                    _symbolChangedEvent = changedEvent;
+                    Log($"{Time} - SymbolChanged event: {changedEvent}. New expiration {_continuousContract.Mapped.ID.Date}");
+                }
+            }
+
+            if (!data.Bars.TryGetValue(_continuousContract.Symbol, out var continuousBar))
+            {
+                return;
+            }
+
+            var mappedBar = Securities[_continuousContract.Mapped].Cache.GetData<TradeBar>();
+            if (mappedBar == null || continuousBar.EndTime != mappedBar.EndTime)
+            {
+                return;
+            }
+            var priceFactor = continuousBar.Close - mappedBar.Close;
+            Debug($"{Time} - Price factor {priceFactor}");
+
+            if(_symbolChangedEvent != null)
+            {
+                if(_previousFactor == priceFactor)
+                {
+                    throw new Exception($"Price factor did not change after symbol changed! {Time} {priceFactor}");
+                }
+
+                Quit("We asserted what we wanted");
+            }
+            _previousFactor = priceFactor;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_symbolChangedEvent == null)
+            {
+                throw new Exception("Unexpected a symbol changed event but got none!");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1395;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "-4.63"},
+            {"Tracking Error", "0.088"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/CorrectConsolidatedBarTypeForTickTypesAlgorithm.cs

@@ -0,0 +1,156 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm asserting that consolidated bars are of type <see cref="QuoteBar"/>
+    /// when <see cref="QCAlgorithm.Consolidate()"/> is called with <see cref="TickType.Quote"/>
+    /// </summary>
+    public class CorrectConsolidatedBarTypeForTickTypesAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _quoteTickConsolidatorCalled;
+        private bool _tradeTickConsolidatorCalled;
+        private bool _openInterestTickConsolidatorCalled;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 7);
+
+            var symbol = AddEquity("SPY", Resolution.Tick).Symbol;
+
+            Consolidate<QuoteBar>(symbol, TimeSpan.FromMinutes(1), TickType.Quote, QuoteTickConsolidationHandler);
+            Consolidate<TradeBar>(symbol, TimeSpan.FromMinutes(1), TickType.Trade, TradeTickConsolidationHandler);
+            Consolidate<TradeBar>(symbol, TimeSpan.FromMinutes(1), TickType.OpenInterest, OpenInterestTickConsolidationHandler);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (Time.Hour > 9)
+            {
+                Quit("Early quit to save time");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_quoteTickConsolidatorCalled)
+            {
+                throw new Exception("QuoteTickConsolidationHandler was not called");
+            }
+
+            if (!_tradeTickConsolidatorCalled)
+            {
+                throw new Exception("TradeTickConsolidationHandler was not called");
+            }
+
+            if (!_openInterestTickConsolidatorCalled)
+            {
+                throw new Exception("OpenInterestTickConsolidationHandler was not called");
+            }
+        }
+
+        private void QuoteTickConsolidationHandler(QuoteBar consolidatedBar)
+        {
+            _quoteTickConsolidatorCalled = true;
+        }
+
+        private void TradeTickConsolidationHandler(TradeBar consolidatedBar)
+        {
+            _tradeTickConsolidatorCalled = true;
+        }
+
+        private void OpenInterestTickConsolidationHandler(TradeBar consolidatedBar)
+        {
+            _openInterestTickConsolidatorCalled = true;
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 393736;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/CoveredCallComboLimitOrderAlgorithm.cs

@@ -0,0 +1,165 @@
+/*
+ * 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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm tarding an equity Covered Call option strategy using a combo limit order
+    /// </summary>
+    public class CoveredCallComboLimitOrderAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private DateTime _submittionTime;
+        private Symbol _optionSymbol;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(200000);
+
+            var equity = AddEquity("GOOG", leverage: 4);
+            var option = AddOption(equity.Symbol);
+            _optionSymbol = option.Symbol;
+
+            option.SetFilter(u => u.Strikes(-1, +1).Expiration(0, 30));
+        }
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested && Transactions.OrdersCount == 0)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    // we find at the money (ATM) call contract with closest expiration
+                    var atmContract = chain
+                        .OrderBy(x => x.Expiry)
+                        .Where(contract => contract.Right == OptionRight.Call && chain.Underlying.Price > contract.Strike - 10)
+                        .OrderBy(x => x.Strike)
+                        .First();
+
+                    var optionPrice = Securities[atmContract.Symbol].AskPrice;
+                    var underlyingPrice = Securities["GOOG"].AskPrice;
+
+                    // covered call
+                    var legs = new List<Leg> { Leg.Create(atmContract.Symbol, -1), Leg.Create(atmContract.Symbol.Underlying, 100) };
+
+                    var comboPrice = underlyingPrice - optionPrice;
+                    if(comboPrice < 734m)
+                    {
+                        // just to make sure the price makes sense
+                        throw new Exception($"Unexpected combo price {comboPrice}");
+                    }
+                    // place order slightly bellow price
+                    ComboLimitOrder(legs, 6, comboPrice - 0.5m);
+
+                    _submittionTime = Time;
+                }
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(orderEvent.ToString());
+            if (orderEvent.Status.IsFill() && (Time - _submittionTime) < TimeSpan.FromMinutes(10))
+            {
+                // we want to make sure we fill because the price moved and hit our limit price
+                throw new Exception($"Unexpected fill time {Time} submittion time {_submittionTime}");
+            }
+        }
+
+        /// <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 => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 465320;
+
+        /// </summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$3.00"},
+            {"Estimated Strategy Capacity", "$8000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "addfbee330e5b80a186acf3c2d776982"}
+        };
+    }
+}

Algorithm.CSharp/CryptoBaseCurrencyFeeRegressionAlgorithm.cs

@@ -73,12 +73,12 @@ namespace QuantConnect.Algorithm.CSharp
                     || filledEvent.FillQuantity != ticket.QuantityFilled
                     || (0.1m - filledEvent.OrderFee.Value.Amount) != ticket.QuantityFilled)
                 {
-                    throw new Exception($"Unexpected BaseCurrency porfoltio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
+                    throw new Exception($"Unexpected BaseCurrency portfolio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
                 }
 
                 if (Portfolio.CashBook[quoteCurrency].Amount != (initialQuoteCurrency - 0.1m * filledEvent.FillPrice))
                 {
-                    throw new Exception($"Unexpected QuoteCurrency porfoltio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
+                    throw new Exception($"Unexpected QuoteCurrency portfolio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
                 }
 
                 if (Securities[_symbol].Holdings.Quantity != (0.1m - filledEvent.OrderFee.Value.Amount))

Algorithm.CSharp/CryptoFutureDailyMarginInterestRegressionAlgorithm.cs

@@ -0,0 +1,87 @@
+/*
+ * 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;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Daily regression algorithm trading ADAUSDT binance futures long and short asserting the behavior
+    /// </summary>
+    public class CryptoFutureDailyMarginInterestRegressionAlgorithm : CryptoFutureHourlyMarginInterestRegressionAlgorithm
+    {
+        /// <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()
+        {
+            Initialize(Resolution.Daily);
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 8;
+
+        /// <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 Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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.15"},
+            {"Estimated Strategy Capacity", "$3400000000.00"},
+            {"Lowest Capacity Asset", "ADAUSDT 18R"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "1287.681"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "2000bf26738e407192574b27086338a6"}
+        };
+    }
+}

Algorithm.CSharp/CryptoFutureHourlyMarginInterestRegressionAlgorithm.cs

@@ -0,0 +1,186 @@
+/*
+ * 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.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Brokerages;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.CryptoFuture;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Daily regression algorithm trading ADAUSDT binance futures long and short asserting the behavior
+    /// </summary>
+    public class CryptoFutureHourlyMarginInterestRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Dictionary<Symbol, int> _interestPerSymbol = new();
+        private decimal _amountAfterTrade;
+
+        protected CryptoFuture AdaUsdt;
+
+        /// <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()
+        {
+            Initialize(Resolution.Hour);
+        }
+
+        protected virtual void Initialize(Resolution resolution)
+        {
+            SetStartDate(2022, 12, 12);
+            SetEndDate(2022, 12, 13);
+
+            SetTimeZone(NodaTime.DateTimeZone.Utc);
+            SetBrokerageModel(BrokerageName.BinanceCoinFutures, AccountType.Margin);
+
+            AdaUsdt = AddCryptoFuture("ADAUSDT", resolution);
+
+            // Default USD cash, set 1M but it wont be used
+            SetCash(1000000);
+
+            // the amount of USDT we need to hold to trade 'ADAUSDT'
+            AdaUsdt.QuoteCurrency.SetAmount(200);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            var interestRates = data.Get<MarginInterestRate>();
+            foreach (var interestRate in interestRates)
+            {
+                _interestPerSymbol.TryGetValue(interestRate.Key, out var count);
+                _interestPerSymbol[interestRate.Key] = ++count;
+
+                var cachedInterestRate = Securities[interestRate.Key].Cache.GetData<MarginInterestRate>();
+                if (cachedInterestRate != interestRate.Value)
+                {
+                    throw new Exception($"Unexpected cached margin interest rate for {interestRate.Key}!");
+                }
+            }
+
+            if(interestRates.Count != data.MarginInterestRates.Count)
+            {
+                throw new Exception($"Unexpected cached margin interest rate data!");
+            }
+
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            Buy(AdaUsdt.Symbol, 1000);
+
+            _amountAfterTrade = Portfolio.CashBook["USDT"].Amount;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_interestPerSymbol.TryGetValue(AdaUsdt.Symbol, out var count) || count != 1)
+            {
+                throw new Exception($"Unexpected interest rate count {count}");
+            }
+
+            // negative because we are long. Rate * Value * Application Count
+            var expectedFundingRateDifference = - (0.0001m * AdaUsdt.Holdings.HoldingsValue * 3);
+            var finalCash = Portfolio.CashBook["USDT"].Amount;
+            if (Math.Abs(finalCash - (_amountAfterTrade + expectedFundingRateDifference)) > Math.Abs(expectedFundingRateDifference * 0.05m))
+            {
+                throw new Exception($"Unexpected interest rate count {Portfolio.CashBook["USDT"].Amount}");
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug(Time + " " + orderEvent);
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 50;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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.15"},
+            {"Estimated Strategy Capacity", "$330000000.00"},
+            {"Lowest Capacity Asset", "ADAUSDT 18R"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "bc23ede7bb4af4d941723ed225768fcb"}
+        };
+    }
+}

Algorithm.CSharp/CustomDataBitcoinAlgorithm.cs

@@ -92,6 +92,16 @@ namespace QuantConnect.Algorithm.CSharp
             public decimal VolumeBTC = 0;
             public decimal VolumeUSD = 0;
 
+            /// <summary>
+            /// The end time of this data. Some data covers spans (trade bars)
+            /// and as such we want to know the entire time span covered
+            /// </summary>
+            /// <remarks>
+            /// This property is overriden to allow different values for Time and EndTime
+            /// if they are set in the Reader. In the base implementation EndTime equals Time
+            /// </remarks>
+            public override DateTime EndTime { get; set; }
+
             /// <summary>
             /// 1. DEFAULT CONSTRUCTOR: Custom data types need a default constructor.
             /// We search for a default constructor so please provide one here. It won't be used for data, just to generate the "Factory".

Algorithm.CSharp/CustomDataPropertiesRegressionAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 10489;
+        public long DataPoints => 10491;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -124,30 +124,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "157.498%"},
+            {"Compounding Annual Return", "155.211%"},
             {"Drawdown", "84.800%"},
             {"Expectancy", "0"},
-            {"Net Profit", "5319.081%"},
-            {"Sharpe Ratio", "2.086"},
-            {"Probabilistic Sharpe Ratio", "69.456%"},
+            {"Net Profit", "5123.242%"},
+            {"Sharpe Ratio", "2.067"},
+            {"Probabilistic Sharpe Ratio", "68.833%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.747"},
-            {"Beta", "0.047"},
-            {"Annual Standard Deviation", "0.84"},
-            {"Annual Variance", "0.706"},
-            {"Information Ratio", "1.922"},
+            {"Alpha", "1.732"},
+            {"Beta", "0.043"},
+            {"Annual Standard Deviation", "0.841"},
+            {"Annual Variance", "0.707"},
+            {"Information Ratio", "1.902"},
             {"Tracking Error", "0.848"},
-            {"Treynor Ratio", "37.47"},
+            {"Treynor Ratio", "40.467"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "2.269"},
-            {"Return Over Maximum Drawdown", "1.858"},
+            {"Sortino Ratio", "2.236"},
+            {"Return Over Maximum Drawdown", "1.83"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -190,6 +190,16 @@ namespace QuantConnect.Algorithm.CSharp
             public decimal VolumeBTC = 0;
             public decimal VolumeUSD = 0;
 
+            /// <summary>
+            /// The end time of this data. Some data covers spans (trade bars)
+            /// and as such we want to know the entire time span covered
+            /// </summary>
+            /// <remarks>
+            /// This property is overriden to allow different values for Time and EndTime
+            /// if they are set in the Reader. In the base implementation EndTime equals Time
+            /// </remarks>
+            public override DateTime EndTime { get; set; }
+
             /// <summary>
             /// 1. DEFAULT CONSTRUCTOR: Custom data types need a default constructor.
             /// We search for a default constructor so please provide one here. It won't be used for data, just to generate the "Factory".

Algorithm.CSharp/CustomDataRegressionAlgorithm.cs

@@ -110,7 +110,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 8942;
+        public long DataPoints => 8943;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -125,30 +125,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "157.655%"},
+            {"Compounding Annual Return", "155.365%"},
             {"Drawdown", "84.800%"},
             {"Expectancy", "0"},
-            {"Net Profit", "5319.007%"},
-            {"Sharpe Ratio", "2.123"},
-            {"Probabilistic Sharpe Ratio", "70.581%"},
+            {"Net Profit", "5123.170%"},
+            {"Sharpe Ratio", "2.103"},
+            {"Probabilistic Sharpe Ratio", "69.967%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.776"},
-            {"Beta", "0.059"},
+            {"Alpha", "1.76"},
+            {"Beta", "0.055"},
             {"Annual Standard Deviation", "0.84"},
             {"Annual Variance", "0.706"},
-            {"Information Ratio", "1.962"},
-            {"Tracking Error", "0.847"},
-            {"Treynor Ratio", "30.455"},
+            {"Information Ratio", "1.942"},
+            {"Tracking Error", "0.848"},
+            {"Treynor Ratio", "32.317"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "2.271"},
-            {"Return Over Maximum Drawdown", "1.86"},
+            {"Sortino Ratio", "2.238"},
+            {"Return Over Maximum Drawdown", "1.832"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -191,6 +191,16 @@ namespace QuantConnect.Algorithm.CSharp
             public decimal VolumeBTC = 0;
             public decimal VolumeUSD = 0;
 
+            /// <summary>
+            /// The end time of this data. Some data covers spans (trade bars)
+            /// and as such we want to know the entire time span covered
+            /// </summary>
+            /// <remarks>
+            /// This property is overriden to allow different values for Time and EndTime
+            /// if they are set in the Reader. In the base implementation EndTime equals Time
+            /// </remarks>
+            public override DateTime EndTime { get; set; }
+
             /// <summary>
             /// 1. DEFAULT CONSTRUCTOR: Custom data types need a default constructor.
             /// We search for a default constructor so please provide one here. It won't be used for data, just to generate the "Factory".

Algorithm.CSharp/CustomDataTypeHistoryAlgorithm.cs

@@ -0,0 +1,170 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Algorithm asserting that
+    /// </summary>
+    public class CustomDataTypeHistoryAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _symbol;
+
+        public override void Initialize()
+        {
+            SetStartDate(2017, 8, 20);
+            SetEndDate(2017, 8, 20);
+
+            _symbol = AddData<CustomDataType>("CustomDataType", Resolution.Hour).Symbol;
+
+            var history = History<CustomDataType>(_symbol, 48, Resolution.Hour).ToList();
+
+            Log($"History count: {history.Count}");
+
+            if (history.Count == 0)
+            {
+                throw new Exception("History request returned no data");
+            }
+
+            var history2 = History<CustomDataType>(new[] { _symbol }, 48, Resolution.Hour).ToList();
+
+            if (history2.Count != history.Count)
+            {
+                throw new Exception("History requests returned different data");
+            }
+
+        }
+
+        public class CustomDataType : DynamicData
+        {
+            public decimal Open;
+            public decimal High;
+            public decimal Low;
+            public decimal Close;
+
+            public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+            {
+                var source = "https://www.dl.dropboxusercontent.com/s/d83xvd7mm9fzpk0/path_to_my_csv_data.csv?dl=0";
+                return new SubscriptionDataSource(source, SubscriptionTransportMedium.RemoteFile);
+            }
+
+            public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+            {
+                if (string.IsNullOrWhiteSpace(line.Trim()))
+                {
+                    return null;
+                }
+
+                try
+                {
+                    var csv = line.Split(",");
+                    var data = new CustomDataType()
+                    {
+                        Symbol = config.Symbol,
+                        Time = DateTime.ParseExact(csv[0], DateFormat.DB, CultureInfo.InvariantCulture).AddHours(20),
+                        Value = csv[4].ToDecimal(),
+                        Open = csv[1].ToDecimal(),
+                        High = csv[2].ToDecimal(),
+                        Low = csv[3].ToDecimal(),
+                        Close = csv[4].ToDecimal()
+                    };
+
+                    return data;
+                }
+                catch
+                {
+                    return null;
+                }
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 28;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 54;
+
+        /// <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 Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/CustomMarginInterestRateModelAlgorithm.cs

@@ -0,0 +1,175 @@
+/*
+ * 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 QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Demonstration of using custom margin interest rate model in backtesting.
+    /// </summary>
+    /// <meta name="tag" content="custom margin interest rate models" />
+    public class CustomMarginInterestRateModelAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+
+        private decimal _cashAfterOrder;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 01);
+            SetEndDate(2013, 10, 31);
+
+            var security = AddEquity("SPY", Resolution.Hour);
+            _spy = security.Symbol;
+
+            // set the margin interest rate model
+            security.SetMarginInterestRateModel(new CustomMarginInterestRateModel());
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_spy, 1);
+            }
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                _cashAfterOrder = Portfolio.Cash;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            var security = Securities[_spy];
+            var marginInterestRateModel = security.MarginInterestRateModel as CustomMarginInterestRateModel;
+
+            if (marginInterestRateModel == null)
+            {
+                throw new Exception("CustomMarginInterestRateModel was not set");
+            }
+
+            if (marginInterestRateModel.CallCount == 0)
+            {
+                throw new Exception("CustomMarginInterestRateModel was not called");
+            }
+
+            var expectedCash = _cashAfterOrder * (decimal)Math.Pow(1 + (double)marginInterestRateModel.InterestRate, marginInterestRateModel.CallCount);
+
+            // add a tolerance since using Math.Pow(double, double) given the lack of a decimal overload
+            if (Math.Abs(Portfolio.Cash - expectedCash) > 1e-10m)
+            {
+                throw new Exception($"Expected cash {expectedCash} but got {Portfolio.Cash}");
+            }
+        }
+
+        public class CustomMarginInterestRateModel : IMarginInterestRateModel
+        {
+            public decimal InterestRate { get; } = 0.01m;
+
+            public int CallCount { get; private set; }
+
+            public void ApplyMarginInterestRate(MarginInterestRateParameters parameters)
+            {
+                var security = parameters.Security;
+                var positionValue = security.Holdings.GetQuantityValue(security.Holdings.Quantity);
+
+                if (positionValue.Amount > 0)
+                {
+                    positionValue.Cash.AddAmount(InterestRate * positionValue.Cash.Amount);
+                    CallCount++;
+                }
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 330;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "93.409%"},
+            {"Drawdown", "2.400%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "5.699%"},
+            {"Sharpe Ratio", "4.771"},
+            {"Probabilistic Sharpe Ratio", "85.653%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.145"},
+            {"Beta", "0.998"},
+            {"Annual Standard Deviation", "0.108"},
+            {"Annual Variance", "0.012"},
+            {"Information Ratio", "28.436"},
+            {"Tracking Error", "0.005"},
+            {"Treynor Ratio", "0.514"},
+            {"Total Fees", "$3.43"},
+            {"Estimated Strategy Capacity", "$150000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.045"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "14.855"},
+            {"Return Over Maximum Drawdown", "63.683"},
+            {"Portfolio Turnover", "0.045"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "701d5dfbbd5ffd8b60a76d61f15bae17"}
+        };
+    }
+}

Algorithm.CSharp/DailyHistoryForMinuteResolutionRegressionAlgorithm.cs

@@ -96,12 +96,12 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 29609;
+        public long DataPoints => 29579;
 
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 42688;
+        public int AlgorithmHistoryDataPoints => 42660;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/DefaultFutureChainRegressionAlgorithm.cs

@@ -0,0 +1,121 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using QuantConnect.Data.UniverseSelection;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing GH issue #6829 where the default future chain selection would let some contracts through
+    /// </summary>
+    public class DefaultFutureChainRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 12, 10);
+
+            AddFuture(Futures.Metals.Gold);
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            foreach (var addedSecurity in changes.AddedSecurities.Where(added => !added.Symbol.IsCanonical()))
+            {
+                // With no future chain filters specified, it should return no contracts in security changes event.
+                // The canonical continuous future will get mapped and emit symbol changed events, while it's current mapped security is an internal feed
+                throw new Exception($"We expect no non canonical security to be added: {addedSecurity.Symbol}");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 473924;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <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 Trades", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "-5.145"},
+            {"Tracking Error", "0.083"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}