public async Task <string> CreateLimitOrderAsync(string assetPair, decimal price, decimal volume,
OrderType orderType)
{
try
{
OrderIdResponse response = await _client.CreateLimitOrderAsync(new LimitOrderRequest
{
Instrument = GetAssetPairId(assetPair),
TradeType = orderType == OrderType.Sell
? TradeType.Sell
: TradeType.Buy,
Price = price,
Volume = volume
});
return(response.OrderId);
}
catch (FailedOperationException)
{
throw;
}
catch (Exception exception)
{
throw new Exception("An error occurred while creating limit order", exception);
}
}
public async Task <IActionResult> CreateLimitOrder([FromBody] LimitOrderRequest order)
{
var orderId = Guid.NewGuid().ToString();
var mlm = new MultiLimitOrderModel()
{
AssetId = order.Instrument,
ClientId = this.ClientId(),
CancelMode = CancelMode.BothSides,
CancelPreviousOrders = false,
Id = Guid.NewGuid().ToString(),
Orders = new List <MultiOrderItemModel> {
new MultiOrderItemModel()
{
Id = orderId,
OrderAction = order.TradeType == TradeType.Buy ? OrderAction.Buy : OrderAction.Sell,
Fee = null,
OldId = null,
Price = (double)order.Price,
Volume = (double)order.Volume
}
}
};
var res = await _meclient.PlaceMultiLimitOrderAsync(mlm);
var status = res.Statuses.Any() ? res.Statuses[0].Status : MeStatusCodes.BadRequest;
if (status == MeStatusCodes.Ok)
{
var resp = new OrderIdResponse()
{
OrderId = orderId
};
return(Ok(resp));
}
return(BadRequest($"incorect result: {status}"));
}
public async Task ExecuteLimitOrderAsync(HedgeLimitOrder hedgeLimitOrder)
{
await _hedgeLimitOrderService.AddAsync(hedgeLimitOrder);
ExternalOrder externalOrder =
await _externalOrderRepository.GetAsync(hedgeLimitOrder.Exchange, hedgeLimitOrder.AssetId);
if (externalOrder != null)
{
hedgeLimitOrder.Error = LimitOrderError.Unknown;
hedgeLimitOrder.ErrorMessage = "Already exists";
return;
}
AssetPairSettings assetPairSettings =
await _instrumentService.GetAssetPairAsync(hedgeLimitOrder.AssetPairId, hedgeLimitOrder.Exchange);
if (assetPairSettings == null)
{
hedgeLimitOrder.Error = LimitOrderError.Unknown;
hedgeLimitOrder.ErrorMessage = "Instrument not configured";
_log.WarningWithDetails("No settings for instrument", hedgeLimitOrder);
return;
}
decimal price = hedgeLimitOrder.Price
.TruncateDecimalPlaces(assetPairSettings.PriceAccuracy, hedgeLimitOrder.Type == LimitOrderType.Sell);
decimal volume = Math.Round(hedgeLimitOrder.Volume, assetPairSettings.VolumeAccuracy);
if (volume < assetPairSettings.MinVolume)
{
hedgeLimitOrder.Error = LimitOrderError.TooSmallVolume;
return;
}
ISpotController spotController = _exchangeAdapterClientFactory.GetSpotController(Name);
try
{
var assetPair = assetPairSettings.AssetPairId;
// TODO: Remove this workaround
if (Name == "NettingEngineDefault")
{
assetPair = GetAssetPair(assetPair);
}
OrderIdResponse response = await spotController.CreateLimitOrderAsync(new LimitOrderRequest
{
Instrument = assetPair,
TradeType = hedgeLimitOrder.Type == LimitOrderType.Sell ? TradeType.Sell : TradeType.Buy,
Price = price,
Volume = volume
});
externalOrder = new ExternalOrder(response.OrderId, hedgeLimitOrder.Exchange,
hedgeLimitOrder.AssetId, hedgeLimitOrder.Id);
await _externalOrderRepository.InsertAsync(externalOrder);
_log.InfoWithDetails("External order created", externalOrder);
}
catch (Exception exception)
{
hedgeLimitOrder.Error = LimitOrderError.Unknown;
hedgeLimitOrder.ErrorMessage = exception.Message;
_log.WarningWithDetails("An error occurred while creating external order", exception, hedgeLimitOrder);
}
}
