public void Properties()
{
var user = new Mock <IBinanceApiUser>().Object;
var clientOrder = new TakeProfitLimitOrder(user);
Assert.Equal(OrderType.TakeProfitLimit, clientOrder.Type);
Assert.Equal(0, clientOrder.StopPrice);
}
public void ValidateOrderType()
{
var symbol = Symbol.BTC_USDT;
var user = new Mock <IBinanceApiUser>().Object;
Assert.Contains(OrderType.Limit, symbol.OrderTypes);
symbol.Validate(OrderType.Limit);
var order = new LimitOrder(new Mock <IBinanceApiUser>().Object);
symbol.ValidateOrderType(order);
var takeProfitLimitOrder = new TakeProfitLimitOrder(user);
if (symbol.OrderTypes.Contains(OrderType.TakeProfitLimit))
{
symbol.ValidateOrderType(takeProfitLimitOrder);
}
else
{
Assert.Throws <ArgumentException>(nameof(takeProfitLimitOrder.Type), () => symbol.ValidateOrderType(takeProfitLimitOrder));
}
}
public void IsValidOrder()
{
var symbol = Symbol.BTC_USDT;
var user = new Mock <IBinanceApiUser>().Object;
const decimal price = 10000;
const decimal quantity = 1;
Assert.Equal(8, symbol.BaseAsset.Precision);
Assert.Equal(8, symbol.QuoteAsset.Precision);
var order = new LimitOrder(user);
Assert.False(symbol.IsValid(order));
order.Price = price;
Assert.False(symbol.IsValid(order));
order.Quantity = quantity;
Assert.False(symbol.IsValid(order));
order.Symbol = symbol;
Assert.True(symbol.IsValid(order));
var takeProfitLimitOrder = new TakeProfitLimitOrder(user)
{
Symbol = symbol,
Price = price,
Quantity = quantity
};
if (symbol.OrderTypes.Contains(OrderType.TakeProfitLimit))
{
Assert.True(symbol.IsValid(takeProfitLimitOrder));
}
else
{
Assert.False(symbol.IsValid(takeProfitLimitOrder));
}
order.Price = price;
order.Quantity = 0.000000001m;
Assert.False(symbol.IsValid(order));
order.Price = 0.000000001m;
order.Quantity = quantity;
Assert.False(symbol.IsValid(order));
order.Price = price;
order.Quantity = symbol.Quantity.Maximum + symbol.Quantity.Increment;
Assert.False(symbol.IsValid(order));
order.Price = symbol.Price.Minimum - symbol.Price.Increment;
order.Quantity = quantity;
Assert.False(symbol.IsValid(order));
order.Price = price;
order.Quantity = symbol.NotionalMinimumValue / price;
Assert.True(symbol.IsValid(order));
order.Price = price;
order.Quantity = symbol.NotionalMinimumValue / price - symbol.Quantity.Increment;
Assert.False(symbol.IsValid(order));
}
public async Task <bool> HandleAsync(string command, CancellationToken token = default)
{
if (!command.StartsWith("takeProfitLimit ", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
var args = command.Split(' ');
if (args.Length < 6)
{
lock (Program.ConsoleSync)
Console.WriteLine("A side, symbol, quantity, price, and stop price are required.");
return(true);
}
if (!Enum.TryParse(args[1], out OrderSide side))
{
lock (Program.ConsoleSync)
Console.WriteLine("A valid order side is required ('buy' or 'sell').");
return(true);
}
var symbol = args[2];
if (!decimal.TryParse(args[3], out var quantity) || quantity <= 0)
{
lock (Program.ConsoleSync)
Console.WriteLine("A quantity greater than 0 is required.");
return(true);
}
if (!decimal.TryParse(args[4], out var price) || price <= 0)
{
lock (Program.ConsoleSync)
Console.WriteLine("A price greater than 0 is required.");
return(true);
}
if (!decimal.TryParse(args[5], out var stopPrice) || stopPrice <= 0)
{
lock (Program.ConsoleSync)
Console.WriteLine("A stop price greater than 0 is required.");
return(true);
}
var clientOrder = new TakeProfitLimitOrder(Program.User)
{
Symbol = symbol,
Side = (OrderSide)side,
Quantity = quantity,
Price = price,
StopPrice = stopPrice
};
if (Program.IsOrdersTestOnly)
{
await Program.BinanceApi.TestPlaceAsync(clientOrder, token : token);
lock (Program.ConsoleSync)
{
Console.WriteLine($"~ TEST ~ >> TAKE PROFIT LIMIT {clientOrder.Side} order (ID: {clientOrder.Id}) placed for {clientOrder.Quantity:0.00000000} {clientOrder.Symbol} @ {clientOrder.Price:0.00000000}");
}
}
else
{
var order = await Program.BinanceApi.PlaceAsync(clientOrder, token : token);
// ReSharper disable once InvertIf
if (order != null)
{
lock (Program.ConsoleSync)
{
Console.WriteLine($">> TAKE PROFIT LIMIT {order.Side} order (ID: {order.Id}) placed for {order.OriginalQuantity:0.00000000} {order.Symbol} @ {order.Price:0.00000000}");
}
}
}
return(true);
}
