Handle insufficient margin for option exercise (#7828)

* Handle insufficient margin for option exercise

* Minor change

* Minor changes

Algorithm.CSharp/CustomOptionAssignmentRegressionAlgorithm.cs

@@ -83,7 +83,7 @@ public override OptionAssignmentResult GetAssignment(OptionAssignmentParameters
             {"Estimated Strategy Capacity", "$4800000.00"},
             {"Lowest Capacity Asset", "GOOCV 305RBQ20WHPNQ|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "26.72%"},
-            {"OrderListHash", "db137c185e96681000e53c2c373c18e5"}
+            {"OrderListHash", "d8a544352326b3e74c0e5c9ce7517ae8"}
         };
     }
 }

Algorithm.CSharp/CustomOptionExerciseModelRegressionAlgorithm.cs

@@ -91,7 +91,7 @@ public override IEnumerable<OrderEvent> OptionExercise(Option option, OptionExer
             {"Estimated Strategy Capacity", "$87000.00"},
             {"Lowest Capacity Asset", "GOOCV 305RBQ20WHPNQ|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "10.93%"},
-            {"OrderListHash", "1b9493f01c5a9c5bc5032cf84c249782"}
+            {"OrderListHash", "f3584e74d78b3fa544f7558bb3c4c1bd"}
         };
     }
 }

Algorithm.CSharp/InsufficientBuyingPowerForAutomaticExerciseRegressionAlgorithm.cs

