private void GetOhlcTest(IOhlcProvider provider, OhlcContext context)
{
if (context == null)
{
return;
}
var ohlc = AsyncContext.Run(() => provider.GetOhlcAsync(context));
bool success = true;
OhlcEntry ohlcEntryPrev = null;
foreach (var ohlcEntry in ohlc.OhlcData)
{
if (ohlcEntryPrev != null)
{
if (ohlcEntry.DateTimeUtc >= ohlcEntryPrev.DateTimeUtc)
{
success = false;
throw new InvalidOperationException("Time check is failed.");
}
}
ohlcEntryPrev = ohlcEntry;
}
Assert.True(success);
Assert.True(ohlc != null && ohlc.OhlcData.Count > 0);
OutputWriter.WriteLine("OHLC data:");
foreach (var entry in ohlc.OhlcData)
{
OutputWriter.WriteLine($"{entry.DateTimeUtc}: O {entry.Open}, H {entry.High}, L {entry.Low}, C {entry.Close}");
}
}
public override void TestGetOhlc()
{
var context = new OhlcContext(new AssetPair("BNT", "BTC"), TimeResolution.Minute,
new TimeRange(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, TimeResolution.Minute));
base.TestGetOhlc(context);
}
public async Task <OhlcData> GetOhlcAsync(OhlcContext context)
{
var api = ApiProvider.GetApi(context);
var pairCode = context.Pair.ToTicker(this);
var interval = ConvertToBinanceInterval(context.Market);
var startDate = (long)(context.Range.UtcFrom.ToUnixTimeStamp() * 1000);
var endDate = (long)(context.Range.UtcTo.ToUnixTimeStamp() * 1000);
var r = await api.GetCandlestickBarsAsync(pairCode, interval, startDate, endDate).ConfigureAwait(false);
var ohlc = new OhlcData(context.Market);
var seriesId = OhlcUtilities.GetHash(context.Pair, context.Market, Network);
foreach (var rEntry in r)
{
var dateTime = ((long)(rEntry[0] / 1000)).ToUtcDateTime();
ohlc.Add(new OhlcEntry(seriesId, dateTime, this)
{
Open = rEntry[1],
Close = rEntry[4],
Low = rEntry[3],
High = rEntry[2],
VolumeTo = rEntry[7], // Quote asset volume
VolumeFrom = rEntry[5], // Volume
WeightedAverage = 0 // BUG: no WeightedAverage data returned from API.
});
}
ohlc.Reverse();
return(ohlc);
}
public async Task <OhlcData> GetOhlcAsync(OhlcContext context)
{
var pair = context.Pair;
var market = context.Market;
var timeStampStart = (long)context.Range.UtcFrom.ToUnixTimeStamp();
var timeStampEnd = (long)context.Range.UtcTo.ToUnixTimeStamp();
var period = ConvertToPoloniexInterval(market);
var api = ApiProvider.GetApi(context);
var r = await api.GetChartDataAsync(pair.ToTicker(this), timeStampStart, timeStampEnd, period).ConfigureAwait(false);
var ohlc = new OhlcData(market);
var seriesid = OhlcUtilities.GetHash(pair, market, Network);
foreach (var ohlcEntry in r)
{
ohlc.Add(new OhlcEntry(seriesid, ohlcEntry.date.ToUtcDateTime(), this)
{
Open = ohlcEntry.open,
Close = ohlcEntry.close,
Low = ohlcEntry.low,
High = ohlcEntry.high,
VolumeTo = ohlcEntry.quoteVolume,
VolumeFrom = ohlcEntry.volume,
WeightedAverage = ohlcEntry.weightedAverage
});
}
return(ohlc);
}
private void GetOhlcAsync(IOhlcProvider provider, OhlcContext context)
{
if (context == null)
{
return;
}
var ohlc = AsyncContext.Run(() => provider.GetOhlcAsync(context));
bool success = true;
OhlcEntry ohlcEntryPrev = null;
foreach (var ohlcEntry in ohlc)
{
if (ohlcEntryPrev != null)
{
if (ohlcEntry.DateTimeUtc >= ohlcEntryPrev.DateTimeUtc)
{
success = false;
Assert.Fail("Time check is failed.");
}
}
ohlcEntryPrev = ohlcEntry;
}
Assert.IsTrue(success);
Assert.IsTrue(ohlc != null && ohlc.Count > 0);
Trace.WriteLine("OHLC data:");
foreach (var entry in ohlc)
{
Trace.WriteLine($"{entry.DateTimeUtc}: O {entry.Open}, H {entry.High}, L {entry.Low}, C {entry.Close}");
}
}
public async Task <OhlcData> GetOhlcAsync(OhlcContext context)
{
var api = ApiProvider.GetApi(context);
var resolution = ConvertToBitMexInterval(context.Market);
var startDate = context.Range.UtcFrom;
var endDate = context.Range.UtcTo;
var r = await api.GetTradeHistoryAsync(context.Pair.Asset1.ToRemoteCode(this), resolution, startDate, endDate).ConfigureAwait(false);
var ohlc = new OhlcData(context.Market);
var seriesId = OhlcUtilities.GetHash(context.Pair, context.Market, Network);
foreach (var instrActive in r)
{
ohlc.Add(new OhlcEntry(seriesId, instrActive.timestamp, this)
{
Open = instrActive.open,
Close = instrActive.close,
Low = instrActive.low,
High = instrActive.high,
VolumeTo = instrActive.volume,
VolumeFrom = instrActive.volume,
WeightedAverage = (instrActive.vwap ?? 0) // BUG: what to set if vwap is NULL?
});
}
return(ohlc);
}
public override void TestGetOhlc()
{
var context = new OhlcContext("BTC_USDT".ToAssetPairRaw(), TimeResolution.Minute,
new TimeRange(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, TimeResolution.Minute));
base.PretestGetOhlc(context);
}
public override void TestGetOhlc()
{
// BUG: supports only 1 day.
var context = new OhlcContext(new AssetPair("BTC", "LTC"), TimeResolution.Day,
new TimeRange(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, TimeResolution.Hour));
base.TestGetOhlc(context);
}
public void TestGetOhlc(OhlcContext context)
{
var p = IsType <IOhlcProvider>();
if (p.Success)
{
GetOhlcAsync(p.Provider, context);
}
}
public async Task <OhlcDataResponse> GetOhlcAsync(OhlcContext context)
{
var api = GdaxApiProvider.GetApi(context);
var currencyCode = context.Pair.ToTicker(this);
var ohlc = new OhlcDataResponse(context.Resolution);
var seriesId = OhlcUtilities.GetHash(context.Pair, context.Resolution, Network);
var granularitySeconds = GetSeconds(context.Resolution);
var maxNumberOfCandles = 200;
var tsFrom = (long)context.Range.UtcFrom.ToUnixTimeStamp();
var tsTo = (long)context.Range.UtcTo.ToUnixTimeStamp();
var tsStep = maxNumberOfCandles * granularitySeconds;
var currTsTo = tsTo;
var currTsFrom = tsTo - tsStep;
while (currTsTo > tsFrom)
{
var candles = await api.GetCandlesAsync(currencyCode, currTsFrom.ToUtcDateTime(), currTsTo.ToUtcDateTime(), granularitySeconds).ConfigureAwait(false);
foreach (var candle in candles)
{
var dateTime = ((long)candle[0]).ToUtcDateTime();
ohlc.Add(new OhlcEntry(seriesId, dateTime, this)
{
Low = candle[1],
High = candle[2],
Open = candle[3],
Close = candle[4],
VolumeTo = candle[5],
VolumeFrom = candle[5],
WeightedAverage = 0 // Is not provided by API.
});
}
currTsTo = currTsFrom;
if (currTsTo - tsStep >= tsFrom)
{
currTsFrom -= tsStep;
}
else
{
currTsFrom = tsFrom;
}
ApiHelpers.EnterRate(this, context);
}
return(ohlc);
}
public void GetOhlc()
{
var provider = Networks.I.Providers.OfType <KrakenProvider>().FirstProvider();
var ctx = new OhlcContext(new AssetPair("BTC", "USD"), TimeResolution.Minute, null);
try
{
var ohlc = AsyncContext.Run(() => provider.GetOhlcAsync(ctx));
foreach (var data in ohlc.OhlcData)
{
System.Console.WriteLine($"{data.DateTimeUtc}: {data.High} {data.Low}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw;
}
}
public async Task <OhlcData> GetOhlcAsync(OhlcContext context)
{
var api = ApiProvider.GetApi(context);
var krakenTimeInterval = ConvertToKrakenInterval(context.Market);
// BUG: "since" is not implemented. Need to be checked.
var r = await api.GetOhlcDataAsync(context.Pair.ToTicker(this, ""), krakenTimeInterval).ConfigureAwait(false);
CheckResponseErrors(r);
var ohlc = new OhlcData(context.Market);
var seriesId = OhlcUtilities.GetHash(context.Pair, context.Market, Network);
if (r.result.pairs.Count != 0)
{
foreach (var ohlcResponse in r.result.pairs.FirstOrDefault().Value.OrderByDescending(x => x.time))
{
var time = ((long)ohlcResponse.time).ToUtcDateTime();
// BUG: ohlcResponse.volume is double ~0.2..10.2, why do we cast to long?
ohlc.Add(new OhlcEntry(seriesId, time, this)
{
Open = ohlcResponse.open,
Close = ohlcResponse.close,
Low = ohlcResponse.low,
High = ohlcResponse.high,
VolumeTo = ohlcResponse.volume, // Cast to long should be revised.
VolumeFrom = ohlcResponse.volume,
WeightedAverage = ohlcResponse.vwap // Should be checked.
});
}
}
else
{
throw new ApiResponseException("No OHLC data received", this);
}
return(ohlc);
}
public void GetChartData()
{
var provider = Networks.I.Providers.OfType <PoloniexProvider>().FirstProvider();
var pair = new AssetPair("BTC", "ETH", provider);
var ctx = new OhlcContext(pair, TimeResolution.Day, new TimeRange(DateTime.UtcNow.AddDays(-5), DateTime.UtcNow, TimeResolution.Day));
try
{
var ohlc = AsyncContext.Run(() => provider.GetOhlcAsync(ctx));
foreach (var entry in ohlc)
{
System.Console.WriteLine($"{entry.DateTimeUtc}: {entry.High}, {entry.Low}, {entry.Open}, {entry.Close}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e);
throw;
}
}
public void Go()
{
var ohlcs = Networks.I.Providers.OfType <IOhlcProvider>().ToArray();
foreach (var provider in ohlcs)
{
System.Console.WriteLine($"Name: {provider.Network.Name}");
}
var bitmex = Networks.I.Providers.OfType <IOhlcProvider>().First(x => x.Network.Name.Equals("bitfinex", StringComparison.InvariantCultureIgnoreCase));
int daysMinus = 120;
var ctx = new OhlcContext("XRP_USD".ToAssetPairRaw(), TimeResolution.Hour,
new TimeRange(DateTime.UtcNow.AddDays(-daysMinus * 2), DateTime.UtcNow.AddDays(-daysMinus),
TimeResolution.Hour));
var r = bitmex.GetOhlcAsync(ctx).Result;
var contents = string.Join("\r\n", r.Select(x => $"{x.DateTimeUtc} - {(x.High + x.Low) / 2}"));
File.WriteAllText(@"ohlc-xrp-usd-2.txt", contents);
}
public void GetOhlcData()
{
var provider = Networks.I.Providers.OfType <BitMexProvider>().FirstProvider();
var ohlcContext = new OhlcContext(new AssetPair("BTC", "USD"), TimeResolution.Minute, new TimeRange(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, TimeResolution.Minute));
try
{
var ohlc = AsyncContext.Run(() => provider.GetOhlcAsync(ohlcContext));
foreach (var data in ohlc)
{
Console.WriteLine($"{data.DateTimeUtc}: {data.High} {data.Low} {data.Open} {data.Close}");
}
Console.WriteLine($"Entries count: {ohlc.Count}");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
public override void TestGetOhlc()
{
var context = new OhlcContext("ETC_ETH".ToAssetPairRaw(), TimeResolution.Minute, TimeRange.EveryDayTillNow);
base.TestGetOhlc(context);
}
public async Task <OhlcData> GetOhlcAsync(OhlcContext context)
{
var range = context.Range;
var market = context.Market;
var pair = context.Pair;
var limit = range.GetDistanceInResolutionTicks();
var toTs = range.UtcTo.GetSecondsSinceUnixEpoch();
var api = GetApi <ICryptoCompareApi>();
CryptoCompareSchema.HistoricListResult apir = null;
switch (market)
{
case TimeResolution.Hour:
apir = await api.GetHistoricalHourlyAsync(pair.Asset1.ToRemoteCode(this), pair.Asset2.ToRemoteCode(this), Name, "prime", "false", "true", 0, limit, toTs).ConfigureAwait(false);
break;
case TimeResolution.Day:
apir = await api.GetHistoricalDayAsync(pair.Asset1.ToRemoteCode(this), pair.Asset2.ToRemoteCode(this), Name, "prime", "false", "true", 0, limit, toTs, "false").ConfigureAwait(false);
break;
case TimeResolution.Minute:
apir = await api.GetHistoricalMinuteAsync(pair.Asset1.ToRemoteCode(this), pair.Asset2.ToRemoteCode(this), Name, "prime", "false", "true", 0, limit, toTs).ConfigureAwait(false);
break;
}
if (apir.IsError())
{
return(null);
}
var r = new OhlcData(market);
var seriesid = OhlcUtilities.GetHash(pair, market, Network);
var from = apir.TimeFrom;
var to = apir.TimeTo;
foreach (var i in apir.Data.Where(x => x.time >= from && x.time <= to))
{
var t = ((double)i.time).UnixTimestampToDateTime();
r.Add(new OhlcEntry(seriesid, t, this)
{
Open = i.open,
Close = i.close,
Low = i.low,
High = i.high,
VolumeFrom = i.volumefrom,
VolumeTo = i.volumeto
});
}
if (!string.IsNullOrWhiteSpace(apir.ConversionType.conversionSymbol))
{
r.ConvertedFrom = apir.ConversionType.conversionSymbol.ToAsset(this);
}
return(r);
}
private OhlcData Convert(TimeRange range)
{
Ctx.Status("Converting @" + Ctx.PrimaryApiProvider.Title + " " + Ctx.CurrencyConversionApiProvider.Title + " [1]");
var pc = new OhlcContext(new AssetPair(Ctx.Pair.Asset1, Ctx.AssetIntermediary), Ctx.TimeResolution, range, L);
var r1 = ApiCoordinator.GetOhlc(Ctx.PrimaryApiProvider, pc);
if (r1.IsNull)
{
return(null);
}
var d1 = r1.Response;
Ctx.Status("Converting @" + Ctx.PrimaryApiProvider.Title + " " + Ctx.CurrencyConversionApiProvider.Title + " [2]");
var pc2 = new OhlcContext(new AssetPair(Ctx.AssetIntermediary, Ctx.Pair.Asset2), Ctx.TimeResolution, range, L);
var r2 = ApiCoordinator.GetOhlc(Ctx.CurrencyConversionApiProvider, pc2);
if (r2.IsNull)
{
return(null);
}
var d2 = r2.Response;
if (d1.IsEmpty() || d2.IsEmpty())
{
return(null);
}
if (d1.Count != d2.Count)
{
return(null);
}
var ohcldata = new OhlcData(_adapter.TimeResolution)
{
ConvertedFrom = Ctx.AssetIntermediary,
Network = Ctx.PrimaryApiProvider.Network
};
var seriesid = OhlcUtilities.GetHash(Ctx.Pair, range.TimeResolution, ohcldata.Network);
foreach (var i in d1)
{
var i2 = d2.FirstOrDefault(x => x.DateTimeUtc == i.DateTimeUtc);
if (i2 == null)
{
return(null);
}
ohcldata.Add(new OhlcEntry(seriesid, i.DateTimeUtc, Ctx.PrimaryApiProvider, Ctx.CurrencyConversionApiProvider, Ctx.AssetIntermediary)
{
Open = i.Open * i2.Open,
Close = i.Close * i2.Close,
High = i.High * i2.High,
Low = i.Low * i2.Low,
VolumeTo = 0,
VolumeFrom = i2.VolumeFrom,
WeightedAverage = 0
});
}
return(ohcldata);
}
