private decimal GetPriceToPlace(string pair, OrderSide side, BinanceOrderBook orderBook, decimal alfa,
int tickUp)
{
var symbol = symbols.Single(x => x.Name == pair);
var orderbookSide = side == OrderSide.Buy ? orderBook.Bids.ToList() : orderBook.Asks.ToList();
decimal sum = 0;
var i = 0;
while (sum < alfa)
{
sum += (orderbookSide[i].Quantity);
i++;
}
i = i == 0 ? 0 : i - 1;
var price = orderbookSide[i].Price;
var ticksize = symbol.PriceFilter.TickSize;
var tickToIncrease = ticksize * tickUp;
decimal priceToPlace;
if (side == OrderSide.Buy)
{
priceToPlace = price + tickToIncrease;
}
else
{
priceToPlace = price - tickToIncrease;
}
var round = Math.Round(priceToPlace, symbol.BaseAssetPrecision);
return(round);
}
private int GetAvailableTick(string pair, decimal price, BinanceOrderBook orderbook, OrderSide side)
{
var orderbookSide = side == OrderSide.Buy ? orderbook.Asks.ToList() : orderbook.Bids.ToList();
var symbol = symbols.Single(x => x.Name == pair);
var availableTick = int.Parse((Math.Abs(orderbookSide[0].Price - price) / symbol.PriceFilter.TickSize).ToString("F0"));
return(availableTick);
}
public ExchangePricesEventArgs(BinanceOrderBook orderBook) : this()
{
var pair = orderBook.Stream.Split('@')[0];
var symbol = OrderBookEventArgs.ParseSymbol(pair);
Instrument1 = symbol[0];
Instrument2 = symbol[1];
Exchange = ExchangeName.Binance;
OrderBook = new OrderBookEventArgs(orderBook).OrderBook;
}
private void HandleUpdate(BinanceOrderBook data)
{
if (Levels == null)
{
UpdateOrderBook(data.LastUpdateId, data.Bids, data.Asks);
}
else
{
SetInitialOrderBook(data.LastUpdateId, data.Bids, data.Asks);
}
}
private void HandleUpdate(BinanceOrderBook data)
{
if (limit == null)
{
UpdateOrderBook(data.FirstUpdateId ?? 0, data.LastUpdateId, data.Bids, data.Asks);
}
else
{
SetInitialOrderBook(data.LastUpdateId, data.Asks, data.Bids);
}
}
public void OnSymbolBuyOrderBookReceived(BinanceOrderBook data, Trades pair)
{
try {
if (data != null)
{
//var isAlreadySubscribed = binanceHelper.GetSubscriptionByKey(pair.Symbol) != null;
//if (!isAlreadySubscribed) { //buy cycle..
var bestAsked = data.Asks.Where(d => d.Price <= pair.BuyPrice).ToList();
if (bestAsked.Count() > 0)
{
Application.Current.Dispatcher.Invoke(() => {
decimal buyPrice = bestAsked.First().Price;
decimal buyQuantity = binanceHelper.GetFilteredBuyQuantity(client, pair.Symbol, buyPrice);
SafelyWriteToTradeLog("BUY: " + pair.Symbol + " Qty: " + buyQuantity + " at price: " + buyPrice);
if (buyPrice > 0 && buyQuantity > 0)
{
var buyResult = client.PlaceOrder(pair.Symbol, OrderSide.Buy, OrderType.Limit, buyQuantity, price: buyPrice, timeInForce: TimeInForce.GoodTillCancel);
if (buyResult.Success)
{
SafelyWriteToTradeLog($"{ buyResult.Data.Side } ::> Pair: { buyResult.Data.Symbol }, Price: { buyResult.Data.Price}, Quantity: { buyResult.Data.OriginalQuantity }, Status: {buyResult.Data.Fills}");
_logger.LogInfoMessage(JsonConvert.SerializeObject(buyResult.Data));
//Unsubscribe from pair's stream and save to database..
binanceHelper.UnsubscribeFromStream(pair.Symbol, socketClient);
SaveBuyTradeData(pair.Symbol, buyQuantity, buyPrice);
//Immediately process sell after buy..
ProcessSell(client, socketClient, tokenSource.Token);
}
else if (buyResult.Error != null)
{
binanceHelper.UnsubscribeFromStream(pair.Symbol, socketClient);
_logger.LogError(buyResult.Error.Message);
}
////Unsubscribe from pair's stream and save to database..
//binanceHelper.UnsubscribeFromStream(pair.Symbol, socketClient);
//SaveBuyTradeData(pair.Symbol, buyQuantity, buyPrice);
//Immediately process sell after buy..
//ProcessSell(client, socketClient, tokenSource.Token);
}
else
{
binanceHelper.UnsubscribeFromStream(pair.Symbol, socketClient);
}
});
}
//}
}
} catch (Exception ex) {
_logger.LogException(ex);
}
}
private bool CheckBetaTick(string pair, BinanceOrderBook orderbook, decimal price, decimal beta, OrderSide side)
{
var availableTick = GetAvailableTick(pair, price, orderbook, side);
if (availableTick >= beta)
{
return(true);
}
else
{
return(false);
}
}
private void insertRow(BinanceOrderBook data)
{
if (lastRecord == null)
{
lastRecord = data;
return;
}
DateTime currTime = data.EventTime.Value.ToUniversalTime();
DateTime prevTime = lastRecord.EventTime.Value.ToUniversalTime();
DateTime currSecond = truncateToSecond(currTime);
DateTime prevSecond = truncateToSecond(prevTime);
if (lastRecord.EventTime.Value > data.EventTime.Value)
{
return;
}
else if (prevSecond == currSecond)
{
lastRecord = data;
return;
}
else if (prevTime.Day == currTime.Day)
{
for (DateTime s = prevSecond; s < currSecond; s = addOneSecond(s))
{
try
{
insertToBigQuery(s, lastRecord);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
Console.WriteLine("Prev Day: " + prevTime + ", Curr Day: " + currTime);
lastRecord = data;
return;
}
else
{
setupTable(currTime);
for (DateTime s = prevSecond; s < currSecond; s = addOneSecond(s))
{
insertToBigQuery(s, lastRecord);
}
lastRecord = data;
return;
}
}
private void HandleUpdate(BinanceOrderBook data)
{
if (limit == null)
{
var updates = new List <ProcessEntry>();
updates.AddRange(data.Asks.Select(a => new ProcessEntry(OrderBookEntryType.Ask, a)));
updates.AddRange(data.Bids.Select(b => new ProcessEntry(OrderBookEntryType.Bid, b)));
UpdateOrderBook(data.FirstUpdateId ?? data.LastUpdateId, data.LastUpdateId, updates);
}
else
{
initialUpdateReceived = true;
SetInitialOrderBook(data.LastUpdateId, data.Asks, data.Bids);
}
}
public void SubscribingToPartialBookDepthStream_Should_TriggerWhenPartialBookStreamMessageIsReceived()
{
// arrange
var socket = new Mock <IWebsocket>();
socket.Setup(s => s.Close());
socket.Setup(s => s.Connect()).Returns(Task.FromResult(true));
socket.Setup(s => s.SetEnabledSslProtocols(It.IsAny <System.Security.Authentication.SslProtocols>()));
var factory = new Mock <IWebsocketFactory>();
factory.Setup(s => s.CreateWebsocket(It.IsAny <string>())).Returns(socket.Object);
BinanceOrderBook result = null;
var client = new BinanceSocketClient {
SocketFactory = factory.Object
};
client.SubscribeToPartialBookDepthStream("test", 10, (test) => result = test);
var data = new BinanceOrderBook()
{
Asks = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.1m,
Quantity = 0.2m
},
new BinanceOrderBookEntry()
{
Price = 0.3m,
Quantity = 0.4m
}
},
LastUpdateId = 1,
Bids = new List <BinanceOrderBookEntry>()
};
// act
socket.Raise(r => r.OnMessage += null, JsonConvert.SerializeObject(data));
// assert
Assert.IsNotNull(result);
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data, result, "Asks", "Bids"));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data.Asks[0], result.Asks[0]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data.Asks[1], result.Asks[1]));
}
public void GetOrderBook_Should_RespondWithOrderBook()
{
// arrange
var orderBook = new BinanceOrderBook()
{
LastUpdateId = 123,
Asks = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.1m,
Quantity = 1.1m
},
new BinanceOrderBookEntry()
{
Price = 0.2m,
Quantity = 2.2m
}
},
Bids = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.3m,
Quantity = 3.3m
},
new BinanceOrderBookEntry()
{
Price = 0.4m,
Quantity = 4.4m
}
}
};
var objects = TestHelpers.PrepareClient(() => Construct(), "{\"lastUpdateId\":123,\"asks\": [[0.1, 1.1], [0.2, 2.2]], \"bids\": [[0.3,3.3], [0.4,4.4]]}");
// act
var result = objects.Client.GetOrderBook("BNBBTC");
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(orderBook, result.Data, "Asks", "Bids"));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(orderBook.Asks[0], result.Data.Asks[0]));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(orderBook.Asks[1], result.Data.Asks[1]));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(orderBook.Bids[0], result.Data.Bids[0]));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(orderBook.Bids[1], result.Data.Bids[1]));
}
public void GetOrderBook_Should_RespondWithOrderBook()
{
// arrange
var orderBook = new BinanceOrderBook()
{
LastUpdateId = 123,
Asks = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.1,
Quantity = 1.1
},
new BinanceOrderBookEntry()
{
Price = 0.2,
Quantity = 2.2
}
},
Bids = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.3,
Quantity = 3.3
},
new BinanceOrderBookEntry()
{
Price = 0.4,
Quantity = 4.4
}
}
};
var client = PrepareClient(JsonConvert.SerializeObject(orderBook));
// act
var result = client.GetOrderBook("BNBBTC");
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(orderBook, result.Data, "Asks", "Bids"));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(orderBook.Asks[0], result.Data.Asks[0]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(orderBook.Asks[1], result.Data.Asks[1]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(orderBook.Bids[0], result.Data.Bids[0]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(orderBook.Bids[1], result.Data.Bids[1]));
}
public void GetOrderBook_Should_RespondWithOrderBook()
{
// arrange
var orderBook = new BinanceOrderBook()
{
LastUpdateId = 123,
Symbol = "BNBBTC",
Asks = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.1m,
Quantity = 1.1m
},
new BinanceOrderBookEntry()
{
Price = 0.2m,
Quantity = 2.2m
}
},
Bids = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 0.3m,
Quantity = 3.3m
},
new BinanceOrderBookEntry()
{
Price = 0.4m,
Quantity = 4.4m
}
}
};
var client = TestHelpers.CreateResponseClient("{\"lastUpdateId\":123,\"asks\": [[0.1, 1.1], [0.2, 2.2]], \"bids\": [[0.3,3.3], [0.4,4.4]]}");
// act
var result = client.GetOrderBook("BNBBTC");
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(TestHelpers.AreEqual(orderBook, result.Data, "Asks", "Bids", "AsksStream", "BidsStream", "LastUpdateIdStream"));
Assert.IsTrue(TestHelpers.AreEqual(orderBook.Asks.ToList()[0], result.Data.Asks.ToList()[0]));
Assert.IsTrue(TestHelpers.AreEqual(orderBook.Asks.ToList()[1], result.Data.Asks.ToList()[1]));
Assert.IsTrue(TestHelpers.AreEqual(orderBook.Bids.ToList()[0], result.Data.Bids.ToList()[0]));
Assert.IsTrue(TestHelpers.AreEqual(orderBook.Bids.ToList()[1], result.Data.Bids.ToList()[1]));
}
/// <summary>
/// Build <see cref="MarketDepth"/>
/// </summary>
/// <param name="marketDepth">Market depth</param>
/// <param name="limit">Limit of returned orders count</param>
public async Task BuildAsync(MarketDepth marketDepth, short limit = 10)
{
if (marketDepth == null)
{
throw new ArgumentNullException(nameof(marketDepth));
}
if (limit <= 0)
{
throw new ArgumentOutOfRangeException(nameof(limit));
}
WebCallResult <BinanceOrderBook> response = await _restClient.Spot.Market.GetOrderBookAsync(marketDepth.Symbol, limit);
BinanceOrderBook orderBook = response.Data;
marketDepth.UpdateDepth(orderBook.Asks, orderBook.Bids, orderBook.LastUpdateId);
}
public void OnSymbolSellOrderBookReceived(BinanceOrderBook data, Trades pair)
{
try {
if (data != null)
{
var bestBid = data.Bids.Where(d => d.Price >= pair.ExpectedSellPrice).ToList();
SafelyWriteToTradeLog("Symbol: " + pair.Symbol + " Price: " + data.Bids.First().Price);
if (bestBid.Count() > 0)
{
Application.Current.Dispatcher.Invoke(() => {
decimal sellPrice = bestBid.First().Price;
decimal sellQuantity = binanceHelper.GetBaseCurrencyBalance(client, pair.Symbol.Replace(binanceHelper.GetBaseCurrencySymbol(), ""));
sellQuantity = binanceHelper.GetFilteredSellQuantity(client, pair.Symbol, sellQuantity);
SafelyWriteToTradeLog("SELL: " + pair.Symbol + " Qty: " + sellQuantity + " at price: " + sellPrice);
if (sellPrice > 0 && sellQuantity > 0)
{
var sellResult = client.PlaceOrder(pair.Symbol, OrderSide.Sell, OrderType.Limit, sellQuantity, price: sellPrice, timeInForce: TimeInForce.GoodTillCancel);
if (sellResult.Success)
{
SafelyWriteToTradeLog($"{ sellResult.Data.Side } ::> Pair: { sellResult.Data.Symbol }, Price: { sellResult.Data.Price}, Quantity: { sellResult.Data.OriginalQuantity }, Status: {sellResult.Data.Fills}");
_logger.LogInfoMessage(JsonConvert.SerializeObject(sellResult.Data));
//Unsubscribe from pair's stream and update to database..
binanceHelper.UnsubscribeFromStream(pair.Symbol, socketClient);
SaveSellTradeData(pair, sellPrice);
}
else if (sellResult.Error != null)
{
_logger.LogError(sellResult.Error.Message);
}
}
////Unsubscribe from pair's stream and update to database..
//binanceHelper.UnsubscribeFromStream(pair.Symbol, socketClient);
//SaveSellTradeData(pair, sellPrice);
});
}
////process buy again..
//ProcessBuy(client, socketClient, tokenSource.Token);
}
} catch (Exception ex) {
_logger.LogException(ex);
}
}
public TradeEventArgs(BinanceOrderBook orderBook) : this()
{
var data = orderBook.Data;
var pair = orderBook.Stream.Split('@')[0];
var symbol = OrderBookEventArgs.ParseSymbol(pair);
Quantity = data.Amount;
Price = data.Price;
Instrument1 = symbol[0];
Instrument2 = symbol[1];
BuyerOrderId = data.BuyerOrderId;
SellerOrderId = data.SellerOrderId;
CreatedAt = StartTime.AddMilliseconds(data.EventTime);
Timestamp = StartTime.AddMilliseconds(data.TradeTime);
Exchange = ExchangeName.Binance;
TradeId = data.TradeId;
IsBuyerMarketMaker = data.IsBuyerMarketMaker;
}
private void insertToBigQuery(DateTime currSecond, BinanceOrderBook record)
{
string baseCurrency = SYMBOL_MAP[symbol].baseCurrency;
string targetCurrency = SYMBOL_MAP[symbol].targetCurrency;
BigQueryInsertRow row = new BigQueryInsertRow(insertId: currSecond.ToString())
{
{ "t", addOneSecond(currSecond) },
{ "bid", BigQueryNumeric.Parse(record.Bids.ToArray()[0].Price.ToString()) },
{ "ask", BigQueryNumeric.Parse(record.Asks.ToArray()[0].Price.ToString()) },
{ "base", baseCurrency },
{ "target", targetCurrency },
{ "s", symbol },
{ "localTime", DateTime.UtcNow }
};
bqClient.InsertRow("firebase-lispace", "binance_orderbooks", getTableName(addOneSecond(currSecond)), row);
}
public decimal getLowestAskAmount(string pair, decimal price)
{
try
{
decimal[] arrayValue = new decimal[2];
arrayValue[0] = arrayValue[1] = 0;
decimal priceBook = 0;
decimal priceAux = 0;
int lines = 0;
decimal total = 0;
BinanceOrderBook book = null;
foreach (var item in Program.array)
{
if ((item as Program.ClassDetailOrder).symbol == pair.ToLower())
{
book = (item as Program.ClassDetailOrder).book; break;
}
}
foreach (var item in book.Asks)
{
lines++;
priceBook += item.Price;
if ((item.Quantity * item.Price) >= price)
{
return(price / item.Price);
}
}
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message + ex.StackTrace);
}
throw new Exception("Erro askamount");
}
private BinanceOrderBook RemoveMyOrderFromOrderbook(decimal price, decimal quantity, OrderSide orderSide,
BinanceOrderBook orderbook)
{
var orderbookSide = orderSide == OrderSide.Sell ? orderbook.Asks.ToList() : orderbook.Bids.ToList();
var indexOfMyOrder = orderbookSide.FindIndex(x => x.Price == price);
if (indexOfMyOrder == -1)
{
Console.WriteLine("My order not found in orderbook");
return(orderbook);
}
var amountDifference = orderbookSide[indexOfMyOrder].Quantity - quantity;
if (amountDifference == 0)
{
orderbookSide.Splice(indexOfMyOrder, 1);
}
else if (amountDifference > 0)
{
orderbookSide[indexOfMyOrder].Quantity = amountDifference;
}
else
{
Console.WriteLine("amount less than my order????");
}
if (orderSide == OrderSide.Sell)
{
orderbook.Asks = orderbookSide;
}
else
{
orderbook.Bids = orderbookSide;
}
return(orderbook);
}
private void TT6(BinanceOrderBook obj)
{
var BestAsk = (List <BinanceOrderBookEntry>)obj.Asks;
var BestBid = (List <BinanceOrderBookEntry>)obj.Bids;
BookEntry Entry = new BookEntry(BestAsk[0].Price, BestBid[0].Price, obj.LastUpdateId);
Logger.Info(string.Format("Spread : {0}", Entry.PriceSpread));
Logger.Info(string.Format("MediumPrice : {0}", Entry.MediumPrice));
Logger.Info(string.Format("Ask : {0}", Entry.Ask));
Logger.Info(string.Format("Bid : {0}", Entry.Bid));
if (Entry.PriceSpread > 1)
{
this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Sell);
this.PlaceOrder("BTCUSDT", Binance.Net.Objects.OrderSide.Buy, Binance.Net.Objects.OrderType.Limit, decimal.Round(.0022m, 4), decimal.Round(Entry.Bid, 2));
}
if (Entry.NegativeSpread < -1)
{
this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Buy);
this.PlaceOrder("BTCUSDT", Binance.Net.Objects.OrderSide.Sell, Binance.Net.Objects.OrderType.Limit, decimal.Round(.0022m, 4), decimal.Round(Entry.Ask, 2));
}
}
public BinanceInstrumentsEventArgs(BinanceOrderBook orders)
{
OrderBook = orders;
}
public async Task <DataTable> GetVolumes()
{
await SetupCoinData();
using (var client = new BinanceClient())
{
while (true)
{
foreach (DataRow pricer in CoinData.Rows)
{
IEnumerable <BinanceKline> eighthourcandles = client.GetKlines(pricer[0].ToString(), KlineInterval.FiveMinutes, startTime: DateTime.UtcNow.AddHours(-8), endTime: DateTime.UtcNow, limit: 100).Data.ToList();
IOrderedEnumerable <BinanceKline> candlearray = eighthourcandles.OrderByDescending(e => e.CloseTime);
decimal averagevolumeeighthours = candlearray.Average(candlestick => candlestick.Volume);
decimal fifteenminavg = (candlearray.ElementAt(1).Volume + candlearray.ElementAt(2).Volume +
candlearray.ElementAt(0).Volume) / 3;
BinanceOrderBook orderBook = client.GetOrderBook(pricer[0].ToString(), 10).Data;
IOrderedEnumerable <BinanceOrderBookEntry> orderAsks = orderBook.Asks.OrderByDescending(e => e.Quantity);
IOrderedEnumerable <BinanceOrderBookEntry> orderBids = orderBook.Bids.OrderByDescending(e => e.Quantity);
decimal maxAsk = orderAsks.First().Price;
decimal maxBid = orderBids.First().Price;
IEnumerable <BinanceAggregatedTrades> aggTrades = client.GetAggregatedTrades(pricer[0].ToString(), startTime: DateTime.UtcNow.AddMinutes(-2), endTime: DateTime.UtcNow, limit: 10).Data.ToList();
DataRow row = CoinData.Rows.Cast <DataRow>().First(o => o[0].ToString() == pricer[0].ToString());
row[1] = DateTime.UtcNow;
row[2] = eighthourcandles.Last().Close;
row[3] = Decimal.Round(averagevolumeeighthours, MidpointRounding.AwayFromZero);
row[4] = PercentGive(candlearray.First().Volume, averagevolumeeighthours);
row[5] = PercentGive(fifteenminavg, averagevolumeeighthours);
int i = 0;
while (i != 20)
{
if (candlearray.ElementAt(i).Close < candlearray.ElementAt(i + 1).Close)
{
break;
}
i++;
}
row[6] = i;
//if (enableTrading)
{
IEnumerable <Candle> candls = candlearray.Select(p => new Candle(p.CloseTime, p.Open, p.High, p.Low, p.Close, p.Volume));
Trady.Analysis.Indicator.AverageDirectionalIndexRating avgDirIdx = new Trady.Analysis.Indicator.AverageDirectionalIndexRating(candls, 12, 12);
Trady.Analysis.Indicator.ModifiedMovingAverage mavgFast = new Trady.Analysis.Indicator.ModifiedMovingAverage(candls, 9);
Trady.Analysis.Indicator.ModifiedMovingAverage mavgSlow = new Trady.Analysis.Indicator.ModifiedMovingAverage(candls, 50);
Trady.Analysis.Indicator.IchimokuCloud ich = new Trady.Analysis.Indicator.IchimokuCloud(candls, 3, 9, 50);
/*if (ich.ShortPeriodCount > ich.MiddlePeriodCount)
* {
* Binance.Account.Orders.LimitOrder lmtOrder = new Binance.Account.Orders.LimitOrder(iuser);
* lmtOrder.Symbol = pricer[0].ToString();
* lmtOrder.Id = "1230";
* lmtOrder.Price = candlearray.First().Close;
* lmtOrder.Quantity = 100000;
* lmtOrder.IcebergQuantity = 12;
* api.PlaceAsync(lmtOrder, 0, CancellationToken.None);
* }*/
}
sql = "INSERT INTO ORDERS (Symbol, Scanned, Price, Volume, TakerBuyBaseAssetVolume, TakerBuyQuoteAssetVolume, NumberOfTrades, Hr8Av, NowPercent, Min15Percent, GreenCandles) VALUES ('" + pricer[0].ToString() + "','" + row[1].ToString() + "', '" + row[2].ToString() + "', '" + candlearray.First().Volume.ToString() + "', '" + candlearray.First().TakerBuyBaseAssetVolume.ToString() + "', '" + candlearray.First().TakerBuyQuoteAssetVolume.ToString() + "', '" + candlearray.First().Trades.ToString() + "', '" + row[3].ToString() + "', '" + row[4].ToString() + "', '" + row[5].ToString() + "', '" + row[6].ToString() + "');";
SQLiteCommand command = new SQLiteCommand(sql, _conn);
command.ExecuteNonQuery();
if (chkShowNowPercent.Checked)
{
CoinData.DefaultView.RowFilter = "NowPercent > 0";
}
//var filtered = CoinData.Select().Where(o => Convert.ToDecimal(o[3].ToString()) > Convert.ToDecimal(o[4].ToString()));
if (this.WindowState != FormWindowState.Minimized)
{
DataViewColours();
coindatagridview.DataSource = CoinData;
//coindatagridview.Sort(coindatagridview.Columns[3], ListSortDirection.Descending);
}
}
}
}
return(CoinData);
}
public decimal getBook(string pair, decimal amount, string type, string operation, bool division = true)
{
try
{
BinanceOrderBook book = null;
foreach (var item in Program.array)
{
if ((item as Program.ClassDetailOrder).symbol == pair.ToLower())
{
book = (item as Program.ClassDetailOrder).book; break;
}
}
List <BinanceOrderBookEntry> lst = null;
if (type == "asks")
{
lst = book.Asks;
}
if (type == "bids")
{
lst = book.Bids;
}
decimal[] arrayValue = new decimal[2];
arrayValue[0] = arrayValue[1] = 0;
decimal orderPrice = 0;
decimal orderAmount = 0;
decimal totalCost = 0;
decimal totalAmount = 0;
decimal remaining = amount;
decimal cost = 0;
foreach (var item in lst)
{
orderPrice = item.Price;
orderAmount = item.Quantity;
cost = orderPrice * orderAmount;
if (cost < remaining)
{
remaining -= cost;
totalCost += cost;
totalAmount += orderAmount;
}
else
{
//finished
remaining -= amount;
totalCost += amount * orderPrice;
totalAmount += amount;
if (division)
{
arrayValue[0] = Math.Round(amount / (totalCost / totalAmount), 8);
arrayValue[1] = Math.Round(amount / orderPrice, 8);
}
else
{
arrayValue[0] = Math.Round((totalCost / totalAmount) * amount, 8);
arrayValue[1] = Math.Round(orderPrice * amount, 8);
}
return(arrayValue[0]);
}
}
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message + ex.StackTrace);
//System.Threading.Thread.Sleep(1000);
}
//System.Threading.Thread.Sleep(1000);
throw new Exception("Error Asks");
}
/// <summary>
/// Receive Orderbook Update coming for the subscription
/// </summary>
/// <param name="OrderbookLevel"></param>
private void OrderBookHandler(BinanceOrderBook OrderbookLevel)
{
try
{
var BestAsk = (List <BinanceOrderBookEntry>)OrderbookLevel.Asks;
var BestBid = (List <BinanceOrderBookEntry>)OrderbookLevel.Bids;
var Capture = BestAsk.ConvertToBook(BestBid);
Capture.Compute();
BookSnapshot.AddBook(Capture);
var RounderAsk = BestAsk.Select(y => Math.Round(y.Price, 0)).ToList().ToList();
var RounderAskVol = BestAsk.Select(y => Math.Round(y.Quantity, 5)).ToList().ToList();
var RounderBid = BestBid.Select(y => Math.Round(y.Price, 0)).ToList().ToList();
var RounderBidVol = BestBid.Select(y => Math.Round(y.Quantity, 5)).ToList().ToList();
for (int i = 0; i < RounderAsk.Count; i++)
{
Map.AddPrice(new PriceLayer(RounderAsk[i], RounderAskVol[i], PriceDirection.Ask));
}
for (int i = 0; i < RounderBid.Count; i++)
{
Map.AddPrice(new PriceLayer(RounderBid[i], RounderBidVol[i], PriceDirection.Bid));
}
//Logger.Info(string.Format("Price : {0}", Map.Map.Last().Price));
//Logger.Info(string.Format("Ask Quantity Price : {0}", Map.Update.Where(y => y.TheChoice == PriceDirection.Ask).Last().PriceLayerRef));
//Logger.Info(string.Format("Ask Quantity Before : {0}", Map.Update.Where(y => y.TheChoice == PriceDirection.Ask).Last().QuantityBefore));
//Logger.Info(string.Format("Ask Quantity After : {0}", Map.Update.Where(y => y.TheChoice == PriceDirection.Ask).Last().QuantityAfter));
//Logger.Info(string.Format("Bid Quantity Price : {0}", Map.Update.Where(y => y.TheChoice == PriceDirection.Bid).Last().PriceLayerRef));
//Logger.Info(string.Format("Bid Quantity Before : {0}", Map.Update.Where(y => y.TheChoice == PriceDirection.Bid).Last().QuantityBefore));
//Logger.Info(string.Format("Bid Quantity After : {0}", Map.Update.Where(y => y.TheChoice == PriceDirection.Bid).Last().QuantityAfter));
//Logger.Info(string.Format("RounderAskVol : {0}", RounderAskVol.First()));
//Logger.Info(string.Format("RounderBidVol : {0}", RounderBidVol.First()));
//Extract Average volume Per Price;
//BookEntry Entry = new BookEntry(BestAsk[0].Price, BestBid[0].Price, obj.LastUpdateId);
//Logger.Info(string.Format("Spread : {0}", Entry.PriceSpread));
//Logger.Info(string.Format("MediumPrice : {0}", Entry.MediumPrice));
//Logger.Info(string.Format("Ask : {0}", Entry.Ask));
//Logger.Info(string.Format("CumuluatedBuyerOnHotRange : {0}", CumuluatedBuyerOnHotRange));
//Logger.Info(string.Format("BestLiquidAsk : {0}", BestLiquidAsk));
//Logger.Info(string.Format("Bid : {0}", Entry.Bid));
//Logger.Info(string.Format("CumuluatedSellerOnHotRange : {0}", CumuluatedSellerOnHotRange));
//Logger.Info(string.Format("BestLiquidBid : {0}", BestLiquidBid));
}
catch (Exception ex)
{
MamaBot.GlobalShared.Vars.Logger.LogError("Exception occured in the OrderBookHandler : " + ex.Message);
}
//if (WANTTOBUY)
//{
// Task.Run(() =>
// {
// this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Buy);
// //this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Sell);
// this.PlaceOrder("BTCUSDT", Binance.Net.Objects.OrderSide.Buy, Binance.Net.Objects.OrderType.Limit, decimal.Round(.0022m, 4), decimal.Round(Entry.Bid, 3));
// //this.PlaceOrder("BTCUSDT", Binance.Net.Objects.OrderSide.Sell, Binance.Net.Objects.OrderType.Limit, decimal.Round(.0022m, 4), decimal.Round(Entry.Ask, 2));
// });
//}
}
private Task Process(Order order)
{
return(Task.Run(async() =>
{
try
{
order.Processing = true;
var orderBookRequest = (await binanceClient.GetOrderBookAsync(order.Pair, 50));
if (!orderBookRequest.Success)
{
order.Status = Status.Error;
order.ErrorMessage = orderBookRequest.Error.Message;
return;
}
BinanceOrderBook orderbook = orderBookRequest.Data;
order.Bid = orderbook.Bids.First().Price;
order.Ask = orderbook.Asks.First().Price;
if (order.Status == Status.WaitBuy)
{
var priceToPlace = GetPriceToPlace(order.Pair,
OrderSide.Buy,
orderbook,
order.BAlfa,
order.TickUp);
var checkBetaTick = CheckBetaTick(order.Pair, orderbook, priceToPlace, order.BBeta,
OrderSide.Buy);
if (checkBetaTick)
{
order.BuyOrder = await PlaceOrder(order.Pair, order.Amount, OrderSide.Buy, priceToPlace);
order.Status = Status.Buy;
order.BuyPrice = priceToPlace;
}
}
else if (order.Status == Status.WaitSell)
{
var priceToPlace = GetPriceToPlace(order.Pair,
OrderSide.Sell,
orderbook,
order.SAlfa,
order.TickUp);
var checkBetaTick = CheckBetaTick(order.Pair, orderbook, priceToPlace, order.SBeta,
OrderSide.Sell);
if (checkBetaTick)
{
order.SellOrder = await PlaceOrder(order.Pair, order.Amount, OrderSide.Sell, priceToPlace);
order.Status = Status.Sell;
order.SellPrice = priceToPlace;
}
}
else if (order.Status == Status.Buy)
{
var statusOrderRequest = await binanceClient.GetOrderAsync(order.Pair, order.BuyOrder.OrderId);
if (!statusOrderRequest.Success)
{
if (statusOrderRequest.Error.Code == -2013)
{
return;
}
order.Status = Status.Error;
order.ErrorMessage = statusOrderRequest.Error.Message;
}
var statusOrder = statusOrderRequest.Data;
if (statusOrder.Status == OrderStatus.Filled)
{
order.BuyOrderCompletedDatetime = DateTime.Now;
var priceToPlace = GetPriceToPlace(order.Pair, OrderSide.Sell, orderbook, order.SAlfa,
order.TickUp);
var checkBeta = CheckBetaTick(order.Pair, orderbook, priceToPlace, order.SBeta,
OrderSide.Sell);
if (checkBeta)
{
order.SellOrder = await PlaceOrder(order.Pair, order.BuyOrder.OriginalQuantity,
OrderSide.Sell, priceToPlace);
order.Status = Status.Sell;
order.SellPrice = priceToPlace;
}
else
{
order.Status = Status.WaitSell;
}
}
else if (statusOrder.Status == OrderStatus.New)
{
var orderBookClear = RemoveMyOrderFromOrderbook(order.BuyOrder.Price,
order.BuyOrder.OriginalQuantity, OrderSide.Buy, orderbook);
var priceToPlace = GetPriceToPlace(order.Pair, OrderSide.Buy, orderBookClear, order.BAlfa,
order.TickUp);
var checkBeta = CheckBetaTick(order.Pair, orderBookClear, priceToPlace, order.BBeta,
OrderSide.Buy);
if (checkBeta)
{
if (priceToPlace != order.BuyOrder.Price)
{
BinanceCanceledOrder orderCancelled;
try
{
orderCancelled = await CancelBinanceOrder(order.Pair, order.BuyOrder.OrderId);
}
catch (UnknowOrderException)
{
return;
}
if (orderCancelled.ExecutedQuantity > 0)
{
ManagePartiallyFilledBuy(order, orderCancelled);
}
// Controllare
order.BuyOrder = await PlaceOrder(order.Pair, order.BuyOrder.OriginalQuantity,
OrderSide.Buy, priceToPlace);
order.BuyPrice = priceToPlace;
}
}
else
{
BinanceCanceledOrder orderCancelled;
try
{
orderCancelled = await CancelBinanceOrder(order.Pair, order.BuyOrder.OrderId);
}
catch (UnknowOrderException)
{
return;
}
if (orderCancelled.ExecutedQuantity > 0)
{
ManagePartiallyFilledBuy(order, orderCancelled);
}
order.Status = Status.WaitBuy;
}
}
else if (statusOrder.Status == OrderStatus.Canceled)
{
var priceToPlace = GetPriceToPlace(order.Pair, OrderSide.Buy, orderbook, order.BAlfa,
order.TickUp);
var checkBeta = CheckBetaTick(order.Pair, orderbook, priceToPlace, order.BBeta,
OrderSide.Buy);
if (checkBeta)
{
// Controllare
order.BuyOrder = await PlaceOrder(order.Pair, order.BuyOrder.OriginalQuantity,
OrderSide.Buy, priceToPlace);
order.BuyPrice = priceToPlace;
}
else
{
order.Status = Status.WaitBuy;
}
}
else if (statusOrder.Status == OrderStatus.PartiallyFilled)
{
BinanceCanceledOrder orderCancelled;
try
{
orderCancelled = await CancelBinanceOrder(order.Pair, order.BuyOrder.OrderId);
}
catch (UnknowOrderException)
{
return;
}
ManagePartiallyFilledBuy(order, orderCancelled);
context.Send(x => Orders.Remove(order), null);
}
}
else if (order.Status == Status.Sell)
{
var orderStatusRequest = await binanceClient.GetOrderAsync(order.Pair, order.SellOrder.OrderId);
if (!orderStatusRequest.Success)
{
order.Status = Status.Error;
order.ErrorMessage = orderStatusRequest.Error.Message;
return;
}
BinanceOrder statusOrder = orderStatusRequest.Data;
if (statusOrder.Status == OrderStatus.Filled)
{
order.SellOrderCompletedDatetime = DateTime.Now;
CompleteOrder(order);
}
else if (statusOrder.Status == OrderStatus.New)
{
var orderBookClear = RemoveMyOrderFromOrderbook(order.SellOrder.Price,
order.BuyOrder.OriginalQuantity, OrderSide.Sell, orderbook);
var priceToPlace = GetPriceToPlace(order.Pair,
OrderSide.Sell,
orderBookClear,
order.SAlfa,
order.TickUp);
var checkBetaTick = CheckBetaTick(order.Pair, orderbook, priceToPlace, order.SBeta,
OrderSide.Sell);
if (checkBetaTick)
{
if (priceToPlace != order.SellOrder.Price)
{
BinanceCanceledOrder orderCancelled;
try
{
orderCancelled = await CancelBinanceOrder(order.Pair, order.SellOrder.OrderId);
}
catch (UnknowOrderException)
{
return;
}
if (orderCancelled.ExecutedQuantity > 0)
{
ManagePartiallyFilledSell(order, orderCancelled);
return;
}
order.SellOrder = await PlaceOrder(order.Pair, order.SellOrder.OriginalQuantity,
OrderSide.Sell, priceToPlace);
order.SellPrice = priceToPlace;
}
}
else
{
BinanceCanceledOrder orderCancelled;
try
{
orderCancelled = await CancelBinanceOrder(order.Pair, order.SellOrder.OrderId);
}
catch (UnknowOrderException)
{
return;
}
if (orderCancelled.ExecutedQuantity > 0)
{
ManagePartiallyFilledSell(order, orderCancelled);
return;
}
order.Status = Status.WaitSell;
}
}
else if (statusOrder.Status == OrderStatus.Canceled)
{
var orderBookClear = RemoveMyOrderFromOrderbook(order.SellOrder.Price,
order.BuyOrder.OriginalQuantity, OrderSide.Sell, orderbook);
var priceToPlace = GetPriceToPlace(order.Pair,
OrderSide.Sell,
orderBookClear,
order.SAlfa,
order.TickUp);
var checkBetaTick = CheckBetaTick(order.Pair, orderbook, priceToPlace, order.SBeta,
OrderSide.Sell);
if (checkBetaTick)
{
order.SellOrder = await PlaceOrder(order.Pair, order.SellOrder.OriginalQuantity,
OrderSide.Sell, priceToPlace);
order.SellPrice = priceToPlace;
}
else
{
order.Status = Status.WaitSell;
}
}
else if (statusOrder.Status == OrderStatus.PartiallyFilled)
{
BinanceCanceledOrder orderCancelled;
try
{
orderCancelled = await CancelBinanceOrder(order.Pair, order.SellOrder.OrderId);
}
catch (UnknowOrderException)
{
return;
}
ManagePartiallyFilledSell(order, orderCancelled);
}
}
}
catch (Exception ex)
{
order.Status = Status.Error;
order.ErrorMessage = ex.Message;
}
finally
{
order.Processing = false;
}
}));
}
