private void GetVolumeTest(IPublicVolumeProvider provider, List <AssetPair> pairs, bool volumeBaseBiggerThanQuote)
{
OutputWriter.WriteLine("Volume interface test\n\n");
if (provider.VolumeFeatures.HasSingle)
{
OutputWriter.WriteLine("\nSingle features test\n");
var context = new PublicVolumeContext(pairs.First());
InternalGetVolumeAsync(provider, context, volumeBaseBiggerThanQuote, true);
}
if (provider.VolumeFeatures.HasBulk)
{
OutputWriter.WriteLine("\nBulk features test with pairs selection\n");
var context = new PublicVolumesContext(pairs);
InternalGetVolumeAsync(provider, context, volumeBaseBiggerThanQuote, false);
if (provider.VolumeFeatures.Bulk.CanReturnAll)
{
OutputWriter.WriteLine("\nBulk features test (provider can return all volumes)\n");
context = new PublicVolumesContext();
InternalGetVolumeAsync(provider, context, volumeBaseBiggerThanQuote, false);
}
}
TestVolumePricingSanity(provider, pairs);
}
public async Task <PublicVolumeResponse> GetVolumesAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickersAsync().ConfigureAwait(false);
CheckResponseError(r);
var rPairsDict = r.data.ToDictionary(x => x.pair.ToAssetPair(this, ':'), x => x);
var pairsQueryable = context.IsRequestAll ? rPairsDict.Keys.ToList() : context.Pairs;
var volumes = new MarketPricesResult();
foreach (var pair in pairsQueryable)
{
if (!rPairsDict.TryGetValue(pair, out var ticker))
{
volumes.MissedPairs.Add(pair);
continue;
}
volumes.MarketPrices.Add(new MarketPrice(Network, pair, 0)
{
Volume = new NetworkPairVolume(Network, pair, ticker.volume)
});
}
return(new PublicVolumeResponse(Network, volumes));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetVolumesAsync().ConfigureAwait(false);
var rPairsDict = r.ToDictionary(x => x.Key.ToAssetPair(this), x => x.Value);
var pairsQueryable = context.IsRequestAll ? rPairsDict.Keys.ToList() : context.Pairs;
var volumes = new List <NetworkPairVolume>();
var missingPairs = new List <AssetPair>();
foreach (var pair in pairsQueryable)
{
if (!rPairsDict.TryGetValue(pair, out var volumeInfo))
{
missingPairs.Add(pair);
continue;
}
var baseVolume = volumeInfo.FirstOrDefault(x => x.Key.Equals(pair.Asset1.ShortCode)).Value;
var quoteVolume = volumeInfo.FirstOrDefault(x => x.Key.Equals(pair.Asset2.ShortCode)).Value;
volumes.Add(new NetworkPairVolume(Network, pair, baseVolume, quoteVolume));
}
return(new PublicVolumeResponse(Network, volumes, missingPairs));
}
public async Task <PublicVolumeResponse> GetVolumesAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetMarketsAsync().ConfigureAwait(false);
if (r.success == false)
{
throw new ApiResponseException(r.message, this);
}
var rPairsDict = r.result.ToDictionary(x => x.MarketName.ToAssetPair(this), x => x);
var pairsQueryable = context.IsRequestAll ? rPairsDict.Keys.ToList() : context.Pairs;
var missing = new List <AssetPair>();
var volumes = new List <NetworkPairVolume>();
foreach (var pair in pairsQueryable)
{
if (!rPairsDict.TryGetValue(pair, out var ticker))
{
missing.Add(pair);
continue;
}
volumes.Add(new NetworkPairVolume(Network, pair, ticker.BaseVolume, ticker.Volume));
}
return(new PublicVolumeResponse(Network, volumes, missing));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.Get24HVolumeAsync().ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var volumes = r.Where(x => x.Key.ToAssetPair(this).Equals(context.Pair)).ToList();
if (!volumes.Any())
{
throw new AssetPairNotSupportedException(context.Pair, this);
}
var rVolumes = JsonConvert.DeserializeObject <Dictionary <string, decimal> >(volumes.FirstOrDefault().Value.ToString());
if (!rVolumes.TryGetValue(context.Pair.Asset1.ShortCode, out var volume))
{
throw new AssetPairNotSupportedException(context.Pair, this);
}
return(new PublicVolumeResponse(Network, context.Pair, volume));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetVolumesAsync().ConfigureAwait(false);
if (r.result == false)
{
throw new ApiResponseException("No market list returned.", this);
}
var rPairsDict = r.data.ToDictionary(x => x.pair.ToAssetPair(this), x => x);
var pairsQueryable = context.IsRequestAll ? rPairsDict.Keys.ToList() : context.Pairs;
var volumes = new List <NetworkPairVolume>();
var missingPairs = new List <AssetPair>();
foreach (var pair in pairsQueryable)
{
if (!rPairsDict.TryGetValue(pair, out var volumeInfo))
{
missingPairs.Add(pair);
continue;
}
volumes.Add(new NetworkPairVolume(Network, pair, volumeInfo.vol_a, volumeInfo.vol_b));
}
return(new PublicVolumeResponse(Network, volumes, missingPairs));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickerAsync(context.Pair.ToTicker(this, "").ToLower()).ConfigureAwait(false);
return(new PublicVolumeResponse(Network, context.Pair, r.volume));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetVolumesAsync().ConfigureAwait(false);
var rPairsDict = r.ToDictionary(x => x.product_id.ToAssetPair(this), x => x);
var pairsQueryable = context.IsRequestAll ? rPairsDict.Keys.ToList() : context.Pairs;
var volumes = new List <NetworkPairVolume>();
var missingPairs = new List <AssetPair>();
foreach (var pair in pairsQueryable)
{
if (!rPairsDict.TryGetValue(pair, out var ticker))
{
missingPairs.Add(pair);
continue;
}
volumes.Add(new NetworkPairVolume(Network, pair, ticker.volume, null));
}
return(new PublicVolumeResponse(Network, volumes, missingPairs));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
if (context.ForSingleMethod)
{
return(await GetVolumeAsync(context).ConfigureAwait(false));
}
return(await GetVolumesAsync(context).ConfigureAwait(false));
}
private void InternalGetVolumeAsync(IPublicVolumeProvider provider, PublicVolumesContext context, bool firstVolumeBaseBiggerThanQuote, bool runSingle)
{
Assert.True(provider.VolumeFeatures != null, "Volume features object is null");
var r = AsyncContext.Run(() => provider.GetPublicVolumeAsync(context));
// First volume, IsRequestAll.
var volume = r.Volume.FirstOrDefault();
Assert.True(volume != null, "Provider returned no volume records");
if (!context.IsRequestAll)
{
var dist = r.Volume.DistinctBy(x => x.Pair).ToList();
Assert.True(context.Pairs.Count == dist.Count, "Provider didn't return required pairs");
Assert.True(volume.Pair.Asset1.Equals(context.Pair.Asset1), "Incorrect base asset");
Assert.True(volume.Pair.Asset2.Equals(context.Pair.Asset2), "Incorrect quote asset");
}
// First volume, base/quote volumes relation.
if (volume.HasVolume24Base && volume.HasVolume24Quote)
{
if (firstVolumeBaseBiggerThanQuote)
{
Assert.True(volume.Volume24Base.ToDecimal(null) > volume.Volume24Quote.ToDecimal(null), "Quote volume is bigger than base (within volume)");
}
else
{
Assert.True(volume.Volume24Base.ToDecimal(null) < volume.Volume24Quote.ToDecimal(null), "Base volume is bigger than quote (within volume)");
}
}
// All volume.
foreach (var networkPairVolume in r.Volume)
{
if (networkPairVolume.HasVolume24Base)
{
Assert.False(networkPairVolume.Volume24Base.ToDecimal(null) == 0,
$"Base volume of {networkPairVolume.Pair} is 0");
OutputWriter.WriteLine($"Base volume for {networkPairVolume.Pair} pair is {networkPairVolume.Volume24Base}");
}
if (networkPairVolume.HasVolume24Quote)
{
Assert.False(networkPairVolume.Volume24Quote.ToDecimal(null) == 0,
$"Quote volume of {networkPairVolume.Pair} is 0");
OutputWriter.WriteLine($"Quote volume for {networkPairVolume.Pair} pair is {networkPairVolume.Volume24Quote}");
}
if (networkPairVolume.HasVolume24Base && networkPairVolume.HasVolume24Quote)
{
Assert.True(volume.Volume24Base.ToDecimal(null) != volume.Volume24Quote.ToDecimal(null), "Base and quote volume are the same");
}
}
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var remoteCode = context.Pair.ToTicker(this, "");
var r = await api.GetTickerInformationAsync(remoteCode).ConfigureAwait(false);
CheckResponseErrors(r);
return(new PublicVolumeResponse(Network, context.Pair, r.result.FirstOrDefault().Value.v[0]));
}
public async Task <PublicVolumeResponse> GetVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var pairCode = context.Pair.ToTicker(this);
var r = await api.GetMarketAsync(pairCode).ConfigureAwait(false);
if (r.success == false && r.result.Length > 0)
{
throw new ApiResponseException(r.message, this);
}
return(new PublicVolumeResponse(Network, context.Pair, r.result[0].BaseVolume, r.result[0].Volume));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
if (!context.Pair.Asset2.Equals(Asset.Krw))
{
throw new NoAssetPairException(context.Pair, this);
}
var r = await api.GetTickerAsync(context.Pair.Asset1.ShortCode).ConfigureAwait(false);
CheckResponseErrors(r);
return(new PublicVolumeResponse(Network, context.Pair, r.volume));
}
public async Task <PublicVolumeResponse> GetPublicVolumeAsync(PublicVolumesContext context)
{
var api = ApiProvider.GetApi(context);
var pairCode = context.Pair.ToTicker(this).ToLower();
var r = await api.GetMarketSummaryAsync(pairCode).ConfigureAwait(false);
var summary = r.result.FirstOrDefault();
var remoteMarker = summary.MarketName.ToAssetPair(this);
if (summary == null || !remoteMarker.Equals(context.Pair))
{
throw new NoAssetPairException(context.Pair, this);
}
return(new PublicVolumeResponse(Network, context.Pair, summary.BaseVolume, summary.Volume));
}
private void GetVolume(IPublicVolumeProvider provider, List <AssetPair> pairs)
{
try
{
Trace.WriteLine("Volume interface test\n\n");
if (provider.VolumeFeatures.HasSingle)
{
Trace.WriteLine("\nSingle features test\n");
var context = new PublicVolumeContext(pairs.First());
InternalGetVolumeAsync(provider, context, true);
}
if (provider.VolumeFeatures.HasBulk)
{
Trace.WriteLine("\nBulk features test with pairs selection\n");
var context = new PublicVolumesContext(pairs);
InternalGetVolumeAsync(provider, context, false);
if (provider.VolumeFeatures.Bulk.CanReturnAll)
{
Trace.WriteLine("\nBulk features test (provider can return all volumes)\n");
context = new PublicVolumesContext();
InternalGetVolumeAsync(provider, context, false);
}
}
TestVolumePricingSanity(provider, pairs);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
private void InternalGetVolumeAsync(IPublicVolumeProvider provider, PublicVolumesContext context, bool runSingle)
{
Assert.IsTrue(provider.VolumeFeatures != null, "Volume features object is null");
var r = AsyncContext.Run(() => provider.GetPublicVolumeAsync(context));
}
