// Candlestick
private void CacheCandle(BinanceStreamKlineData stream, int interval)
{
var instrument = stream.Symbol;
var data = stream.Data;
CacheResult(BINANCE_CANDLE, instrument, RtdFields.EVENT, interval, stream.Event);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.EVENT_TIME, interval, stream.EventTime.ToLocalTime());
CacheResult(BINANCE_CANDLE, instrument, RtdFields.FIRST_ID, interval, data.FirstTrade);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.LAST_ID, interval, data.LastTrade);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.HIGH, interval, data.High);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.LOW, interval, data.Low);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.OPEN_TIME, interval, data.OpenTime.ToLocalTime());
CacheResult(BINANCE_CANDLE, instrument, RtdFields.OPEN, interval, data.Open);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.CLOSE_TIME, interval, data.CloseTime.ToLocalTime());
CacheResult(BINANCE_CANDLE, instrument, RtdFields.CLOSE, interval, data.Close);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.FINAL, interval, data.Final);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.INTERVAL, interval, data.Interval.ToString());
CacheResult(BINANCE_CANDLE, instrument, RtdFields.TRADES, interval, data.TradeCount);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.QUOTE_VOL, interval, data.QuoteAssetVolume);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.VOL, interval, data.Volume);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.TAKE_BUY_VOL, interval, data.TakerBuyBaseAssetVolume);
CacheResult(BINANCE_CANDLE, instrument, RtdFields.TAKE_BUY_QUOTE_VOL, interval, data.TakerBuyQuoteAssetVolume);
}
public void SubscribingToKlineStream_Should_TriggerWhenKlineStreamMessageIsReceived()
{
// 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 <Log>(), It.IsAny <string>())).Returns(socket.Object);
BinanceStreamKlineData result = null;
var client = new BinanceSocketClient {
SocketFactory = factory.Object
};
client.SubscribeToKlineStream("test", KlineInterval.OneMinute, (test) => result = test);
var data = new BinanceCombinedStream <BinanceStreamKlineData>()
{
Stream = "test",
Data = new BinanceStreamKlineData()
{
Event = "TestKlineStream",
EventTime = new DateTime(2017, 1, 1),
Symbol = "test",
Data = new BinanceStreamKline()
{
TakerBuyBaseAssetVolume = 0.1m,
Close = 0.2m,
CloseTime = new DateTime(2017, 1, 2),
Final = true,
FirstTrade = 10000000000,
High = 0.3m,
Interval = KlineInterval.OneMinute,
LastTrade = 2000000000000,
Low = 0.4m,
Open = 0.5m,
TakerBuyQuoteAssetVolume = 0.6m,
QuoteAssetVolume = 0.7m,
OpenTime = new DateTime(2017, 1, 1),
Symbol = "test",
TradeCount = 10,
Volume = 0.8m
}
}
};
// act
socket.Raise(r => r.OnMessage += null, JsonConvert.SerializeObject(data));
// assert
Assert.IsNotNull(result);
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data.Data, result, "Data"));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data.Data.Data, result.Data));
}
/// <summary>
/// Converts a binance sourced candle to an internal model.
/// </summary>
/// <param name="candle">The candle to convert.</param>
/// <returns><see cref="BacktestingCandle"/> instance.</returns>
public static BacktestingCandle ToInternal(BinanceStreamKlineData candle)
{
return(new BacktestingCandle(
openTimestamp: candle.Data.OpenTime.ToUnixTimestampMilliseconds(),
open: candle.Data.Open,
close: candle.Data.Close,
high: candle.Data.High,
low: candle.Data.Low,
volume: candle.Data.Volume,
tradingPair: candle.Symbol));
}
private void KL1Min(BinanceStreamKlineData obj)
{
//this.IsAllowedIntoRange = obj.Data.Open > obj.Data.Close;
//CurrentCumulativeDelta = (obj.Data.Volume - obj.Data.TakerBuyQuoteAssetVolume);
//Logger.Info(string.Format("CVD : {0}", CurrentCumulativeDelta));
//Logger.Info(string.Format("VOL : {0}", obj.Data.Volume));
if (obj.Data.Final)
{
CurrentCumulativeDelta = 0;
}
}
/// <summary>
/// Get Data From Date X to Date Y on Symbol V
/// </summary>
/// <param name="From"></param>
/// <param name="To"></param>
/// <param name="Symbol"></param>
public void GetDataFromTo(DateTime From, DateTime To, string Symbol)
{
Console.WriteLine("Core - Loading data for : {0}", Symbol);
if (From > To)
{
throw new Exception(string.Format("From : {0} is superior to To : {1}", From, To));
}
var CandleMin = this.bclient.Client.GetKlines(Symbol, KlineInterval.OneMinute, startTime: From, endTime: To, limit: int.MaxValue);
foreach (var data in CandleMin.Data)
{
BinanceStreamKlineData formated = new BinanceStreamKlineData();
formated.Data = new BinanceStreamKline();
formated.EventTime = data.CloseTime;
formated.Symbol = Symbol;
formated.Data.Close = data.Close;
formated.Data.CloseTime = data.CloseTime;
formated.Data.Final = true;
formated.Data.High = data.High;
formated.Data.Low = data.Low;
formated.Data.OpenTime = data.OpenTime;
formated.Data.Symbol = Symbol;
formated.Data.Open = data.Open;
formated.Data.Volume = data.Volume;
formated.Data.TakerBuyBaseAssetVolume = data.TakerBuyBaseAssetVolume;
formated.Data.TakerBuyQuoteAssetVolume = data.TakerBuyQuoteAssetVolume;
formated.Data.TradeCount = data.TradeCount;
var sourcedata = new Trady.Core.Candle(formated.Data.CloseTime, formated.Data.Open, formated.Data.High, formated.Data.Low, formated.Data.Close, formated.Data.Volume);
BinanceCandle Standardize = new BinanceCandle(sourcedata);
Standardize.Last = formated.Data.Final;
Standardize.Name = formated.Symbol;
Standardize.Candle = sourcedata;
Type myType = formated.Data.GetType();
//Extract all exchanger candle properties
IList <PropertyInfo> props = new List <PropertyInfo>(myType.GetProperties());
foreach (PropertyInfo prop in props)
{
object propValue = prop.GetValue(formated.Data, null);
Standardize.Properties.Add(prop.Name, propValue);
}
Standardize.Update();
this.Candles.Add(Standardize);
}
Console.WriteLine("Core - Finished to load from {0} to {1} for symbol {2}", From, To, Symbol);
}
public void SubscribingToKlineStream_Should_TriggerWhenKlineStreamMessageIsReceived()
{
// arrange
var socket = new TestSocket();
var client = TestHelpers.CreateSocketClient(socket);
BinanceStreamKlineData result = null;
client.Spot.SubscribeToKlineUpdatesAsync("ETHBTC", KlineInterval.OneMinute, (test) => result = test);
var data = new BinanceCombinedStream <BinanceStreamKlineData>()
{
Stream = "test",
Data = new BinanceStreamKlineData()
{
Event = "TestKlineStream",
EventTime = new DateTime(2017, 1, 1),
Symbol = "ETHBTC",
Data = new BinanceStreamKline()
{
TakerBuyBaseAssetVolume = 0.1m,
Close = 0.2m,
CloseTime = new DateTime(2017, 1, 2),
Final = true,
FirstTrade = 10000000000,
High = 0.3m,
Interval = KlineInterval.OneMinute,
LastTrade = 2000000000000,
Low = 0.4m,
Open = 0.5m,
TakerBuyQuoteAssetVolume = 0.6m,
QuoteAssetVolume = 0.7m,
OpenTime = new DateTime(2017, 1, 1),
Symbol = "test",
TradeCount = 10,
Volume = 0.8m
}
}
};
// act
socket.InvokeMessage(data);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(TestHelpers.AreEqual(data.Data, result, "Data"));
Assert.IsTrue(TestHelpers.AreEqual(data.Data.Data, result.Data));
}
private void KL1Min(BinanceStreamKlineData obj)
{
//Periodic reset (Temporary)
if (obj.Data.Final)
{
CurrentCumulativeDelta = 0;
MapHistory.AddMap(Map);
Map.Clear();
Map.Update.Clear();
BookSnapshot.OrderBookSnap.Clear();
SellerMatcher.Clear();
BuyerMatcher.Clear();
OrderFlowAnalyseService.Orders.Clear();
MamaBot.GlobalShared.Vars.OrderChannel.Queue.Clear();
Debug.WriteLine("Cleared all Temporary data");
}
}
private object DecodeCandle(BinanceStreamKlineData stream, string field)
{
var data = stream.Data;
switch (field)
{
case RtdFields.SYMBOL: return(stream.Symbol);
case RtdFields.EVENT: return(stream.Event);
case RtdFields.EVENT_TIME: return(stream.EventTime.ToLocalTime());
case RtdFields.FIRST_ID: return(data.FirstTrade);
case RtdFields.LAST_ID: return(data.LastTrade);
case RtdFields.HIGH: return(data.High);
case RtdFields.LOW: return(data.Low);
case RtdFields.OPEN: return(data.Open);
case RtdFields.CLOSE: return(data.Close);
case RtdFields.OPEN_TIME: return(data.OpenTime.ToLocalTime());
case RtdFields.CLOSE_TIME: return(data.CloseTime.ToLocalTime());
case RtdFields.FINAL: return(data.Final);
case RtdFields.INTERVAL: return(data.Interval.ToString());
case RtdFields.TRADES: return(data.TradeCount);
case RtdFields.QUOTE_VOL: return(data.QuoteAssetVolume);
case RtdFields.VOL: return(data.Volume);
case RtdFields.TAKE_BUY_VOL: return(data.TakerBuyBaseAssetVolume);
case RtdFields.TAKE_BUY_QUOTE_VOL: return(data.TakerBuyQuoteAssetVolume);
}
return(SubscriptionManager.UnsupportedField);
}
/// <summary>
/// Get Data From Date X to Date Y on Symbol V
/// </summary>
/// <param name="From"></param>
/// <param name="To"></param>
/// <param name="Symbol"></param>
public List <BinanceStreamKlineData> GetDataFromTo(DateTime From, DateTime To, string Symbol)
{
Console.WriteLine("Core - Loading data for : {0}", Symbol);
if (From > To)
{
throw new Exception(string.Format("From : {0} is superior to To : {1}", From, To));
}
var DayBetween = (To - From).TotalDays;
var CandleMin = this.bclient.Client.GetKlines(Symbol, KlineInterval.OneMinute, From, To, int.MaxValue);
var GroupPerHour = CandleMin.Data.GroupBy(y => y.CloseTime.Day);
List <BinanceStreamKlineData> returned = new List <BinanceStreamKlineData>();
foreach (var data in CandleMin.Data)
{
BinanceStreamKlineData formated = new BinanceStreamKlineData();
formated.Data = new BinanceStreamKline();
formated.EventTime = data.CloseTime;
formated.Symbol = Symbol;
formated.Data.Close = data.Close;
formated.Data.CloseTime = data.CloseTime;
formated.Data.Final = true;
formated.Data.High = data.High;
formated.Data.Low = data.Low;
formated.Data.OpenTime = data.OpenTime;
formated.Data.Symbol = Symbol;
formated.Data.Open = data.Open;
formated.Data.Volume = data.Volume;
formated.Data.TakerBuyBaseAssetVolume = data.TakerBuyBaseAssetVolume;
formated.Data.TakerBuyQuoteAssetVolume = data.TakerBuyQuoteAssetVolume;
formated.Data.TradeCount = data.TradeCount;
returned.Add(formated);
}
return(returned);
//var data = IncomingBinance.bclient.Client.GetKlines(textBox2.Text, KlineInterval.OneHour, Data_Datestart.Value, Data_DateEnd.Value, int.MaxValue);
}