@@ -0,0 +1,214 @@
+/*
+ * 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>
+    /// Regression algorithm asserting that a short option position is auto exercised even when there is insufficient margin,
+    /// but triggering a margin call for the underlying stock to cover the assignment.
+    /// </summary>
+    public class InsufficientBuyingPowerForAutomaticExerciseRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _stock;
+        private Symbol _option;
+
+        private bool _stockBought;
+        private bool _optionSold;
+        private bool _optionAssigned;
+        private bool _marginCallReceived;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 23);
+            SetEndDate(2015, 12, 28);
+            SetCash(100000);
+
+            _stock = AddEquity("GOOG").Symbol;
+
+            var contracts = OptionChainProvider.GetOptionContractList(_stock, UtcTime).ToList();
+            _option = contracts
+                .Where(c => c.ID.OptionRight == OptionRight.Put)
+                .OrderBy(c => c.ID.Date)
+                .First(c => c.ID.StrikePrice == 800m);
+
+            AddOptionContract(_option);
+        }
+
+        public override void OnData(Slice data)
+        {
+            // We are done with buying
+            if (_stockBought && _optionSold)
+            {
+                return;
+            }
+
+            if (!Portfolio.Invested)
+            {
+                // We'll use all our buying power to buy the stock, so when we then open a short put position,
+                // the margin will not be enough to cover the automatic exercise
+                SetHoldings(_stock, 1);
+            }
+
+            if (_stockBought && Securities[_option].Price != 0)
+            {
+                MarketOrder(_option, -2);
+            }
+        }
+
+        public override void OnMarginCall(List<SubmitOrderRequest> requests)
+        {
+            if (!_optionAssigned)
+            {
+                throw new Exception("Expected option to have been assigned before the margin call " +
+                    "(which should have been triggered by the auto-exercise of the option with inssuficient margin).");
+            }
+
+            if (_marginCallReceived)
+            {
+                throw new Exception("Received multiple margin calls. Expected just one.");
+            }
+
+            var request = requests.Single();
+            if (request.Symbol != _stock)
+            {
+                throw new Exception("Expected margin call for the stock, but got margin call for: " + request.Symbol);
+            }
+
+            _marginCallReceived = true;
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            var order = Transactions.GetOrderById(orderEvent.OrderId);
+            Debug($"{Time} :: {order.Id} - {order.Type} - {orderEvent.Symbol}: {orderEvent.Status} - {orderEvent.Quantity} shares at {orderEvent.FillPrice}");
+
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                if (orderEvent.Symbol == _stock)
+                {
+                    _stockBought = true;
+                }
+                else if (orderEvent.Symbol == _option)
+                {
+                    if (order.Type == OrderType.Market)
+                    {
+                        if (!_stockBought)
+                        {
+                            throw new Exception("Stock should have been bought first");
+                        }
+
+                        _optionSold = true;
+                    }
+                    else if (order.Type == OrderType.OptionExercise && orderEvent.IsAssignment)
+                    {
+                        if (!_optionSold)
+                        {
+                            throw new Exception("Option should have been sold first");
+                        }
+
+                        _optionAssigned = true;
+                    }
+                }
+                else
+                {
+                    throw new Exception("Unexpected symbol: " + orderEvent.Symbol);
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_stockBought)
+            {
+                throw new Exception("Stock was not bought");
+            }
+
+            if (!_optionSold)
+            {
+                throw new Exception("Option was not sold");
+            }
+
+            if (!_optionAssigned)
+            {
+                throw new Exception("Option was not assigned");
+            }
+
+            if (!_marginCallReceived)
+            {
+                throw new Exception("Margin call was not received");
+            }
+        }
+
+        /// <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 => 2821;
+
+        /// <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", "8.96%"},
+            {"Average Loss", "-1.95%"},
+            {"Compounding Annual Return", "-67.963%"},
+            {"Drawdown", "2.900%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-1.752%"},
+            {"Sharpe Ratio", "-6.542"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "1.125%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "4.60"},
+            {"Alpha", "-0.007"},
+            {"Beta", "1.181"},
+            {"Annual Standard Deviation", "0.036"},
+            {"Annual Variance", "0.001"},
+            {"Information Ratio", "-1.422"},
+            {"Tracking Error", "0.03"},
+            {"Treynor Ratio", "-0.2"},
+            {"Total Fees", "$3.30"},
+            {"Estimated Strategy Capacity", "$2400000.00"},
+            {"Lowest Capacity Asset", "GOOCV 305RBQ20WHPNQ|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "54.01%"},
+            {"OrderListHash", "72e36e29e49caae435accc583f060c47"}
+        };
+    }
+}
+

Algorithm.CSharp/OptionAssignmentRegressionAlgorithm.cs

@@ -128,7 +128,7 @@ public override void OnData(Slice data)
             {"Estimated Strategy Capacity", "$710000.00"},
             {"Lowest Capacity Asset", "GOOCV 305RBQ20WHPNQ|GOOCV VP83T1ZUHROL"},
             {"Portfolio Turnover", "218.80%"},
-            {"OrderListHash", "02d3bd3ca1b69a6f1c64d862cd0dd4ba"}
+            {"OrderListHash", "67f42f49744d67f72f2c64b5dddb3432"}
         };
     }
 }

Brokerages/Backtesting/BacktestingBrokerage.cs

@@ -466,12 +466,12 @@ private void ProcessAssignmentOrders()
                     var result = option.OptionAssignmentModel.GetAssignment(new OptionAssignmentParameters(option));
                     if (result != null && result.Quantity != 0)
                     {
-                        var request = new SubmitOrderRequest(OrderType.OptionExercise, option.Type, option.Symbol, Math.Abs(result.Quantity), 0m, 0m, 0m, Algorithm.UtcTime, result.Tag);
                         if (!_pendingOptionAssignments.Add(option.Symbol))
                         {
                             throw new InvalidOperationException($"Duplicate option exercise order request for symbol {option.Symbol}. Please contact support");
                         }
-                        Algorithm.Transactions.ProcessRequest(request);
+
+                        OnOptionNotification(new OptionNotificationEventArgs(option.Symbol, 0, result.Tag));
                     }
                 }
             }

Common/Brokerages/OptionNotificationEventArgs.cs

@@ -33,6 +33,11 @@ public sealed class OptionNotificationEventArgs : EventArgs
         /// </summary>
         public decimal Position { get; }
 
+        /// <summary>
+        /// The tag that will be used in the order
+        /// </summary>
+        public string Tag { get; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="OptionNotificationEventArgs"/> class
         /// </summary>
@@ -44,12 +49,30 @@ public OptionNotificationEventArgs(Symbol symbol, decimal position)
             Position = position;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OptionNotificationEventArgs"/> class
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        /// <param name="position">The new option position</param>
+        /// <param name="tag">The tag to be used for the order</param>
+        public OptionNotificationEventArgs(Symbol symbol, decimal position, string tag)
+            : this(symbol, position)
+        {
+            Tag = tag;
+        }
+
         /// <summary>
         /// Returns the string representation of this event
         /// </summary>
         public override string ToString()
         {
-            return $"{Symbol} position: {Position}";
+            var str = $"{Symbol} position: {Position}";
+            if (!string.IsNullOrEmpty(Tag))
+            {
+                str += $", tag: {Tag}";
+            }
+
+            return str;
         }
     }
 }

Engine/TransactionHandlers/BrokerageTransactionHandler.cs

@@ -1453,7 +1453,7 @@ private void HandleOptionNotification(OptionNotificationEventArgs e)
                             // If the quantity is already 0 for Lean and the brokerage there is nothing else todo here
                             if (quantity != 0)
                             {
-                                var exerciseOrder = GenerateOptionExerciseOrder(security, quantity);
+                                var exerciseOrder = GenerateOptionExerciseOrder(security, quantity, e.Tag);
 
                                 EmitOptionNotificationEvents(security, exerciseOrder);
                             }
@@ -1514,7 +1514,7 @@ private void HandleOptionNotification(OptionNotificationEventArgs e)
                                 {
                                     var quantity = e.Position - security.Holdings.Quantity;
 
-                                    var exerciseOrder = GenerateOptionExerciseOrder(security, quantity);
+                                    var exerciseOrder = GenerateOptionExerciseOrder(security, quantity, e.Tag);
 
                                     EmitOptionNotificationEvents(security, exerciseOrder);
                                 }
@@ -1541,10 +1541,10 @@ void onError(IReadOnlyCollection<SecurityType> supportedSecurityTypes) =>
             }
         }
 
-        private OptionExerciseOrder GenerateOptionExerciseOrder(Security security, decimal quantity)
+        private OptionExerciseOrder GenerateOptionExerciseOrder(Security security, decimal quantity, string tag)
         {
             // generate new exercise order and ticket for the option
-            var order = new OptionExerciseOrder(security.Symbol, quantity, CurrentTimeUtc);
+            var order = new OptionExerciseOrder(security.Symbol, quantity, CurrentTimeUtc, tag);
 
             // save current security prices
             order.OrderSubmissionData = new OrderSubmissionData(security.BidPrice, security.AskPrice, security.Close);