private OrderModel CreateTradeOrder(AlertMessage alertMessage, BinancePlacedOrder trade, decimal?btcAmount, decimal?usdtAmount, decimal?currentBtcPrice, decimal?quantity)
{
if (trade == null)
{
_logger.LogError($"Trade was null. Bailing out.");
}
var model = new OrderModel
{
Id = Guid.NewGuid(),
CreatedAt = alertMessage.CreatedAt,
OrderId = trade.OrderId,
MessageId = alertMessage.MessageId,
Completed = false,
USDTAmount = usdtAmount,
BTCAmount = btcAmount,
BTCToTradeAmount = trade.ExecutedQuantity,
BTCToTradeAmountValue = trade.CummulativeQuoteQuantity,
BTCPrice = trade.Price == 0 ? currentBtcPrice : trade.Price,
PercentageToTrade = alertMessage.PercentageToTrade,
Buy = alertMessage.Buy,
Sell = alertMessage.Sell
};
return(model);
}
// Ej: BTC-EUR
// Buy: EUR -> BTC
// Sell: BTC -> EUR
private static void MakeMoney()
{
BinancePlacedOrder buyPlaced = Client.Spot.Order
.PlaceOrder(_session.Pair, OrderSide.Buy, OrderType.Market, null, _session.EurAvailable)
.GetResult();
decimal buyFee = GetFee(buyPlaced);
BinanceOrder buy = WaitOrder(buyPlaced);
_session.WantedPrice = buy.QuoteQuantity + buy.QuoteQuantity * _session.Profit / 100;
string logBuy = $" Comprado: {buy.QuoteQuantity.Round()} - {buyFee.Round()} = {buy.QuoteQuantityFilled.Round()} Eur";
_session.Logs.Add(logBuy);
_session.UpdateAvailable();
UiController.PrintSession(_session);
int count = 1;
bool exit = false;
while (!exit)
{
Sleep(_session.IntervalMin * 6); // 10 veces
decimal price = Client.Spot.Market.GetPrice(_session.Pair).GetResult().Price;
decimal actualPrice = buy.QuantityFilled * price; // Antes o despues de impuestos?
decimal actualFees = actualPrice * _session.TakerFee;
decimal wouldGet = actualPrice - actualFees;
Console.WriteLine($" {count}/10 - Obtendría: {actualPrice.Round()} - {actualFees.Round()} = {wouldGet.Round()} Eur");
if (wouldGet >= _session.WantedPrice)
{
exit = true;
}
if (count >= 10)
{
break;
}
count++;
}
BinancePlacedOrder sellPlaced = Client.Spot.Order
.PlaceOrder(_session.Pair, OrderSide.Sell, OrderType.Market, buy.QuantityFilled)
.GetResult();
decimal sellFee = GetFee(buyPlaced);
BinanceOrder sell = WaitOrder(sellPlaced);
decimal finalSell = sell.QuoteQuantityFilled - sellFee;
string logSell = $" Vendido: {sell.QuoteQuantityFilled.Round()} - {sellFee.Round()} = {finalSell.Round()} Eur";
_session.Logs.Add(logSell);
decimal balance = finalSell - buy.QuoteQuantity;
_session.UpdateBalance(balance);
}
private static BinanceOrder WaitOrder(BinancePlacedOrder placedOrder)
{
BinanceOrder order = Client.Spot.Order.GetOrder(_session.Pair, placedOrder.OrderId, placedOrder.ClientOrderId).GetResult();
while (order.Status != OrderStatus.Filled)
{
Thread.Sleep(1000);
order = Client.Spot.Order.GetOrder(_session.Pair, placedOrder.OrderId, placedOrder.ClientOrderId).GetResult();
}
return(order);
}
private static decimal GetFee(BinancePlacedOrder placed)
{
if (placed.Fills == null)
{
throw new Exception("No hay fills! (Ver Account Trade List)");
}
decimal feePrice = Client.Spot.Market.GetPrice("BNBEUR").GetResult().Price;
decimal fee = placed.Fills.Sum(f => f.Commission) * feePrice;
return(fee);
}
public void PlaceOrders(decimal quantity, decimal currrentClose, StrategyOutput strategyOutput, StrategyData strategyData)
{
BinancePlacedOrder placedOrder = null;
if (strategyOutput == StrategyOutput.OpenPositionWithBuy || strategyOutput == StrategyOutput.ExitPositionWithBuy ||
strategyOutput == StrategyOutput.BookProfitWithBuy || strategyOutput == StrategyOutput.MissedPositionBuy ||
strategyOutput == StrategyOutput.ExitPositionHeavyLossWithBuy)
{
placedOrder = webCall.PlaceBuyOrder(quantity, -1, true);
}
else if (strategyOutput == StrategyOutput.OpenPositionWithSell || strategyOutput == StrategyOutput.ExitPositionWithSell ||
strategyOutput == StrategyOutput.BookProfitWithSell || strategyOutput == StrategyOutput.MissedPositionSell ||
strategyOutput == StrategyOutput.ExitPositionHeavyLossWithSell)
{
placedOrder = webCall.PlaceSellOrder(quantity, -1, true);
}
else if (strategyOutput == StrategyOutput.EscapeTrapWithBuy)
{
if (BinanceBotSettings.settings.ReOpenOnEscape)
{
placedOrder = webCall.PlaceBuyOrder(quantity * 2, -1, true);
}
else
{
placedOrder = webCall.PlaceBuyOrder(quantity, -1, true);
}
}
else if (strategyOutput == StrategyOutput.EscapeTrapWithSell)
{
if (BinanceBotSettings.settings.ReOpenOnEscape)
{
placedOrder = webCall.PlaceSellOrder(quantity * 2, -1, true);
}
else
{
placedOrder = webCall.PlaceSellOrder(quantity, -1, true);
}
}
else
{
//no action
}
if (placedOrder != null)
{
DumpToLog(currrentClose, strategyOutput.ToString(), strategyData);
}
}
public void PlaceOrder_Should_RespondWithPlacedOrder()
{
// arrange
var placed = new BinancePlacedOrder()
{
ClientOrderId = "test",
OrderId = 100000000000,
Symbol = "BNBBTC",
TransactTime = new DateTime(2017, 1, 1)
};
var client = PrepareClient(JsonConvert.SerializeObject(placed));
// act
var result = client.PlaceOrder("BNBBTC", OrderSide.Buy, OrderType.Limit, TimeInForce.GoodTillCancel, 1, 2);
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(placed, result.Data));
}
public void PlaceOrder_Should_RespondWithPlacedOrder()
{
// arrange
var placed = new BinancePlacedOrder()
{
ClientOrderId = "test",
OrderId = 100000000000,
Symbol = "BNBBTC",
TransactTime = new DateTime(2017, 1, 1)
};
var objects = TestHelpers.PrepareClient(() => Construct(new BinanceClientOptions()
{
ApiCredentials = new ApiCredentials("Test", "Test")
}), JsonConvert.SerializeObject(placed));
// act
var result = objects.Client.PlaceOrder("BNBBTC", OrderSide.Buy, OrderType.Limit, timeInForce: TimeInForce.GoodTillCancel, quantity: 1, price: 2);
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(placed, result.Data));
}
public static ExchangeOrder ToOrder(this BinancePlacedOrder externalOrder)
{
if (externalOrder == null)
{
return(null);
}
ExchangeOrder order = new ExchangeOrder();
order.Symbol = externalOrder.Symbol;
order.Status = externalOrder.Status.ToStatus();
order.OriginalQuantity = externalOrder.OriginalQuantity;
order.OrderId = long.Parse(externalOrder.ClientOrderId);
order.ExchangeOrderId = externalOrder.OrderId.ToString();
order.OrderSideCode = externalOrder.Side.ToCode();
order.OrderTypeCode = externalOrder.Type.ToCode();
order.FillPoliticsCode = externalOrder.TimeInForce.ToCode();
order.ExecutedQuantity = externalOrder.ExecutedQuantity;
order.Price = externalOrder.Price;
order.TransactTime = externalOrder.TransactTime;
return(order);
}
public void PlaceMarginOrder_Should_RespondWithMarginPlacedOrder()
{
// arrange
var placed = new BinancePlacedOrder()
{
ClientOrderId = "test",
OrderId = 100000000000,
Symbol = "BNBBTC",
TransactTime = new DateTime(2017, 1, 1)
};
var client = TestHelpers.CreateResponseClient(placed, new BinanceClientOptions()
{
ApiCredentials = new ApiCredentials("Test", "Test"),
AutoTimestamp = false
});
// act
var result = client.PlaceMarginOrder("BTCUSDT", OrderSide.Buy, OrderType.Limit, timeInForce: TimeInForce.GoodTillCancel, quantity: 1, price: 2);
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(TestHelpers.AreEqual(placed, result.Data));
}
private BinancePlacedOrder CloneBinancePlaceOrder(BinancePlacedOrder binancePlaced)
{
var clone = new BinancePlacedOrder()
{
ExecutedQuantity = binancePlaced.ExecutedQuantity,
Price = binancePlaced.Price,
Status = binancePlaced.Status,
OriginalQuantity = binancePlaced.OriginalQuantity,
TransactTime = binancePlaced.TransactTime,
OrderId = binancePlaced.OrderId,
ClientOrderId = binancePlaced.ClientOrderId,
CummulativeQuoteQuantity = binancePlaced.CummulativeQuoteQuantity,
Fills = binancePlaced.Fills,
OrderListId = binancePlaced.OrderListId,
OriginalClientOrderId = binancePlaced.OriginalClientOrderId,
Side = binancePlaced.Side,
StopPrice = binancePlaced.StopPrice,
Symbol = binancePlaced.Symbol,
TimeInForce = binancePlaced.TimeInForce,
Type = binancePlaced.Type
};
return(clone);
}
