/// <summary>
/// Gets the Klines/Candlesticks for the provided request
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <List <KlineCandleStickResponse> > GetKlinesCandlesticks(GetKlinesCandlesticksRequest request)
{
Guard.AgainstNull(request.Symbol);
Guard.AgainstNull(request.Interval);
return(await _apiProcessor.ProcessGetRequest <List <KlineCandleStickResponse> >(Endpoints.MarketData.KlineCandlesticks(request)));
}
public async Task <List <Candle> > GetTickerHistory(string market, DateTime startDate, Period period)
{
var endTime = DateTime.UtcNow;
var start = startDate;
var candles = new List <KlineCandleStickResponse>();
while (start < endTime)
{
var request = new GetKlinesCandlesticksRequest
{
Symbol = market,
Interval = (BinanceExchange.API.Enums.KlineInterval)period,
StartTime = start,
EndTime = endTime
};
var candlesticksToAdd = await _client.GetKlinesCandlesticks(request);
candles.AddRange(candlesticksToAdd);
start = candlesticksToAdd.Count() == 0 ? DateTime.MaxValue : candlesticksToAdd.Max(_ => _.CloseTime);
}
return(candles.Select(_ =>
new Candle
{
Close = (double)_.Close,
High = (double)_.High,
Low = (double)_.Low,
Open = (double)_.Open,
Timestamp = _.OpenTime
}
).ToList());
}
/// <summary>
/// Gets the Klines/Candlesticks for the provided request
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <List <KlineCandleStickResponse> > GetKlinesCandlesticks(GetKlinesCandlesticksRequest request)
{
Guard.AgainstNull(request.Symbol);
Guard.AgainstDateTimeMin(request.StartTime);
Guard.AgainstDateTimeMin(request.EndTime);
if (request.Limit == 0 || request.Limit > 500)
{
request.Limit = 500;
}
return(await _apiProcessor.ProcessGetRequest <List <KlineCandleStickResponse> >(Endpoints.MarketData.KlineCandlesticks(request)));
}
private async Task <KlineCandleStickResponse> GetLastDaysCandle(string symbol)
{
var endTime = DateTime.UtcNow;
var startTime = endTime.AddDays(-1);
var request = new GetKlinesCandlesticksRequest
{
Symbol = symbol,
StartTime = startTime,
EndTime = endTime,
Interval = BinanceExchange.API.Enums.KlineInterval.OneDay
};
var result = await _client.GetKlinesCandlesticks(request);
return(result.SingleOrDefault());
}
public async Task <IEnumerable <CandleStick> > Get([FromServices] IBinanceClient binanceClient, string currency,
int?limit, long?startDate, long?endDate, string tframe)
{
KlineInterval interval = tframe switch
{
"M1" => KlineInterval.OneMinute,
"M5" => KlineInterval.FiveMinutes,
"M15" => KlineInterval.FifteenMinutes,
"M30" => KlineInterval.ThirtyMinutes,
"H1" => KlineInterval.OneHour,
"H4" => KlineInterval.FourHours,
"D1" => KlineInterval.OneDay,
"W1" => KlineInterval.OneWeek,
_ => KlineInterval.OneHour
};
var opts = new GetKlinesCandlesticksRequest {
Interval = interval, Limit = limit, Symbol = currency
};
opts.StartTime = (startDate.HasValue) ? DateTimeOffset.FromUnixTimeSeconds(startDate.Value).DateTime.ToLocalTime() : null;
opts.EndTime = (endDate.HasValue) ? DateTimeOffset.FromUnixTimeSeconds(endDate.Value).DateTime.ToLocalTime() : null;
var data = await binanceClient.GetKlinesCandlesticks(opts);
var result = data.Select(d => new CandleStick()
{
Open = d.Open,
Close = d.Close,
High = d.High,
Low = d.Low,
Volume = d.Volume,
Timestamp = d.OpenTime.ToToUnixTimestamp()
}).ToList();
return(result);
}
}
/// <summary>
/// Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.
/// </summary>
public static BinanceEndpointData KlineCandlesticks(GetKlinesCandlesticksRequest request)
{
var queryString = GenerateQueryStringFromData(request);
return(new BinanceEndpointData(new Uri($"{APIPrefix}/{ApiVersion}/klines?{queryString}"), EndpointSecurityType.None));
}
/// <summary>
/// Advanced approach to building local Kline Cache from WebSocket and API Call example (refactored)
/// </summary>
/// <param name="binanceClient">The BinanceClient instance</param>
/// <param name="symbol">The Symbol to request</param>
/// <param name="interval">The interval for Klines</param>
/// <param name="klinesCandlesticksRequest">The initial request for Klines</param>
/// <param name="webSocketConnectionFunc">The function to determine exiting the websocket (can be timeout or Func based on external params)</param>
/// <param name="cacheObject">The cache object. Must always be provided, and can exist with data.</param>
/// <returns></returns>
public static async Task BuildAndUpdateLocalKlineCache(IBinanceClient binanceClient,
string symbol,
KlineInterval interval,
GetKlinesCandlesticksRequest klinesCandlesticksRequest,
WebSocketConnectionFunc webSocketConnectionFunc,
Dictionary <string, KlineCacheObject> cacheObject)
{
Guard.AgainstNullOrEmpty(symbol);
Guard.AgainstNull(webSocketConnectionFunc);
Guard.AgainstNull(klinesCandlesticksRequest);
Guard.AgainstNull(cacheObject);
long epochTicks = new DateTime(1970, 1, 1).Ticks;
if (cacheObject.ContainsKey(symbol))
{
if (cacheObject[symbol].KlineInterDictionary.ContainsKey(interval))
{
throw new Exception(
"Symbol and Interval pairing already provided, please use a different interval/symbol or pair.");
}
cacheObject[symbol].KlineInterDictionary.Add(interval, new KlineIntervalCacheObject());
}
else
{
var klineCacheObject = new KlineCacheObject
{
KlineInterDictionary = new Dictionary <KlineInterval, KlineIntervalCacheObject>()
};
cacheObject.Add(symbol, klineCacheObject);
cacheObject[symbol].KlineInterDictionary.Add(interval, new KlineIntervalCacheObject());
}
// Get Kline Results, and use Cache
long ticks = klinesCandlesticksRequest.StartTime.Value.Ticks;
var startTimeKeyTime = (ticks - epochTicks) / TimeSpan.TicksPerSecond;
var klineResults = await binanceClient.GetKlinesCandlesticks(klinesCandlesticksRequest);
var oneMinKlineCache = cacheObject[symbol].KlineInterDictionary[interval];
oneMinKlineCache.TimeKlineDictionary = new Dictionary <long, KlineCandleStick>();
var instanceKlineCache = oneMinKlineCache.TimeKlineDictionary;
//Populate our kline cache with initial results
klineResults.ForEach(k =>
{
instanceKlineCache.Add(((k.OpenTime.Ticks - epochTicks) / TimeSpan.TicksPerSecond), new KlineCandleStick()
{
Close = k.Close,
High = k.High,
Low = k.Low,
Open = k.Open,
Volume = k.Volume,
});
});
// Store the last update from our result set;
using (var binanceWebSocketClient = new DisposableBinanceWebSocketClient(binanceClient))
{
binanceWebSocketClient.ConnectToKlineWebSocket(symbol, interval, data =>
{
var keyTime = (data.Kline.StartTime.Ticks - epochTicks) / TimeSpan.TicksPerSecond;
var klineObj = new KlineCandleStick()
{
Close = data.Kline.Close,
High = data.Kline.High,
Low = data.Kline.Low,
Open = data.Kline.Open,
Volume = data.Kline.Volume,
};
if (!data.Kline.IsBarFinal)
{
if (keyTime < startTimeKeyTime)
{
return;
}
TryAddUpdateKlineCache(instanceKlineCache, keyTime, klineObj);
}
else
{
TryAddUpdateKlineCache(instanceKlineCache, keyTime, klineObj);
}
System.Console.Clear();
System.Console.WriteLine($"{JsonConvert.SerializeObject(instanceKlineCache, Formatting.Indented)}");
System.Console.SetWindowPosition(0, 0);
});
if (webSocketConnectionFunc.IsTimout)
{
Thread.Sleep(webSocketConnectionFunc.Timeout);
}
else
{
while (true)
{
if (!webSocketConnectionFunc.ExitFunction())
{
// Throttle Application
Thread.Sleep(100);
}
else
{
break;
}
}
}
}
}
