static async Task <long?> PlaceMarketOrder(string side = "buy")
{
WriteNewLine("Creating a EUR_USD market BUY order ...");
var oandaInstrument = (await Rest20.GetAccountInstrumentsAsync(AccountID, INSTRUMENT)).First();
long orderUnits = side == "buy" ? 10 : -10;
var request = new MarketOrderRequest(oandaInstrument)
{
units = orderUnits
};
OrderPostResponse response = null;
try
{
response = await Rest20.PostOrderAsync(AccountID, request);
WriteNewLine("Congrats! You've put on a trade! Let it run! :)");
}
catch
{
WriteNewLine("Oops. Order creation failed.");
}
return(response?.orderFillTransaction?.tradeOpened?.tradeID);
}
public override async Task <PlaceMarketOrderResponse> PlaceMarketOrder(MarketOrderRequest request, ServerCallContext context)
{
if (!_settings.InstrumentMappings.TryGetValue(request.AssetPair, out var assetPairId))
{
_logger.LogWarning("Asset pair not found. {assetPairId}", request.AssetPair);
return(new PlaceMarketOrderResponse
{
Error = ErrorCode.Critical,
ErrorMessage = "Asset pair not found"
});
}
var orderId = $"{((int)request.TradeTypeTag).ToString()}{request.ComponentTag}{Guid.NewGuid().ToString().Remove(0, 1 + request.ComponentTag.Length)}";
decimal size = decimal.Parse(request.Size, CultureInfo.InvariantCulture);
var response = await _b2C2RestClient.OrderAsync(new OrderRequest
{
ClientOrderId = orderId,
Instrument = assetPairId,
Side = size > 0
? Side.Buy
: Side.Sell,
Quantity = Math.Abs(size),
OrderType = OrderType.MKT,
ValidUntil = DateTime.UtcNow.AddSeconds(3)
});
return(new PlaceMarketOrderResponse
{
Error = ErrorCode.Ok,
RequestId = orderId
});
}
public IResponse <ResponseModelDouble> PostOrdersMarket(MarketOrderRequest request, string apiKey)
{
return(Request.Post($"/Orders/market")
.AddJsonBody(request)
.WithHeaders("api-key", apiKey)
.Build().Execute <ResponseModelDouble>());
}
/// <summary>
/// Generates an Oanda order request
/// </summary>
/// <param name="order">The LEAN order</param>
/// <returns>The request in JSON format</returns>
private string GenerateOrderRequest(Order order)
{
var instrument = SymbolMapper.GetBrokerageSymbol(order.Symbol);
string request;
switch (order.Type)
{
case OrderType.Market:
var marketOrderRequest = new MarketOrderRequest
{
Type = MarketOrderRequest.TypeEnum.MARKET,
Instrument = instrument,
Units = order.Quantity.ToStringInvariant()
};
request = JsonConvert.SerializeObject(new { order = marketOrderRequest });
break;
case OrderType.Limit:
var limitOrderRequest = new LimitOrderRequest
{
Type = LimitOrderRequest.TypeEnum.LIMIT,
Instrument = instrument,
Units = order.Quantity.ToStringInvariant(),
Price = ((LimitOrder)order).LimitPrice.ToString(CultureInfo.InvariantCulture)
};
request = JsonConvert.SerializeObject(new { order = limitOrderRequest });
break;
case OrderType.StopMarket:
var marketIfTouchedOrderRequest = new MarketIfTouchedOrderRequest
{
Type = MarketIfTouchedOrderRequest.TypeEnum.MARKETIFTOUCHED,
Instrument = instrument,
Units = order.Quantity.ToStringInvariant(),
Price = ((StopMarketOrder)order).StopPrice.ToString(CultureInfo.InvariantCulture)
};
request = JsonConvert.SerializeObject(new { order = marketIfTouchedOrderRequest });
break;
case OrderType.StopLimit:
var stopOrderRequest = new StopOrderRequest
{
Type = StopOrderRequest.TypeEnum.STOP,
Instrument = instrument,
Units = order.Quantity.ToStringInvariant(),
Price = ((StopLimitOrder)order).StopPrice.ToString(CultureInfo.InvariantCulture),
PriceBound = ((StopLimitOrder)order).LimitPrice.ToString(CultureInfo.InvariantCulture)
};
request = JsonConvert.SerializeObject(new { order = stopOrderRequest });
break;
default:
throw new NotSupportedException("The order type " + order.Type + " is not supported.");
}
return(request);
}
public void GetHistoryTradeByIdTest()
{
var skip = "0";
var take = "500";
var responseBefore = hft.History.GetHistory(FirstAssetId, skip, take, ApiKey);
responseBefore.Validate.StatusCode(HttpStatusCode.OK);
var request = new MarketOrderRequest()
{
Asset = SecondAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 0.2
};
var response = hft.Orders.PostOrdersMarket(request, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
var amount = 0.009;
//buy
var requestBuy = new MarketOrderRequest()
{
Asset = FirstAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = amount
};
var responseBuy = hft.Orders.PostOrdersMarket(requestBuy, ApiKey);
responseBuy.Validate.StatusCode(HttpStatusCode.OK);
var summ = responseBuy.GetResponseObject().Result;
var responseAfter = hft.History.GetHistory(FirstAssetId, skip, take, ApiKey);
responseAfter.Validate.StatusCode(HttpStatusCode.OK);
Stopwatch sw = new Stopwatch();
sw.Start();
while (sw.Elapsed < TimeSpan.FromMinutes(5))
{
var currentHistory = hft.History.GetHistory(FirstAssetId, skip, take, ApiKey);
if (currentHistory.StatusCode == HttpStatusCode.OK)
{
if (responseBefore.GetResponseObject().First().Id != hft.History.GetHistory(FirstAssetId, skip, take, ApiKey).GetResponseObject().First().Id)
{
break;
}
}
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(3));
}
sw.Stop();
var last = hft.History.GetHistory(FirstAssetId, skip, take, ApiKey);
Assert.That(responseBefore.GetResponseObject().First().Id, Does.Not.EqualTo(last.GetResponseObject().First().Id), "Orders are not present in response(they havnt been finished in 5 minutes?)");
Assert.That(() => hft.History.GetHistory(FirstAssetId, skip, take, ApiKey).GetResponseObject().Find(t => t.Amount == amount).Price, Is.EqualTo(summ).After(5 * 60 * 1000, 2 * 1000));
}
private void ExecuteTrade(TradeType tradeType, int volume)
{
Request request = new MarketOrderRequest(tradeType, volume)
{
Label = LabelName
};
Trade.Send(request);
}
public override async Task <OrderIdResponse> CreateMarketOrderAsync([FromBody] MarketOrderRequest request)
{
Guid orderId = await Api.CreateMarketOrderAsync(
request.Instrument, request.TradeType.ToDomainTradeType(), request.Volume);
return(new OrderIdResponse
{
OrderId = orderId.ToString()
});
}
public void PostOrdersMarketWrongAssetTest(string asset)
{
var request = new MarketOrderRequest()
{
Asset = asset, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 0.5
};
var response = hft.Orders.PostOrdersMarket(request, ApiKey);
response.Validate.StatusCode(HttpStatusCode.BadRequest);
}
public void PostOrdersMarketWrongVolumeTest(double volume)
{
var request = new MarketOrderRequest()
{
Asset = SecondAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = volume
};
var response = hft.Orders.PostOrdersMarket(request, ApiKey);
response.Validate.StatusCode(HttpStatusCode.BadRequest);
}
private void ExecuteOrder(int volume, TradeType tradeType)
{
var request = new MarketOrderRequest(tradeType, volume)
{
Label = "BerthoRobot",
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
public void MOSellInvertedTest()
{
(var newMinSellPrice, var newMaxBuyPrice) = newMinMaxPrices();
(var marketSell, var marketBuy) = currentMinMaxPrices();
//
var candlesAsk1 = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Ask, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesBid1 = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Bid, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
//
var requestSell1user = new LimitOrderRequest()
{
Price = newMinSellPrice, AssetPairId = AssetPairId, OrderAction = OrderAction.Sell, Volume = 0.1
};
var responseSell1user = hft.Orders.PostOrdersLimitOrder(requestSell1user, ApiKey);
responseSell1user.Validate.StatusCode(HttpStatusCode.OK);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
var requestSell = new MarketOrderRequest()
{
AssetPairId = AssetPairId, OrderAction = OrderAction.Sell, Volume = tradingVolume / 2, Asset = SecondAssetId
};
var responseSell = hft.Orders.PostOrdersMarket(requestSell, SecondWalletApiKey);
responseSell.Validate.StatusCode(HttpStatusCode.OK);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
var candlesTrades = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Trades, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesAsk = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Ask, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesBid = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Bid, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var prices = new List <decimal>();
candlesTrades.History.ForEach(p => {
prices.Add(Decimal(p.Close));
prices.Add(Decimal(p.Open));
prices.Add(Decimal(p.High));
prices.Add(Decimal(p.Low));
});
Assert.Multiple(() =>
{
Assert.That(prices, Does.Contain(Decimal(newMinSellPrice)), "Close price does not contain new min sell price");
Assert.That(candlesTrades.History.Select(c => Decimal(c.TradingOppositeVolume)), Does.Contain(Decimal(tradingVolume / 2)), "does not contain trading volume");
});
}
private void ExecuteOrder(int volume, TradeType tradeType)
{
var request = new MarketOrderRequest(tradeType, volume)
{
Label = "BerthoRobot",
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
public async Task <long> CreateMarketOrder(string accountId, string instrument, long units)
{
MarketOrderRequest request = new MarketOrderRequest()
{
instrument = instrument,
units = units,
};
OrderPostResponse response = await Rest20.PostOrderAsync(accountId, request);
return(response.orderFillTransaction.id);
}
public static OrderRequest ToOrderRequest(MarketOrderRequest request)
{
return(new OrderRequest {
AccountId = request.AccountId,
Action = request.Action,
Ticker = request.Ticker,
Type = OrderType.OrderMarket,
Quantity = request.Quantity,
OrderPrice = 0,
TimeInForce = OrderTimeInForce.OrderDay
});
}
/// <summary>
/// Send a Sell trade request
/// </summary>
private void Sell()
{
Request request = new MarketOrderRequest(TradeType.Sell, Volume)
{
Label = "Gann HiLo",
//SlippagePips = 1,
StopLossPips = StopLoss > 0 ? (int?)StopLoss : null,
TakeProfitPips = TakeProfit > 0 ? (int?)TakeProfit : null
};
Trade.Send(request);
}
private void ExecuteTrade(TradeType tradeType)
{
var request = new MarketOrderRequest(tradeType, Volume)
{
Label = Label,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
public static TradingSignal ToMarketOrder(this MarketOrderRequest request, bool isMarginOrder)
{
return(new TradingSignal(
new Instrument(request.Instrument),
orderId: null,
command: OrderCommand.Create,
tradeType: request.TradeType,
price: 0,
volume: request.Volume,
time: DateTime.UtcNow,
isMarginOrder: isMarginOrder,
orderType: OrderType.Market
));
}
public void PostOrdersMarket()
{
Step("Make POST orders/market and validate response", () =>
{
var model = new MarketOrderRequest
{
AssetId = "BTC",
AssetPairId = "BTCUSD",
OrderAction = OrderAction.Sell,
Volume = 0.01
};
var response = apiV2.Orders.PostOrdersMarket(model, token);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
});
}
protected override void OnBar()
{
double top = bollingerBands.Top.LastValue;
double bottom = bollingerBands.Bottom.LastValue;
if ((top - bottom) / Symbol.PipSize <= BandHeight)
{
Domination = Domination + 1;
}
else
{
Domination = 0;
}
if (Domination >= DominationPeriods)
{
if (Symbol.Ask > top && MarketSeries.Close[MarketSeries.Close.Count - 2] > MarketSeries.Open[MarketSeries.Close.Count - 2])
{
var request = new MarketOrderRequest(TradeType.Buy, Volume)
{
Label = "SampleGameTheory",
StopLossPips = StopLossInPips,
TakeProfitPips = TakeProfitInPips
};
Trade.Send(request);
Domination = 0;
}
else if (Symbol.Bid < bottom && MarketSeries.Close[MarketSeries.Close.Count - 2] < MarketSeries.Open[MarketSeries.Close.Count - 2])
{
var request = new MarketOrderRequest(TradeType.Sell, Volume)
{
Label = "SampleGameTheory",
StopLossPips = StopLossInPips,
TakeProfitPips = TakeProfitInPips
};
Trade.Send(request);
Domination = 0;
}
}
}
protected override void OnBar()
{
double top = bollingerBands.Top.LastValue;
double bottom = bollingerBands.Bottom.LastValue;
if ((top - bottom) / Symbol.PipSize <= BandHeight)
{
Domination = Domination + 1;
}
else
{
Domination = 0;
}
if (Domination >= DominationPeriods)
{
if (Symbol.Ask > top && MarketSeries.Close[MarketSeries.Close.Count - 2] > MarketSeries.Open[MarketSeries.Close.Count - 2])
{
var request = new MarketOrderRequest(TradeType.Buy, Volume)
{
Label = "SampleGameTheory",
StopLossPips = StopLossInPips,
TakeProfitPips = TakeProfitInPips
};
Trade.Send(request);
Domination = 0;
}
else if (Symbol.Bid < bottom && MarketSeries.Close[MarketSeries.Close.Count - 2] < MarketSeries.Open[MarketSeries.Close.Count - 2])
{
var request = new MarketOrderRequest(TradeType.Sell, Volume)
{
Label = "SampleGameTheory",
StopLossPips = StopLossInPips,
TakeProfitPips = TakeProfitInPips
};
Trade.Send(request);
Domination = 0;
}
}
}
private void OpenPosition(TradeType type)
{
if (_position != null)
{
Trade.Close(_position);
}
Volume = GetVolume;
Print(Volume);
Request request = new MarketOrderRequest(type, Volume)
{
Label = "CCI 20",
StopLossPips = StopLoss > 0 ? StopLoss : (int?)null,
TakeProfitPips = TakeProfit > 0 ? TakeProfit : (int?)null,
};
Trade.Send(request);
}
public override async Task <ExecuteMarketOrderResponse> ExecuteMarketOrder(MarketOrderRequest request, ServerCallContext context)
{
if (!_settings.InstrumentMappings.TryGetValue(request.AssetPair, out var assetPairId))
{
_logger.LogWarning("Asset pair not found. {assetPairId}", request.AssetPair);
return(new ExecuteMarketOrderResponse
{
Error = ErrorCode.Critical,
ErrorMessage = "Asset pair not found"
});
}
var orderId = $"{((int)request.TradeTypeTag).ToString()}{request.ComponentTag}{Guid.NewGuid().ToString().Remove(0, 1 + request.ComponentTag.Length)}";
decimal size = decimal.Parse(request.Size, CultureInfo.InvariantCulture);
var response = await _b2C2RestClient.OrderAsync(new OrderRequest
{
ClientOrderId = orderId,
Instrument = assetPairId,
Side = size > 0
? Side.Buy
: Side.Sell,
Quantity = Math.Abs(size),
OrderType = OrderType.MKT,
ValidUntil = DateTime.UtcNow.AddSeconds(3)
});
var result = new ExecuteMarketOrderResponse
{
OrderId = response.OrderId,
RequestId = response.ClientOrderId,
AssetPairId = request.AssetPair,
Price = response.ExecutedPrice.ToString(CultureInfo.InvariantCulture),
FilledSize = (response.Side == Side.Buy ? response.Quantity : -response.Quantity).ToString(CultureInfo.InvariantCulture),
CancelledSize = "0",
Timestamp = response.Created.ToTimestamp(),
Error = ErrorCode.Ok
};
result.Trades.AddRange(MapTrades(response.Trades));
return(result);
}
public async Task <IActionResult> CreateMarketOrder([FromBody] MarketOrderRequest request)
{
try
{
var result = await GetAuthenticatedExchange().AddOrderAndWaitExecution(request.ToMarketOrder(false), TimeSpan.FromSeconds(DefaultTimeOutSeconds));
return(Ok(new OrderIdResponse {
OrderId = result.ExchangeOrderId.ToString()
}));
}
catch (ApiException ex)
{
if (ex.ApiStatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest(new ErrorModel(ex.Message, ex.ErrorCode)));
}
return(StatusCode((int)HttpStatusCode.InternalServerError, new ErrorModel(ex.Message, ex.ErrorCode)));
}
}
public void PostOrdersMarketTest()
{
var request = new MarketOrderRequest()
{
Asset = SecondAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 0.2
};
var response = hft.Orders.PostOrdersMarket(request, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
Assert.That(response.GetResponseObject().Result, Is.Not.Null);
var requestSell = new MarketOrderRequest()
{
Asset = SecondAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.1
};
var responseSell = hft.Orders.PostOrdersMarket(requestSell, ApiKey);
}
public void MONumerousTradesCandleTest()
{
(var newMinSellPrice, var newMaxBuyPrice) = newMinMaxPrices();
for (var i = 0; i < partialCount; i++)
{
var requestSell = new LimitOrderRequest()
{
Price = newMinSellPrice + i / Math.Pow(10, 5), AssetPairId = AssetPairId, OrderAction = OrderAction.Sell, Volume = tradingVolume
};
var responseSell = hft.Orders.PostOrdersLimitOrder(requestSell, ApiKey);
responseSell.Validate.StatusCode(HttpStatusCode.OK);
}
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
hft.OrderBooks.GetOrderBooks(AssetPairId);
var requestBuy = new MarketOrderRequest()
{
AssetPairId = AssetPairId, OrderAction = OrderAction.Buy, Volume = tradingVolume * partialCount, Asset = FirstAssetId
};
var responseBuy = hft.Orders.PostOrdersMarket(requestBuy, SecondWalletApiKey);
responseBuy.Validate.StatusCode(HttpStatusCode.OK);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
var candlesTrades = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Trades, CandleTimeInterval.Minute, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesAsk = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Ask, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesBid = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Bid, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
Assert.Multiple(() =>
{
Assert.That(candlesTrades.History.Select(c => Decimal(c.High)), Does.Contain(Decimal(newMinSellPrice) + Decimal((partialCount - 1) / Math.Pow(10, 5))), "Unexpected max price");
Assert.That(candlesTrades.History.Select(c => Decimal(c.Low)), Does.Contain(Decimal(newMinSellPrice)), "Unexpected low price");
Assert.That(candlesTrades.History.Select(c => Decimal(c.TradingVolume)), Does.Contain(Decimal(tradingVolume) * Decimal(partialCount)), "does not contain trading volume");
});
}
public void LOSellPartiallyMarketOrderExecutionCandleTest()
{
(var newMinSellPrice, var newMaxBuyPrice) = newMinMaxPrices();
var requestSell = new LimitOrderRequest()
{
Price = newMinSellPrice, AssetPairId = AssetPairId, OrderAction = OrderAction.Sell, Volume = tradingVolume * partialCount
};
var responseSell = hft.Orders.PostOrdersLimitOrder(requestSell, ApiKey);
responseSell.Validate.StatusCode(HttpStatusCode.OK);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
var requestBuy = new MarketOrderRequest()
{
AssetPairId = AssetPairId, OrderAction = OrderAction.Buy, Volume = tradingVolume, Asset = FirstAssetId
};
for (var i = 0; i < partialCount; i++)
{
var responseBuy = hft.Orders.PostOrdersMarket(requestBuy, SecondWalletApiKey);
responseBuy.Validate.StatusCode(HttpStatusCode.OK);
}
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
var candlesTrades = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Trades, CandleTimeInterval.Minute, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesAsk = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Ask, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesBid = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Bid, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
Assert.Multiple(() =>
{
Assert.That(candlesTrades.History.Select(c => Decimal(c.Close)), Does.Contain(Decimal(newMinSellPrice)), "Close price does not contain new min sell price");
Assert.That(candlesTrades.History.Select(c => Decimal(c.TradingVolume)), Does.Contain(Decimal(tradingVolume) * Decimal(partialCount)), "does not contain trading volume");
Assert.That(candlesTrades.History.Select(c => Decimal(c.TradingOppositeVolume)), Does.Contain((Decimal(tradingVolume) * Decimal(newMinSellPrice) * partialCount)), "does not contain trading volume * sell price");
});
}
static async Task <long?> PlaceMarketOrder(string side = "buy")
{
WriteNewLine("Creating a EUR_USD market BUY order ...");
var parameters = new AccountInstrumentsParameters()
{
instruments = new List <string>()
{
INSTRUMENT
}
};
var oandaInstrument = (await Rest20.GetAccountInstrumentsAsync(AccountID, parameters)).First();
decimal orderUnits = side == "buy" ? 10 : -10;
var request = new MarketOrderRequest(oandaInstrument)
{
units = orderUnits
};
PostOrderResponse response = null;
try
{
response = await Rest20.PostOrderAsync(AccountID, request);
WriteNewLine("Congrats! You've put on a trade! Let it run! :)");
}
catch (Exception ex)
{
var errorResponse = ErrorResponseFactory.Create(ex.Message);
WriteNewLine("Oops. Order creation failed.");
WriteNewLine($"The failure message is: {errorResponse.errorMessage}.");
WriteNewLine("Try again later.");
}
return(response?.orderFillTransaction?.tradeOpened?.tradeID);
}
public async Task <IActionResult> PlaceMarketOrder([FromBody] MarketOrderRequest request)
{
var id = Guid.NewGuid();
var asset = _assetsServiceClient.Assets.Get(request.AssetId);
var pair = _assetsServiceClient.AssetPairs.Get(request.AssetPairId);
if (asset == null)
{
return(NotFound($"Asset '{request.AssetId}' not found."));
}
if (pair == null)
{
return(NotFound($"Asset pair '{request.AssetPairId}' not found."));
}
if (pair.IsDisabled)
{
return(BadRequest($"Asset pair '{request.AssetPairId}' disabled."));
}
if (request.AssetId != pair.BaseAssetId && request.AssetId != pair.QuotingAssetId)
{
return(BadRequest());
}
var baseAsset = _assetsServiceClient.Assets.Get(pair.BaseAssetId);
var quotingAsset = _assetsServiceClient.Assets.Get(pair.QuotingAssetId);
var tradingSession = await _clientSessionsClient.GetTradingSession(_requestContext.SessionId);
var confirmationRequired = _baseSettings.EnableSessionValidation && !(tradingSession?.Confirmed ?? false);
if (confirmationRequired)
{
return(BadRequest("Session confirmation is required"));
}
var command = new CreateMarketOrderCommand
{
AssetId = request.AssetId,
AssetPair = new AssetPairModel
{
Id = request.AssetPairId,
BaseAsset = ConvertAssetToAssetModel(baseAsset),
QuotingAsset = ConvertAssetToAssetModel(quotingAsset),
MinVolume = pair.MinVolume,
MinInvertedVolume = pair.MinInvertedVolume
},
Volume = Math.Abs(request.Volume),
OrderAction = request.OrderAction == OrderAction.Buy
? Lykke.Service.Operations.Contracts.Orders.OrderAction.Buy
: Lykke.Service.Operations.Contracts.Orders.OrderAction.Sell,
Client = await GetClientModel(),
GlobalSettings = GetGlobalSettings()
};
try
{
await _operationsClient.PlaceMarketOrder(id, command);
}
catch (HttpOperationException e)
{
if (e.Response.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest(JObject.Parse(e.Response.Content)));
}
throw;
}
return(Created(Url.Action("Get", "Operations", new { id }), id));
}
private void ExecuteTrade(TradeType tradeType)
{
var request = new MarketOrderRequest(tradeType, Volume)
{
Label = Label,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
/// <summary>
/// Send a Sell trade request
/// </summary>
private void Sell()
{
Request request = new MarketOrderRequest(TradeType.Sell, Volume)
{
Label = "Gann HiLo",
//SlippagePips = 1,
StopLossPips = StopLoss > 0 ? (int?)StopLoss : null,
TakeProfitPips = TakeProfit > 0 ? (int?)TakeProfit : null
};
Trade.Send(request);
}
public virtual Task <OrderIdResponse> CreateMarketOrderAsync([FromBody] MarketOrderRequest request)
{
throw new System.NotImplementedException();
}
protected override void OnPositionClosed(Position closedPosition)
{
switch (closedPosition.TradeType)
{
case TradeType.Buy:
LongPositions--;
break;
case TradeType.Sell:
ShortPositions--;
break;
}
if (closedPosition.GrossProfit < 1)
{
Message(1, "Attacked by St. George!");
if (LossDelay > 0)
{
Count = -(LossDelay);
Message(1, "Dragon is licking his wounds...");
}
if (AdaptiveBias == true)
{
switch (closedPosition.TradeType)
{
case TradeType.Buy:
if (MaxLong > 1)
{
MaxLong--;
}
if (MaxShort < MaxShortTrades)
{
MaxShort++;
}
break;
case TradeType.Sell:
if (MaxShort > 1)
{
MaxShort--;
}
if (MaxLong < MaxLongTrades)
{
MaxLong++;
}
break;
}
}
if (MartingaleEnabled && MartingaleActive < MartingaleMax)
{
MartingaleActive++;
BuyVolume = (int)closedPosition.Volume * MartingaleFactor;
if (MaxLotSize > 0 && BuyVolume > MaxLotSize)
{
BuyVolume = MaxLotSize;
}
if (Reversingale)
{
Message(1, "Taking evasive action");
if (closedPosition.TradeType == TradeType.Sell)
{
TakeProfit = (int)(-closedPosition.Pips / MartingaleFactor * 1.2);
if (TakeProfit < MinimumPips)
{
TakeProfit = MinimumPips;
}
Request request = new MarketOrderRequest(TradeType.Buy, BuyVolume)
{
Label = DragonID,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
else
{
TakeProfit = (int)(-closedPosition.Pips / MartingaleFactor * 1.2);
if (TakeProfit < MinimumPips)
{
TakeProfit = MinimumPips;
}
Request request = new MarketOrderRequest(TradeType.Sell, BuyVolume)
{
Label = DragonID,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
Message(2, "Reversingale Stop. Entry " + closedPosition.EntryPrice + ", Loss " + closedPosition.GrossProfit + ", New Entry " + Symbol.Ask + ", New Target " + TakeProfit);
}
}
}
else
{
BuyVolume = OpeningLotSize;
if (MartingaleActive > 0)
{
// MartingaleActive--;
// Message(1, "St. George defeated! Revenge is sweet");
}
else
{
Message(1, "Dinner is served!");
}
}
}
private void OpenPosition(TradeType tradetype)
{
if (Trade.IsExecuting || Count < BuyWait)
{
return;
}
switch (tradetype)
{
case TradeType.Buy:
switch (TargetLevel)
{
case -1:
TakeProfit = (int)(Math.Abs(t1l1 - ask) / pipsize);
break;
case 0:
TakeProfit = (int)(Math.Abs(t1c0 - ask) / pipsize);
break;
case 1:
TakeProfit = (int)(Math.Abs(t1h1 - ask) / pipsize);
break;
case 2:
TakeProfit = (int)(Math.Abs(t1h2 - ask) / pipsize);
break;
case 3:
TakeProfit = (int)(Math.Abs(t1h3 - ask) / pipsize);
break;
}
break;
case TradeType.Sell:
switch (TargetLevel)
{
case -1:
TakeProfit = (int)(Math.Abs(bid - t1h1) / pipsize);
break;
case 0:
TakeProfit = (int)(Math.Abs(bid - t1c0) / pipsize);
break;
case 1:
TakeProfit = (int)(Math.Abs(bid - t1l1) / pipsize);
break;
case 2:
TakeProfit = (int)(Math.Abs(bid - t1l2) / pipsize);
break;
case 3:
TakeProfit = (int)(Math.Abs(bid - t1l3) / pipsize);
break;
}
break;
}
if (MartingaleEnabled && MartingaleActive > 0)
{
TakeProfit = (int)(StopLoss / MartingaleFactor * 1.2);
Message(1, "St.George sighted...");
}
if (MoneyManagement == true && Account.Balance > OpeningBalance)
{
Quantity = BuyVolume * (int)(Account.Balance / OpeningBalance);
Message(3, "Money Management : " + Quantity + "(BV:" + BuyVolume + ")");
}
else
{
Quantity = BuyVolume;
}
if (MaxLotSize > 0 && Quantity > MaxLotSize)
{
Quantity = MaxLotSize;
}
if (TakeProfit < MinimumPips)
{
TakeProfit = MinimumPips;
}
Request request = new MarketOrderRequest(tradetype, Quantity)
{
Label = DragonID,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
Count = 0;
}
private void OpenPosition(TradeType type)
{
if (_position != null)
Trade.Close(_position);
Volume = GetVolume;
Print(Volume);
Request request = new MarketOrderRequest(type, Volume)
{
Label = "CCI 20",
StopLossPips = StopLoss > 0 ? StopLoss : (int?) null,
TakeProfitPips = TakeProfit > 0 ? TakeProfit : (int?) null,
};
Trade.Send(request);
}
public void SendBuyCommand(int p_Volume, double p_StopLoss, double p_TakeProfit)
{
MarketOrderRequest l_Request = new MarketOrderRequest(TradeType.Buy, p_Volume)
{
Label = "CRiskATrader",
SlippagePips = 10
};
l_Request.StopLossPips = Convert.ToInt32((Symbol.Ask - p_StopLoss) / Symbol.PipSize);
l_Request.TakeProfitPips = Convert.ToInt32((p_TakeProfit - Symbol.Ask) / Symbol.PipSize);
Trade.Send(l_Request);
}
public ActionResult <OrderResponse> SubmitMarketOrder(MarketOrderRequest request)
{
logger.Information("SubmitMarketOrder");
return(SubmitOrder(OrderTransformer.ToOrderRequest(request)));
}
protected override void OnPositionClosed(Position closedPosition)
{
switch (closedPosition.TradeType)
{
case TradeType.Buy:
LongPositions--;
break;
case TradeType.Sell:
ShortPositions--;
break;
}
if (closedPosition.GrossProfit < 1)
{
Message(1, "Attacked by St. George!");
if (LossDelay > 0)
{
Count = -(LossDelay);
Message(1, "Dragon is licking his wounds...");
}
if (AdaptiveBias == true)
{
switch (closedPosition.TradeType)
{
case TradeType.Buy:
if (MaxLong > 1)
MaxLong--;
if (MaxShort < MaxShortTrades)
MaxShort++;
break;
case TradeType.Sell:
if (MaxShort > 1)
MaxShort--;
if (MaxLong < MaxLongTrades)
MaxLong++;
break;
}
}
if (MartingaleEnabled && MartingaleActive < MartingaleMax)
{
MartingaleActive++;
BuyVolume = (int)closedPosition.Volume * MartingaleFactor;
if (MaxLotSize > 0 && BuyVolume > MaxLotSize)
BuyVolume = MaxLotSize;
if (Reversingale)
{
Message(1, "Taking evasive action");
if (closedPosition.TradeType == TradeType.Sell)
{
TakeProfit = (int)(-closedPosition.Pips / MartingaleFactor * 1.2);
if (TakeProfit < MinimumPips)
TakeProfit = MinimumPips;
Request request = new MarketOrderRequest(TradeType.Buy, BuyVolume)
{
Label = DragonID,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
else
{
TakeProfit = (int)(-closedPosition.Pips / MartingaleFactor * 1.2);
if (TakeProfit < MinimumPips)
TakeProfit = MinimumPips;
Request request = new MarketOrderRequest(TradeType.Sell, BuyVolume)
{
Label = DragonID,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
}
Message(2, "Reversingale Stop. Entry " + closedPosition.EntryPrice + ", Loss " + closedPosition.GrossProfit + ", New Entry " + Symbol.Ask + ", New Target " + TakeProfit);
}
}
}
else
{
BuyVolume = OpeningLotSize;
if (MartingaleActive > 0)
{
// MartingaleActive--;
// Message(1, "St. George defeated! Revenge is sweet");
}
else
Message(1, "Dinner is served!");
}
}
private void OpenPosition(TradeType tradetype)
{
if (Trade.IsExecuting || Count < BuyWait)
{
return;
}
switch (tradetype)
{
case TradeType.Buy:
switch (TargetLevel)
{
case -1:
TakeProfit = (int)(Math.Abs(t1l1 - ask) / pipsize);
break;
case 0:
TakeProfit = (int)(Math.Abs(t1c0 - ask) / pipsize);
break;
case 1:
TakeProfit = (int)(Math.Abs(t1h1 - ask) / pipsize);
break;
case 2:
TakeProfit = (int)(Math.Abs(t1h2 - ask) / pipsize);
break;
case 3:
TakeProfit = (int)(Math.Abs(t1h3 - ask) / pipsize);
break;
}
break;
case TradeType.Sell:
switch (TargetLevel)
{
case -1:
TakeProfit = (int)(Math.Abs(bid - t1h1) / pipsize);
break;
case 0:
TakeProfit = (int)(Math.Abs(bid - t1c0) / pipsize);
break;
case 1:
TakeProfit = (int)(Math.Abs(bid - t1l1) / pipsize);
break;
case 2:
TakeProfit = (int)(Math.Abs(bid - t1l2) / pipsize);
break;
case 3:
TakeProfit = (int)(Math.Abs(bid - t1l3) / pipsize);
break;
}
break;
}
if (MartingaleEnabled && MartingaleActive > 0)
{
TakeProfit = (int)(StopLoss / MartingaleFactor * 1.2);
Message(1, "St.George sighted...");
}
if (MoneyManagement == true && Account.Balance > OpeningBalance)
{
Quantity = BuyVolume * (int)(Account.Balance / OpeningBalance);
Message(3, "Money Management : " + Quantity + "(BV:" + BuyVolume + ")");
}
else
{
Quantity = BuyVolume;
}
if (MaxLotSize > 0 && Quantity > MaxLotSize)
Quantity = MaxLotSize;
if (TakeProfit < MinimumPips)
TakeProfit = MinimumPips;
Request request = new MarketOrderRequest(tradetype, Quantity)
{
Label = DragonID,
SlippagePips = Slippage,
StopLossPips = StopLoss,
TakeProfitPips = TakeProfit
};
Trade.Send(request);
Count = 0;
}
private void ExecuteTrade(TradeType tradeType, int volume)
{
Request request = new MarketOrderRequest(tradeType, volume)
{
Label = LabelName
};
Trade.Send(request);
}
