public void PerformsStopMarketFillSell()
{
var model = new EquityTransactionModel();
var order = new StopMarketOrder(Symbol, -100, 101.5m, DateTime.Now, type: SecurityType.Equity);
var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Equity, Symbol, Resolution.Minute, true, true, true, true, false, 0);
var security = new Security(config, 1);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 102m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101m));
fill = model.StopMarketFill(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void ValidateStopMarketOrders()
{
var oanda = (OandaBrokerage)Brokerage;
var symbol = Symbol;
var quotes = oanda.GetRates(new List <string> {
new OandaSymbolMapper().GetBrokerageSymbol(symbol)
});
// Buy StopMarket order below market
var price = Convert.ToDecimal(quotes[0].bid - 0.5);
var order = new StopMarketOrder(symbol, 1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
// Buy StopMarket order above market
price = Convert.ToDecimal(quotes[0].ask + 0.5);
order = new StopMarketOrder(symbol, 1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
// Sell StopMarket order below market
price = Convert.ToDecimal(quotes[0].bid - 0.5);
order = new StopMarketOrder(symbol, -1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
// Sell StopMarket order above market
price = Convert.ToDecimal(quotes[0].ask + 0.5);
order = new StopMarketOrder(symbol, -1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
}
public void ValidateStopMarketOrders()
{
var alpaca = (AlpacaBrokerage)Brokerage;
var symbol = Symbol;
var quote = alpaca.GetRates(symbol.Value);
// Buy StopMarket order below market
var price = quote.BidPrice - 0.5m;
var order = new StopMarketOrder(symbol, 1, price, DateTime.Now);
Assert.IsTrue(alpaca.PlaceOrder(order));
// Buy StopMarket order above market
price = quote.AskPrice + 0.5m;
order = new StopMarketOrder(symbol, 1, price, DateTime.Now);
Assert.IsTrue(alpaca.PlaceOrder(order));
// Sell StopMarket order below market
price = quote.BidPrice - 0.5m;
order = new StopMarketOrder(symbol, -1, price, DateTime.Now);
Assert.IsTrue(alpaca.PlaceOrder(order));
// Sell StopMarket order above market
price = quote.AskPrice + 0.5m;
order = new StopMarketOrder(symbol, -1, price, DateTime.Now);
Assert.IsTrue(alpaca.PlaceOrder(order));
}
public void LimitSellOrderChecksOpenOrders()
{
_portfolio.SetCash(5000);
_portfolio.CashBook["BTC"].SetAmount(1m);
_portfolio.CashBook["ETH"].SetAmount(3m);
_btcusd = _algorithm.AddCrypto("BTCUSD");
_btcusd.SetMarketPrice(new Tick {
Value = 15000m
});
_ethusd = _algorithm.AddCrypto("ETHUSD");
_ethusd.SetMarketPrice(new Tick {
Value = 1000m
});
_ethbtc = _algorithm.AddCrypto("ETHBTC");
_ethbtc.SetMarketPrice(new Tick {
Value = 0.1m
});
_algorithm.SetFinishedWarmingUp();
// BTCUSD sell limit order decreases available BTC (1 - 0.1 = 0.9 BTC)
SubmitLimitOrder(_btcusd.Symbol, -0.1m, 15000m);
// ETHUSD sell limit order decreases available ETH (3 - 1 = 2 ETH)
SubmitLimitOrder(_ethusd.Symbol, -1m, 1000m);
// ETHBTC buy limit order decreases available BTC (0.9 - 0.1 = 0.8 BTC)
SubmitLimitOrder(_ethbtc.Symbol, 1m, 0.1m);
// BTCUSD sell stop order decreases available BTC (0.8 - 0.1 = 0.7 BTC)
SubmitStopMarketOrder(_btcusd.Symbol, -0.1m, 5000m);
// 0.7 BTC available, can sell 0.7 BTC at any price
var order = new LimitOrder(_btcusd.Symbol, -0.7m, 10000m, DateTime.UtcNow);
Assert.IsTrue(_buyingPowerModel.HasSufficientBuyingPowerForOrder(_portfolio, _btcusd, order));
// 0.7 BTC available, cannot sell 0.8 BTC at any price
order = new LimitOrder(_btcusd.Symbol, -0.8m, 10000m, DateTime.UtcNow);
Assert.IsFalse(_buyingPowerModel.HasSufficientBuyingPowerForOrder(_portfolio, _btcusd, order));
// 2 ETH available, can sell 2 ETH at any price
order = new LimitOrder(_ethusd.Symbol, -2m, 1200m, DateTime.UtcNow);
Assert.IsTrue(_buyingPowerModel.HasSufficientBuyingPowerForOrder(_portfolio, _ethusd, order));
// 2 ETH available, cannot sell 2.1 ETH at any price
order = new LimitOrder(_ethusd.Symbol, -2.1m, 2000m, DateTime.UtcNow);
Assert.IsFalse(_buyingPowerModel.HasSufficientBuyingPowerForOrder(_portfolio, _ethusd, order));
// 0.7 BTC available, can sell stop 0.7 BTC at any price
var stopOrder = new StopMarketOrder(_btcusd.Symbol, -0.7m, 5000m, DateTime.UtcNow);
Assert.IsTrue(_buyingPowerModel.HasSufficientBuyingPowerForOrder(_portfolio, _btcusd, stopOrder));
// 0.7 BTC available, cannot sell stop 0.8 BTC at any price
stopOrder = new StopMarketOrder(_btcusd.Symbol, -0.8m, 5000m, DateTime.UtcNow);
Assert.IsFalse(_buyingPowerModel.HasSufficientBuyingPowerForOrder(_portfolio, _btcusd, stopOrder));
}
public void ValidateStopMarketOrders()
{
var oanda = (OandaBrokerage)Brokerage;
var symbol = Symbol;
var quote = oanda.GetRates(new OandaSymbolMapper().GetBrokerageSymbol(symbol));
// Buy StopMarket order below market
var price = quote.BidPrice - 0.5m;
var order = new StopMarketOrder(symbol, 1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
// Buy StopMarket order above market
price = quote.AskPrice + 0.5m;
order = new StopMarketOrder(symbol, 1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
// Sell StopMarket order below market
price = quote.BidPrice - 0.5m;
order = new StopMarketOrder(symbol, -1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
// Sell StopMarket order above market
price = quote.AskPrice + 0.5m;
order = new StopMarketOrder(symbol, -1, price, DateTime.Now);
Assert.IsTrue(oanda.PlaceOrder(order));
}
/// <summary>
/// Default stop fill model implementation in base class security. (Stop Market Order Type)
/// </summary>
/// <param name="asset">Security asset we're filling</param>
/// <param name="order">Order packet to model</param>
/// <returns>Order fill information detailing the average price and quantity filled.</returns>
/// <seealso cref="MarketFill(Security, MarketOrder)"/>
/// <seealso cref="SecurityTransactionModel.LimitFill"/>
public virtual OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
//Default order event to return.
var utcTime = asset.LocalTime.ConvertToUtc(asset.Exchange.TimeZone);
var fill = new OrderEvent(order, utcTime, 0);
// make sure the exchange is open before filling
if (!IsExchangeOpen(asset))
{
return(fill);
}
//If its cancelled don't need anymore checks:
if (order.Status == OrderStatus.Canceled)
{
return(fill);
}
//Get the range of prices in the last bar:
decimal minimumPrice;
decimal maximumPrice;
DataMinMaxPrices(asset, out minimumPrice, out maximumPrice);
//Calculate the model slippage: e.g. 0.01c
var slip = asset.SlippageModel.GetSlippageApproximation(asset, order);
//Check if the Stop Order was filled: opposite to a limit order
switch (order.Direction)
{
case OrderDirection.Sell:
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (minimumPrice < order.StopPrice)
{
fill.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at lowest of the stop & asset price.
fill.FillPrice = Math.Min(order.StopPrice, asset.Price - slip);
}
break;
case OrderDirection.Buy:
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (maximumPrice > order.StopPrice)
{
fill.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at highest of the stop & asset price.
fill.FillPrice = Math.Max(order.StopPrice, asset.Price + slip);
}
break;
}
// assume the order completely filled
if (fill.Status == OrderStatus.Filled)
{
fill.FillQuantity = order.Quantity;
fill.OrderFee = asset.FeeModel.GetOrderFee(asset, order);
}
return(fill);
}
/// <summary>
/// Wrapper for <see cref = "IFillModel.StopMarketFill(Security, StopMarketOrder)" /> in Python
/// </summary>
/// <param name="asset">Asset we're trading this order</param>
/// <param name="order">Stop Order to Check, return filled if true</param>
/// <returns>Order fill information detailing the average price and quantity filled.</returns>
public OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
using (Py.GIL())
{
return(_model.StopMarketFill(asset, order));
}
}
public void PerformsStopMarketFillBuy()
{
var model = new EquityTransactionModel();
var order = new StopMarketOrder(Symbol, 100, 101.5m, Noon, type: SecurityType.Equity);
var config = CreateTradeBarConfig(Symbol);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbol, Noon, 101m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbol, Noon, 102.5m));
fill = model.StopMarketFill(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Max(security.Price, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
/// <summary>
/// Stop Market Fill Model. Return an order event with the fill details.
/// </summary>
/// <param name="asset">Asset we're trading this order</param>
/// <param name="order">Stop Order to Check, return filled if true</param>
/// <returns>Order fill information detailing the average price and quantity filled.</returns>
public override OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
using (Py.GIL())
{
return((_model.StopMarketFill(asset, order) as PyObject).GetAndDispose <OrderEvent>());
}
}
public void PerformsStopMarketFillBuy()
{
var model = new ForexTransactionModel();
var order = new StopMarketOrder(Symbol, 100, 101.5m, DateTime.Now, type: SecurityType.Forex);
var config = CreateTradeBarDataConfig(SecurityType.Forex, Symbol);
var security = new Security(SecurityExchangeHours.AlwaysOpen, config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 101m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 102.5m));
fill = model.StopMarketFill(security, order);
var slip = model.GetSlippageApproximation(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Max(security.Price + slip, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void PerformsStopMarketFillSell()
{
var model = new SecurityTransactionModel();
var order = new StopMarketOrder(Symbols.SPY, -100, 101.5m, Noon);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 102m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101m));
fill = model.StopMarketFill(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
public void PerformsStopMarketFillSell()
{
var model = new ForexTransactionModel();
var security = CreateSecurity();
var order = new StopMarketOrder(Symbols.USDJPY, -100, 101.5m, DateTime.Now, type: SecurityType.Forex);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.USDJPY, DateTime.Now, 102m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbols.USDJPY, DateTime.Now, 101m));
fill = model.StopMarketFill(security, order);
var slip = model.GetSlippageApproximation(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price - slip, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
public void ValidateStopMarketOrders()
{
var alpaca = (AlpacaBrokerage)Brokerage;
var symbol = Symbol;
var lastPrice = GetLastPrice(symbol.Value);
// Buy StopMarket order below market
var price = lastPrice - 0.5m;
var order = new StopMarketOrder(symbol, 1, price, DateTime.UtcNow);
Assert.IsTrue(alpaca.PlaceOrder(order));
// Buy StopMarket order above market
price = lastPrice + 0.5m;
order = new StopMarketOrder(symbol, 1, price, DateTime.UtcNow);
Assert.IsTrue(alpaca.PlaceOrder(order));
// Sell StopMarket order below market
price = lastPrice - 0.5m;
order = new StopMarketOrder(symbol, -1, price, DateTime.UtcNow);
Assert.IsTrue(alpaca.PlaceOrder(order));
// Sell StopMarket order above market
price = lastPrice + 0.5m;
order = new StopMarketOrder(symbol, -1, price, DateTime.UtcNow);
Assert.IsTrue(alpaca.PlaceOrder(order));
}
/// <summary>
/// Default stop fill model implementation in base class security. (Stop Market Order Type)
/// </summary>
/// <param name="asset">Security asset we're filling</param>
/// <param name="order">Order packet to model</param>
/// <returns>Order fill informaton detailing the average price and quantity filled.</returns>
/// <seealso cref="MarketFill(Security, MarketOrder)"/>
/// <seealso cref="LimitFill(Security, LimitOrder)"/>
public virtual OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
//Default order event to return.
var fill = new OrderEvent(order);
try
{
//If its cancelled don't need anymore checks:
if (fill.Status == OrderStatus.Canceled)
{
return(fill);
}
//Get the range of prices in the last bar:
decimal minimumPrice;
decimal maximumPrice;
DataMinMaxPrices(asset, out minimumPrice, out maximumPrice);
//Calculate the model slippage: e.g. 0.01c
var slip = GetSlippageApproximation(asset, order);
//Check if the Stop Order was filled: opposite to a limit order
switch (order.Direction)
{
case OrderDirection.Sell:
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (minimumPrice < order.StopPrice)
{
order.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at lowest of the stop & asset price.
order.Price = Math.Min(order.StopPrice, asset.Price - slip);
}
break;
case OrderDirection.Buy:
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (maximumPrice > order.StopPrice)
{
order.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at highest of the stop & asset price.
order.Price = Math.Max(order.StopPrice, asset.Price + slip);
}
break;
}
if (order.Status == OrderStatus.Filled || order.Status == OrderStatus.PartiallyFilled)
{
fill.FillQuantity = order.Quantity;
fill.FillPrice = order.Price; //we picked the correct fill price above, just respect it here
fill.Status = order.Status;
}
}
catch (Exception err)
{
Log.Error("SecurityTransactionModel.StopMarketFill(): " + err.Message);
}
return(fill);
}
/// <summary>
/// Gets all orders not yet closed
/// </summary>
/// <returns></returns>
public override List<Order> GetOpenOrders()
{
var list = new List<Order>();
var req = new RestRequest("/orders?status=open&status=pending", Method.GET);
GetAuthenticationToken(req);
var response = ExecuteRestRequest(req, GdaxEndpointType.Private);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception($"GDAXBrokerage.GetOpenOrders: request failed: [{(int) response.StatusCode}] {response.StatusDescription}, Content: {response.Content}, ErrorMessage: {response.ErrorMessage}");
}
var orders = JsonConvert.DeserializeObject<Messages.Order[]>(response.Content);
foreach (var item in orders)
{
Order order;
if (item.Type == "market")
{
order = new MarketOrder { Price = item.Price };
}
else if (item.Type == "limit")
{
order = new LimitOrder { LimitPrice = item.Price };
}
else if (item.Type == "stop")
{
order = new StopMarketOrder { StopPrice = item.Price };
}
else
{
OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Error, (int)response.StatusCode,
"GDAXBrokerage.GetOpenOrders: Unsupported order type returned from brokerage: " + item.Type));
continue;
}
order.Quantity = item.Side == "sell" ? -item.Size : item.Size;
order.BrokerId = new List<string> { item.Id };
order.Symbol = ConvertProductId(item.ProductId);
order.Time = DateTime.UtcNow;
order.Status = ConvertOrderStatus(item);
order.Price = item.Price;
list.Add(order);
}
foreach (var item in list)
{
if (item.Status.IsOpen())
{
var cached = CachedOrderIDs.Where(c => c.Value.BrokerId.Contains(item.BrokerId.First()));
if (cached.Any())
{
CachedOrderIDs[cached.First().Key] = item;
}
}
}
return list;
}
/// <summary>
/// Converts the specified Oanda order into a qc order.
/// The 'task' will have a value if we needed to issue a rest call for the stop price, otherwise it will be null
/// </summary>
protected Order ConvertOrder(DataType.Order order)
{
Order qcOrder;
switch (order.type)
{
case "limit":
qcOrder = new LimitOrder();
if (order.side == "buy")
{
((LimitOrder)qcOrder).LimitPrice = Convert.ToDecimal(order.lowerBound);
}
if (order.side == "sell")
{
((LimitOrder)qcOrder).LimitPrice = Convert.ToDecimal(order.upperBound);
}
break;
case "stop":
qcOrder = new StopLimitOrder();
if (order.side == "buy")
{
((StopLimitOrder)qcOrder).LimitPrice = Convert.ToDecimal(order.lowerBound);
}
if (order.side == "sell")
{
((StopLimitOrder)qcOrder).LimitPrice = Convert.ToDecimal(order.upperBound);
}
break;
case "marketIfTouched":
//when market reaches the price sell at market.
qcOrder = new StopMarketOrder {
Price = Convert.ToDecimal(order.price), StopPrice = Convert.ToDecimal(order.price)
};
break;
case "market":
qcOrder = new MarketOrder();
break;
default:
throw new NotSupportedException("The Oanda order type " + order.type + " is not supported.");
}
qcOrder.Symbol = order.instrument;
qcOrder.Quantity = ConvertQuantity(order);
qcOrder.SecurityType = InstrumentSecurityTypeMap[order.instrument];
qcOrder.Status = OrderStatus.None;
qcOrder.BrokerId.Add(order.id);
qcOrder.Id = order.id;
qcOrder.Duration = OrderDuration.Custom;
qcOrder.DurationValue = XmlConvert.ToDateTime(order.expiry, XmlDateTimeSerializationMode.Utc);
qcOrder.Time = XmlConvert.ToDateTime(order.time, XmlDateTimeSerializationMode.Utc);
return(qcOrder);
}
/// <summary>
/// Converts an Oanda order into a LEAN order.
/// </summary>
private Order ConvertOrder(JToken order)
{
var type = order["type"].ToString();
Order qcOrder;
var instrument = order["instrument"].ToString();
var id = order["id"].ToString();
var units = order["units"].ConvertInvariant <decimal>();
var createTime = order["createTime"].ToString();
var securityType = SymbolMapper.GetBrokerageSecurityType(instrument);
var symbol = SymbolMapper.GetLeanSymbol(instrument, securityType, Market.Oanda);
var time = GetTickDateTimeFromString(createTime);
var quantity = units;
switch (type)
{
case "MARKET_IF_TOUCHED":
var stopOrder = order.ToObject <MarketIfTouchedOrder>();
qcOrder = new StopMarketOrder
{
StopPrice = stopOrder.Price.ToDecimal()
};
break;
case "LIMIT":
var limitOrder = order.ToObject <OandaLimitOrder>();
qcOrder = new LimitOrder(symbol, quantity, limitOrder.Price.ToDecimal(), time);
break;
case "STOP":
var stopLimitOrder = order.ToObject <StopOrder>();
var price = stopLimitOrder.Price.ConvertInvariant <decimal>();
var limitPrice = stopLimitOrder.PriceBound.ConvertInvariant <decimal>();
qcOrder = new StopLimitOrder(symbol, quantity, price, limitPrice, time);
break;
case "MARKET":
qcOrder = new MarketOrder();
break;
default:
throw new NotSupportedException(
"An existing " + type + " working order was found and is currently unsupported. Please manually cancel the order before restarting the algorithm.");
}
qcOrder.Status = OrderStatus.None;
qcOrder.BrokerId.Add(id);
var gtdTime = order["gtdTime"];
if (gtdTime != null)
{
var expiry = GetTickDateTimeFromString(gtdTime.ToString());
qcOrder.Properties.TimeInForce = TimeInForce.GoodTilDate(expiry);
}
return(qcOrder);
}
public void StopMarketOrderDoesNotFillUsingDataBeforeSubmitTime(decimal orderQuantity, decimal stopPrice)
{
var time = new DateTime(2018, 9, 24, 9, 30, 0);
var timeKeeper = new TimeKeeper(time.ConvertToUtc(TimeZones.NewYork), TimeZones.NewYork);
var symbol = Symbol.Create("SPY", SecurityType.Equity, Market.USA);
var config = new SubscriptionDataConfig(typeof(TradeBar), symbol, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, true, true, false);
var security = new Security(
SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(),
config,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
security.SetLocalTimeKeeper(timeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
var tradeBar = new TradeBar(time, symbol, 290m, 292m, 289m, 291m, 12345);
security.SetMarketPrice(tradeBar);
time += TimeSpan.FromMinutes(1);
timeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork));
var fillForwardBar = (TradeBar)tradeBar.Clone(true);
security.SetMarketPrice(fillForwardBar);
var fillModel = new ImmediateFillModel();
var order = new StopMarketOrder(symbol, orderQuantity, stopPrice, time.ConvertToUtc(TimeZones.NewYork));
var fill = fillModel.Fill(new FillModelParameters(
security,
order,
new MockSubscriptionDataConfigProvider(config),
Time.OneHour)).OrderEvent;
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
time += TimeSpan.FromMinutes(1);
timeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork));
tradeBar = new TradeBar(time, symbol, 290m, 292m, 289m, 291m, 12345);
security.SetMarketPrice(tradeBar);
fill = fillModel.StopMarketFill(security, order);
Assert.AreEqual(orderQuantity, fill.FillQuantity);
Assert.AreEqual(stopPrice, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(0, fill.OrderFee.Value.Amount);
}
public void ClientPlacesStopLimitOrder()
{
bool orderFilled = false;
var manualResetEvent = new ManualResetEvent(false);
var ib = _interactiveBrokersBrokerage;
decimal fillPrice = 100m;
decimal delta = 85.0m; // if we can't get a price then make the delta huge
ib.OrderStatusChanged += (sender, args) =>
{
orderFilled = true;
fillPrice = args.FillPrice;
delta = 0.02m;
manualResetEvent.Set();
};
// get the current market price, couldn't get RequestMarketData to fire tick events
int id = 0;
Order order = new MarketOrder(Symbols.USDJPY, buyQuantity, DateTime.UtcNow)
{
Id = ++id
};
_orders.Add(order);
ib.PlaceOrder(order);
manualResetEvent.WaitOne(2000);
manualResetEvent.Reset();
Assert.IsTrue(orderFilled);
orderFilled = false;
// make a box around the current price +- a little
order = new StopMarketOrder(Symbols.USDJPY, buyQuantity, fillPrice - delta, DateTime.UtcNow)
{
Id = ++id
};
_orders.Add(order);
ib.PlaceOrder(order);
order = new StopMarketOrder(Symbols.USDJPY, -buyQuantity, fillPrice + delta, DateTime.UtcNow)
{
Id = ++id
};
_orders.Add(order);
ib.PlaceOrder(order);
manualResetEvent.WaitOne(1000);
var orderFromIB = AssertOrderOpened(orderFilled, ib, order);
Assert.AreEqual(OrderType.StopMarket, orderFromIB.Type);
}
private Order ConvertOrder(IB.Order ibOrder, IB.Contract contract)
{
// this function is called by GetOpenOrders which is mainly used by the setup handler to
// initialize algorithm state. So the only time we'll be executing this code is when the account
// has orders sitting and waiting from before algo initialization...
// because of this we can't get the time accurately
Order order;
var mappedSymbol = MapSymbol(contract);
var orderType = ConvertOrderType(ibOrder.OrderType);
switch (orderType)
{
case OrderType.Market:
order = new MarketOrder(mappedSymbol,
ibOrder.TotalQuantity,
new DateTime() // not sure how to get this data
);
break;
case OrderType.Limit:
order = new LimitOrder(mappedSymbol,
ibOrder.TotalQuantity,
ibOrder.LimitPrice,
new DateTime()
);
break;
case OrderType.StopMarket:
order = new StopMarketOrder(mappedSymbol,
ibOrder.TotalQuantity,
ibOrder.AuxPrice,
new DateTime()
);
break;
case OrderType.StopLimit:
order = new StopLimitOrder(mappedSymbol,
ibOrder.TotalQuantity,
ibOrder.AuxPrice,
ibOrder.LimitPrice,
new DateTime()
);
break;
default:
throw new InvalidEnumArgumentException("orderType", (int)orderType, typeof(OrderType));
}
order.SecurityType = ConvertSecurityType(contract.SecurityType);
order.BrokerId.Add(ibOrder.OrderId);
return(order);
}
public void ClientPlacesStopLimitOrder()
{
bool orderFilled = false;
var manualResetEvent = new ManualResetEvent(false);
var ib = new InteractiveBrokersBrokerage();
ib.Connect();
decimal aapl = 100m;
decimal delta = 85.0m; // if we can't get a price then make the delta huge
ib.OrderEvent += (sender, args) =>
{
orderFilled = true;
aapl = args.FillPrice;
delta = 0.02m;
manualResetEvent.Set();
};
// get the current market price, couldn't get RequestMarketData to fire tick events
int id = 0;
ib.PlaceOrder(new MarketOrder("AAPL", 1, DateTime.UtcNow, "", SecurityType.Equity)
{
Id = ++id
});
manualResetEvent.WaitOne(2000);
manualResetEvent.Reset();
Assert.IsTrue(orderFilled);
orderFilled = false;
// make a box around the current price +- a little
const int quantity = 1;
var order = new StopMarketOrder("AAPL", +quantity, aapl - delta, DateTime.Now, "", SecurityType.Equity)
{
Id = ++id
};
ib.PlaceOrder(order);
ib.PlaceOrder(new StopMarketOrder("AAPL", -quantity, aapl + delta, DateTime.Now, "", SecurityType.Equity)
{
Id = ++id
});
manualResetEvent.WaitOne(1000);
var orderFromIB = AssertOrderOpened(orderFilled, ib, order);
Assert.AreEqual(OrderType.StopMarket, orderFromIB.Type);
}
/// <summary>
/// Default stop fill model implementation in base class security. (Stop Market Order Type)
/// </summary>
/// <param name="asset">Security asset we're filling</param>
/// <param name="order">Order packet to model</param>
/// <returns>Order fill information detailing the average price and quantity filled.</returns>
/// <seealso cref="MarketFill(Security, MarketOrder)"/>
/// <seealso cref="SecurityTransactionModel.LimitFill"/>
public virtual OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
//Default order event to return.
var utcTime = asset.LocalTime.ConvertToUtc(asset.Exchange.TimeZone);
var fill = new OrderEvent(order, utcTime, 0);
// make sure the exchange is open before filling
if (!IsExchangeOpen(asset)) return fill;
//If its cancelled don't need anymore checks:
if (order.Status == OrderStatus.Canceled) return fill;
//Get the range of prices in the last bar:
decimal minimumPrice;
decimal maximumPrice;
DataMinMaxPrices(asset, out minimumPrice, out maximumPrice, order.Direction);
//Calculate the model slippage: e.g. 0.01c
var slip = asset.SlippageModel.GetSlippageApproximation(asset, order);
//Check if the Stop Order was filled: opposite to a limit order
switch (order.Direction)
{
case OrderDirection.Sell:
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (minimumPrice < order.StopPrice)
{
fill.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at lowest of the stop & asset price.
fill.FillPrice = Math.Min(order.StopPrice, asset.Price - slip);
}
break;
case OrderDirection.Buy:
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (maximumPrice > order.StopPrice)
{
fill.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at highest of the stop & asset price.
fill.FillPrice = Math.Max(order.StopPrice, asset.Price + slip);
}
break;
}
// assume the order completely filled
if (fill.Status == OrderStatus.Filled)
{
fill.FillQuantity = order.Quantity;
fill.OrderFee = asset.FeeModel.GetOrderFee(asset, order);
}
return fill;
}
/// <summary>
/// Default stop fill model implementation in base class security. (Stop Market Order Type)
/// </summary>
/// <param name="asset">Security asset we're filling</param>
/// <param name="order">Order packet to model</param>
/// <returns>Order fill information detailing the average price and quantity filled.</returns>
/// <seealso cref="MarketFill(Security, MarketOrder)"/>
public virtual OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
//Default order event to return.
var utcTime = asset.LocalTime.ConvertToUtc(asset.Exchange.TimeZone);
var fill = new OrderEvent(order, utcTime, OrderFee.Zero);
//If its cancelled don't need anymore checks:
if (order.Status == OrderStatus.Canceled) return fill;
// make sure the exchange is open/normal market hours before filling
if (!IsExchangeOpen(asset, false)) return fill;
//Get the range of prices in the last bar:
var prices = GetPricesCheckingPythonWrapper(asset, order.Direction);
var pricesEndTime = prices.EndTime.ConvertToUtc(asset.Exchange.TimeZone);
// do not fill on stale data
if (pricesEndTime <= order.Time) return fill;
//Calculate the model slippage: e.g. 0.01c
var slip = asset.SlippageModel.GetSlippageApproximation(asset, order);
//Check if the Stop Order was filled: opposite to a limit order
switch (order.Direction)
{
case OrderDirection.Sell:
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (prices.Low < order.StopPrice)
{
fill.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at lowest of the stop & asset price.
fill.FillPrice = Math.Min(order.StopPrice, prices.Current - slip);
// assume the order completely filled
fill.FillQuantity = order.Quantity;
}
break;
case OrderDirection.Buy:
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (prices.High > order.StopPrice)
{
fill.Status = OrderStatus.Filled;
// Assuming worse case scenario fill - fill at highest of the stop & asset price.
fill.FillPrice = Math.Max(order.StopPrice, prices.Current + slip);
// assume the order completely filled
fill.FillQuantity = order.Quantity;
}
break;
}
return fill;
}
/// <summary>
/// Check if the model has stopped out our position yet:
/// </summary>
/// <param name="asset">Asset we're working with</param>
/// <param name="order">Stop Order to Check, return filled if true</param>
/// <returns>OrderEvent packet with the full or partial fill information</returns>
public OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
var fill = new OrderEvent(order);
try
{
//If its cancelled don't need anymore checks:
if (order.Status == OrderStatus.Canceled)
{
return(fill);
}
//Calculate the model slippage: e.g. 0.01c
var slip = GetSlippageApproximation(asset, order);
//Check if the Stop Order was filled: opposite to a limit order
switch (order.Direction)
{
case OrderDirection.Sell:
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (asset.Price < order.StopPrice)
{
order.Status = OrderStatus.Filled;
order.Price = Math.Round(asset.Price, 3);
order.Price -= slip;
}
break;
case OrderDirection.Buy:
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (asset.Price > order.StopPrice)
{
order.Status = OrderStatus.Filled;
order.Price = Math.Round(asset.Price, 3);
order.Price += slip;
}
break;
}
if (order.Status == OrderStatus.Filled || order.Status == OrderStatus.PartiallyFilled)
{
fill.FillQuantity = order.Quantity;
fill.FillPrice = order.Price;
fill.Status = order.Status;
}
}
catch (Exception err)
{
Log.Error("EquityTransactionModel.StopMarketFill(): " + err.Message);
}
return(fill);
}
/// <summary>
/// Create a stop market order and return the newly created order id; or negative if the order is invalid
/// </summary>
/// <param name="symbol">String symbol for the asset we're trading</param>
/// <param name="quantity">Quantity to be traded</param>
/// <param name="stopPrice">Price to fill the stop order</param>
/// <param name="tag">Optional string data tag for the order</param>
/// <returns>Int orderId for the new order.</returns>
public int StopMarketOrder(string symbol, int quantity, decimal stopPrice, string tag = "")
{
var error = PreOrderChecks(symbol, quantity, OrderType.StopMarket);
if (error < 0)
{
return(error);
}
var order = new StopMarketOrder(symbol, quantity, stopPrice, Time, tag, Securities[symbol].Type);
//Add the order and create a new order Id.
return(Transactions.AddOrder(order));
}
/// <summary>
/// Default stop fill model implementation in base class security. (Stop Market Order Type)
/// </summary>
/// <param name="asset">Security asset we're filling</param>
/// <param name="order">Order packet to model</param>
/// <returns>Order fill informaton detailing the average price and quantity filled.</returns>
/// <seealso cref="MarketFill(Security, MarketOrder)"/>
/// <seealso cref="LimitFill(Security, LimitOrder)"/>
public OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
//Default order event to return.
var fill = new OrderEvent(order);
try
{
//If its cancelled don't need anymore checks:
if (fill.Status == OrderStatus.Canceled)
{
return(fill);
}
//Check if the Stop Order was filled: opposite to a limit order
switch (order.Direction)
{
case OrderDirection.Sell:
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (asset.Price < order.StopPrice)
{
order.Status = OrderStatus.Filled;
order.Price = asset.Price;
}
break;
case OrderDirection.Buy:
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (asset.Price > order.StopPrice)
{
order.Status = OrderStatus.Filled;
order.Price = asset.Price;
}
break;
}
if (order.Status == OrderStatus.Filled || order.Status == OrderStatus.PartiallyFilled)
{
fill.FillQuantity = order.Quantity;
fill.FillPrice = asset.Price; //Stop price as security price because can gap past stop price.
fill.Status = order.Status;
}
}
catch (Exception err)
{
Log.Error("SecurityTransactionModel.TransOrderDirection.StopFill(): " + err.Message);
}
return(fill);
}
public void DeserializesStopMarketOrder(Symbols.SymbolsKey key)
{
var expected = new StopMarketOrder(Symbols.Lookup(key), 100, 210.10m, new DateTime(2015, 11, 23, 17, 15, 37), "now")
{
Id = 12345,
Price = 209.03m,
ContingentId = 123456,
BrokerId = new List <string> {
"727", "54970"
}
};
var actual = TestOrderType(expected);
Assert.AreEqual(expected.StopPrice, actual.StopPrice);
}
public void DeserializesStopMarketOrder()
{
var expected = new StopMarketOrder(Symbols.SPY, 100, 210.10m, new DateTime(2015, 11, 23, 17, 15, 37), "now", SecurityType.Equity)
{
Id = 12345,
Price = 209.03m,
ContingentId = 123456,
BrokerId = new List <long> {
727, 54970
}
};
var actual = TestOrderType(expected);
Assert.AreEqual(expected.StopPrice, actual.StopPrice);
}
/// <summary>
/// Check if the model has stopped out our position yet: (Stop Market Order Type)
/// </summary>
/// <param name="asset">Asset we're working with</param>
/// <param name="order">Stop Order to Check, return filled if true</param>
/// <returns>OrderEvent packet with the full or partial fill information</returns>
/// <seealso cref="OrderEvent"/>
/// <seealso cref="Order"/>
public override OrderEvent StopMarketFill(Security asset, StopMarketOrder order)
{
var fill = new OrderEvent(order);
try
{
//If its cancelled don't need anymore checks:
if (order.Status == OrderStatus.Canceled)
{
return(fill);
}
//Check if the Stop Order was filled: opposite to a limit order
if (order.Direction == OrderDirection.Sell)
{
//-> 1.1 Sell Stop: If Price below setpoint, Sell:
if (asset.Price < order.StopPrice)
{
//Set the order and slippage on the order, update the fill price:
order.Status = OrderStatus.Filled;
order.Price = asset.Price; //Fill at the security price, sometimes gap down skip past stop.
}
}
else if (order.Direction == OrderDirection.Buy)
{
//-> 1.2 Buy Stop: If Price Above Setpoint, Buy:
if (asset.Price > order.StopPrice)
{
order.Status = OrderStatus.Filled;
order.Price = asset.Price; //Fill at the security price, sometimes gap down skip past stop.
}
}
//Set the fill properties when order filled.
if (order.Status == OrderStatus.Filled || order.Status == OrderStatus.PartiallyFilled)
{
fill.FillQuantity = order.Quantity;
fill.FillPrice = asset.Price;
fill.Status = order.Status;
}
}
catch (Exception err)
{
Log.Error("ForexTransactionModel.StopFill(): " + err.Message);
}
return(fill);
}
public void PerformsStopMarketFillSell()
{
var model = new ImmediateFillModel();
var order = new StopMarketOrder(Symbols.SPY, -100, 101.5m, Noon);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(
SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(),
config,
new Cash(Currencies.USD, 0, 1m),
SymbolProperties.GetDefault(Currencies.USD),
ErrorCurrencyConverter.Instance,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCache()
);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 102m));
var fill = model.Fill(new FillModelParameters(
security,
order,
new MockSubscriptionDataConfigProvider(config),
Time.OneHour)).OrderEvent;
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101m));
fill = model.Fill(new FillModelParameters(
security,
order,
new MockSubscriptionDataConfigProvider(config),
Time.OneHour)).OrderEvent;
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
/// <summary>
/// Converts an FXCM order to a QuantConnect order.
/// </summary>
/// <param name="fxcmOrder">The FXCM order</param>
private Order ConvertOrder(ExecutionReport fxcmOrder)
{
Order order;
if (fxcmOrder.getOrdType() == OrdTypeFactory.LIMIT)
{
order = new LimitOrder
{
LimitPrice = Convert.ToDecimal(fxcmOrder.getPrice())
};
}
else if (fxcmOrder.getOrdType() == OrdTypeFactory.MARKET)
{
order = new MarketOrder();
}
else if (fxcmOrder.getOrdType() == OrdTypeFactory.STOP)
{
order = new StopMarketOrder
{
StopPrice = Convert.ToDecimal(fxcmOrder.getPrice())
};
}
else
{
throw new NotSupportedException("FxcmBrokerage.ConvertOrder(): The FXCM order type " + fxcmOrder.getOrdType() + " is not supported.");
}
var securityType = _symbolMapper.GetBrokerageSecurityType(fxcmOrder.getInstrument().getSymbol());
order.Symbol = _symbolMapper.GetLeanSymbol(fxcmOrder.getInstrument().getSymbol(), securityType, Market.FXCM);
order.Quantity = Convert.ToInt32(fxcmOrder.getOrderQty() * (fxcmOrder.getSide() == SideFactory.BUY ? +1 : -1));
order.Status = ConvertOrderStatus(fxcmOrder.getFXCMOrdStatus());
order.BrokerId.Add(fxcmOrder.getOrderID());
order.Duration = ConvertDuration(fxcmOrder.getTimeInForce());
order.Time = FromJavaDate(fxcmOrder.getTransactTime().toDate());
return(order);
}
