public void PostOrdersLimitNegativeTest()
{
var request1 = new PlaceLimitOrderModel()
{
Price = 1.0, AssetPairId = AssetPair, OrderAction = OrderAction.Buy
};
var request2 = new PlaceLimitOrderModel()
{
Price = 1.0, OrderAction = OrderAction.Buy, Volume = 0.1
};
var request3 = new PlaceLimitOrderModel()
{
AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.1
};
var request4 = new PlaceLimitOrderModel()
{
};
Assert.Multiple(() =>
{
Assert.That(hft.Orders.PostOrdersLimitOrder(request1, ApiKey).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(hft.Orders.PostOrdersLimitOrder(request2, ApiKey).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(hft.Orders.PostOrdersLimitOrder(request3, ApiKey).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(hft.Orders.PostOrdersLimitOrder(request4, ApiKey).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
});
}
public void AskSellLOSpotTest()
{
(var newMinSellPrice, var newMaxBuyPrice) = newMinMaxPrices();
var requestSell = new PlaceLimitOrderModel()
{
Price = newMinSellPrice, 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));
var candlesBid = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Bid, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesAsk = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Ask, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
var candlesMid = lykkeApi.CandleHistory.GetCandleHistory(AssetPairId, CandlePriceType.Mid, CandleTimeInterval.Sec, fromMoment, DateTime.Now.ToUniversalTime()).GetResponseObject();
Assert.Multiple(() =>
{
Assert.That(candlesAsk.History.Select(c => c.Low), Does.Contain(newMinSellPrice), "Low is not as in order");
Assert.That(candlesAsk.History.Select(c => c.High), Does.Contain(newMinSellPrice), "High is not as in order");
Assert.That(candlesAsk.History.Select(c => c.Open), Does.Contain(newMinSellPrice), "Open is not as in order");
});
}
public IResponse <LimitOrderResponseModel> PostOrdersLimitOrder(PlaceLimitOrderModel request, string apiKey)
{
return(Request.Post($"/Orders/v2/limit")
.AddJsonBody(request)
.WithHeaders("api-key", apiKey)
.Build().Execute <LimitOrderResponseModel>());
}
public async Task PlaceLimitAndCancelOrder()
{
var client = GetClient <IOrdersApi>();
var order = new PlaceLimitOrderModel
{
AssetPairId = "BTCUSD",
OrderAction = GetRandomItem(_actions),
Price = 500,
Volume = 0.001m
};
var result = await client.PlaceLimitOrder(order).TryExecute();
if (result.Success)
{
result.Result.Id.Should().NotBe(Guid.Empty);
}
else
{
result.Error.Should().NotBeNull();
}
if (result.Success)
{
await client.CancelLimitOrder(result.Result.Id);
}
}
public void GetOrderBooksUnknowAssetStatusTest()
{
var limitRequest = new PlaceLimitOrderModel()
{
Price = 1.0, AssetPairId = "BLRBTS", OrderAction = OrderAction.Buy, Volume = 0.1
};
var limitResponse = hft.Orders.PostOrdersLimitOrder(limitRequest, ApiKey);
Assert.That(limitResponse.StatusCode, Is.AnyOf(HttpStatusCode.NotFound, HttpStatusCode.BadRequest));
}
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 PlaceLimitOrderModel()
{
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 PlaceMarketOrderModel()
{
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");
});
}
public void PostOrdersLimitSellTest()
{
var request = new PlaceLimitOrderModel()
{
Price = 1.0, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.1
};
var response = hft.Orders.PostOrdersLimitOrder(request, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
}
public async Task <IActionResult> PlaceLimitOrderOld(PlaceLimitOrderModel order)
{
var result = await PlaceLimitOrder(order);
if (!(result is OkObjectResult okResult))
{
return(result);
}
var response = (LimitOrderResponseModel)okResult.Value;
return(Ok(response.Id));
}
public async Task <IActionResult> PlaceLimitOrder(PlaceLimitOrderModel order)
{
var assetPair = _assetPairsReadModel.TryGetIfEnabled(order.AssetPairId);
if (assetPair == null)
{
return(NotFound($"Asset-pair {order.AssetPairId} could not be found or is disabled."));
}
if (!_requestValidator.ValidateAssetPair(order.AssetPairId, assetPair, out var badRequestModel))
{
return(BadRequest(badRequestModel));
}
var asset = _assetsReadModel.TryGetIfEnabled(assetPair.BaseAssetId);
if (asset == null)
{
throw new InvalidOperationException($"Base asset '{assetPair.BaseAssetId}' for asset pair '{assetPair.Id}' not found.");
}
var price = order.Price;
if (!_requestValidator.ValidatePrice(price, out badRequestModel))
{
return(BadRequest(badRequestModel));
}
var volume = order.Volume;
var minVolume = assetPair.MinVolume;
if (!_requestValidator.ValidateVolume(volume, minVolume, asset.DisplayId, out badRequestModel))
{
return(BadRequest(badRequestModel));
}
var walletId = User.GetUserId();
var response = await _matchingEngineAdapter.PlaceLimitOrderAsync(
clientId : walletId,
assetPair : assetPair,
orderAction : order.OrderAction,
volume : volume,
price : price);
if (response.Error != null)
{
return(BadRequest(response));
}
return(Ok(response.Result));
}
public void PostOrdersCancelLimitTest()
{
var request = new PlaceLimitOrderModel()
{
Price = 10000000.0, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 0.5
};
var limit = hft.Orders.PostOrdersLimitOrder(request, ApiKey);
var id = limit.GetResponseObject().Id.ToString();
var response = hft.Orders.DeleteOrder(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
}
public void GetOrderByValidIdTest()
{
var request = new PlaceLimitOrderModel()
{
Price = 1.0, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.1
};
var responseOrder = hft.Orders.PostOrdersLimitOrder(request, ApiKey);
responseOrder.Validate.StatusCode(HttpStatusCode.OK);
var id = responseOrder.GetResponseObject().Id.ToString();
var response = hft.Orders.GetOrderById(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
}
public void GetOrderBooksGetNewOrderTest()
{
var ordersBefore = hft.OrderBooks.GetOrderBooks(AssetPair);
ordersBefore.Validate.StatusCode(HttpStatusCode.OK);
double price = default(double);
var volume = 1000;
int i = 0;
HttpStatusCode code = HttpStatusCode.BadRequest;
do
{
price = double.Parse(TestData.GenerateNumbers(3)) / Math.Pow(10, 2);
var request = new PlaceLimitOrderModel()
{
Price = price,
AssetPairId = AssetPair,
OrderAction = OrderAction.Buy,
Volume = volume
};
var response = hft.Orders.PostOrdersLimitOrder(request, ApiKey);
code = response.StatusCode;
i++;
}while (i < 5 && code != HttpStatusCode.OK);
Stopwatch sw = new Stopwatch();
sw.Start();
while (sw.Elapsed < TimeSpan.FromMinutes(5))
{
if (ordersBefore.ResponseObject.FindAll(r => r.IsBuy == true).First().Timestamp != hft.OrderBooks.GetOrderBooks(AssetPair).ResponseObject.FindAll(r => r.IsBuy == true).First().Timestamp)
{
break;
}
System.Threading.Thread.Sleep(2);
}
sw.Stop();
// check that it appear into ordersbook
Assert.That(() =>
{
var order = hft.OrderBooks.GetOrderBooks(AssetPair).ResponseObject.FindAll(r => r.IsBuy == true).First();
return(order.Prices.Any(o => o.Price == price) && order.Prices.Any(o => o.Volume == volume));
}, Is.True.After(5 * 60 * 1000, 2 * 1000), "Order does not appear in orderbook");
}
public void GetOrderBooksNotEnoughFundsStatusTest()
{
var limitRequest = new PlaceLimitOrderModel()
{
Price = 10000000.0, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 10000
};
var limitResponse = hft.Orders.PostOrdersLimitOrder(limitRequest, ApiKey);
limitResponse.Validate.StatusCode(HttpStatusCode.BadRequest);
var id = limitResponse.JObject["Result"]["Id"].ToString();
var response = hft.Orders.GetOrderById(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
Assert.That(response.GetResponseObject().Status, Is.EqualTo(OrderStatus.NotEnoughFunds));
}
public void GetOrderBooksInOrderBookStatusTest()
{
var limitRequest = new PlaceLimitOrderModel()
{
Price = 1.0, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.1
};
var limitResponse = hft.Orders.PostOrdersLimitOrder(limitRequest, ApiKey);
limitResponse.Validate.StatusCode(HttpStatusCode.OK);
var id = limitResponse.GetResponseObject().Id.ToString();
var response = hft.Orders.GetOrderById(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
Assert.That(response.GetResponseObject().Status, Is.EqualTo(OrderStatus.InOrderBook));
}
public void MONumerousTradesCandleTest()
{
(var newMinSellPrice, var newMaxBuyPrice) = newMinMaxPrices();
for (var i = 0; i < partialCount; i++)
{
var requestSell = new PlaceLimitOrderModel()
{
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 PlaceMarketOrderModel()
{
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 PostOrdersMarketBuyTest()
{
var request = new PlaceLimitOrderModel()
{
Price = 100, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 3.2
};
var response = hft.Orders.PostOrdersLimitOrder(request, SecondWalletApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
var requestBuy = new PlaceMarketOrderModel()
{
Asset = FirstAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 3.1
};
var responseBuy = hft.Orders.PostOrdersMarket(requestBuy, ApiKey);
Assert.That(responseBuy.GetResponseObject().Price, Is.Not.Null);
}
public void PostOrdersMarketTest()
{
var request = new PlaceLimitOrderModel()
{
Price = 10, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 3.2
};
var response = hft.Orders.PostOrdersLimitOrder(request, SecondWalletApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
var requestSell = new PlaceMarketOrderModel()
{
Asset = FirstAssetId, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 2.3
};
var responseSell = hft.Orders.PostOrdersMarket(requestSell, ApiKey);
responseSell.Validate.StatusCode(HttpStatusCode.OK);
}
// Limit order
protected IResponse <LimitOrderResponseModel> CreateAndValidateLimitOrder(
double price,
string assetPairId,
OrderAction orderAction,
double volume,
string apiKey,
HttpStatusCode statusCode = HttpStatusCode.OK)
{
var request = new PlaceLimitOrderModel()
{
Price = price,
AssetPairId = assetPairId,
OrderAction = orderAction,
Volume = volume
};
return(hft.Orders.PostOrdersLimitOrder(request, apiKey)
.Validate
.StatusCode(statusCode));
}
public void GetOrderBooksCancelStatusTest()
{
var request = new PlaceLimitOrderModel()
{
Price = 0.01, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.5
};
var limit = hft.Orders.PostOrdersLimitOrder(request, ApiKey);
limit.Validate.StatusCode(HttpStatusCode.OK);
var id = limit.GetResponseObject().Id.ToString();
var response = hft.Orders.DeleteOrder(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
var responseOrder = hft.Orders.GetOrderById(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
Assert.That(() => hft.Orders.GetOrderById(id, ApiKey).GetResponseObject().Status, Is.EqualTo(OrderStatus.Cancelled).After(30 * 1000, 1 * 1000));
}
public void LOSellPartiallyMarketOrderExecutionCandleTest()
{
(var newMinSellPrice, var newMaxBuyPrice) = newMinMaxPrices();
var requestSell = new PlaceLimitOrderModel()
{
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 PlaceMarketOrderModel()
{
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");
});
}
public void GetOrderBooksLeadToNegativeSpreadStatusTest()
{
var limitRequest1 = new PlaceLimitOrderModel()
{
Price = 1.2, AssetPairId = AssetPair, OrderAction = OrderAction.Buy, Volume = 0.01
};
var limitRequest2 = new PlaceLimitOrderModel()
{
Price = 0.8, AssetPairId = AssetPair, OrderAction = OrderAction.Sell, Volume = 0.01
};
var limitResponse1 = hft.Orders.PostOrdersLimitOrder(limitRequest1, ApiKey);
var limitResponse2 = hft.Orders.PostOrdersLimitOrder(limitRequest2, ApiKey);
limitResponse2.Validate.StatusCode(HttpStatusCode.BadRequest);
var id = limitResponse2.JObject["Result"]["Id"].ToString();
var response = hft.Orders.GetOrderById(id, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
Assert.That(() => hft.Orders.GetOrderById(id, ApiKey).GetResponseObject().Status, Is.EqualTo(OrderStatus.LeadToNegativeSpread).After(1 * 60 * 1000, 2 * 1000));
}
public void SetUp()
{
//to start from the minute
if (DateTime.Now.Second > 10)
{
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(60 - DateTime.Now.Second));
}
var orderBooks = hft.OrderBooks.GetOrderBooks(AssetPairId).GetResponseObject();
var minSellPrice = Double.MaxValue;
var maxBuyPrice = Double.MinValue;
orderBooks.FindAll(o => o.IsBuy == true)?.ForEach(o =>
{
o.Prices.ToList()?.ForEach(p =>
{
if (p.Price > maxBuyPrice)
{
maxBuyPrice = p.Price;
}
});
});
orderBooks.FindAll(o => o.IsBuy == false).ForEach(o =>
{
o.Prices.ToList()?.ForEach(p =>
{
if (p.Price < minSellPrice)
{
minSellPrice = p.Price;
}
});
});
if (maxBuyPrice == double.MinValue && minSellPrice != double.MaxValue)
{
maxBuyPrice = 0.9 * minSellPrice;
}
if (minSellPrice == double.MaxValue && maxBuyPrice != double.MinValue)
{
minSellPrice = 1.1 * maxBuyPrice;
}
if (minSellPrice == double.MaxValue && maxBuyPrice == double.MinValue)
{
maxBuyPrice = 1.0;
minSellPrice = 1.3;
}
// accuracy = 5
maxBuyPrice = Make5numberAfterDot(maxBuyPrice);
minSellPrice = Make5numberAfterDot(minSellPrice);
fromMoment = DateTime.Now.ToUniversalTime();
var limitOrderRequestBuy = new PlaceLimitOrderModel()
{
Price = maxBuyPrice, AssetPairId = AssetPairId, OrderAction = OrderAction.Buy, Volume = tradingVolume
};
var response = hft.Orders.PostOrdersLimitOrder(limitOrderRequestBuy, ApiKey);
response.Validate.StatusCode(HttpStatusCode.OK);
var limitOrderRequestSell = new PlaceLimitOrderModel()
{
Price = minSellPrice, AssetPairId = AssetPairId, OrderAction = OrderAction.Sell, Volume = tradingVolume
};
var response1 = hft.Orders.PostOrdersLimitOrder(limitOrderRequestSell, ApiKey);
response1.Validate.StatusCode(HttpStatusCode.OK);
//wait to appear in orderbook
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(7));
}
