public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickerAsync("BTCUSD").ConfigureAwait(false);
return(r?.responseStatus?.message?.Equals("OK", StringComparison.InvariantCultureIgnoreCase) == true);
}
public Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var t = new Task <bool>(() => true);
t.Start();
return(t);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetMarketsAsync().ConfigureAwait(false);
return(r?.status.Equals("success", StringComparison.OrdinalIgnoreCase) == true);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickersAsync().ConfigureAwait(false);
return(r.Success);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickerAsync("BTC/USD").ConfigureAwait(false);
return(r?.last > 0);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var ctx = new PublicPriceContext("btc_cad".ToAssetPair(this, 3));
var r = await GetPricingAsync(ctx).ConfigureAwait(false);
return(r != null);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetCountriesAsync().ConfigureAwait(false);
return(r?.Length > 0);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetExchangeRate().ConfigureAwait(false);
return(r?.rate > 0);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetSymbolPriceTickerAsync().ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var assetPairs = new AssetPairs();
foreach (var rPrice in r.OrderBy(x => x.symbol.Length))
{
var pair = AssetsUtilities.GetAssetPair(rPrice.symbol, assetPairs);
if (!pair.HasValue)
{
continue;
}
assetPairs.Add(new AssetPair(pair.Value.AssetCode1, pair.Value.AssetCode2, this));
}
return(assetPairs);
}
public virtual async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProviderPublic.GetApi(context);
var r = await api.GetAssetPairsAsync().ConfigureAwait(false);
return(r?.pairs?.Count > 0);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickerAsync("BTC_EUR").ConfigureAwait(false);
return(r?.error == false && r.data != null);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTimeAsync().ConfigureAwait(false);
return(r?.timestamp > 0);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickerAsync("ltc_usd").ConfigureAwait(false);
return(r?.ticker != null);
}
protected void GetAssetPairsTest(IAssetPairsProvider provider, AssetPairs requiredPairs)
{
var ctx = new NetworkProviderContext();
var pairs = AsyncContext.Run(() => provider.GetAssetPairsAsync(ctx));
Assert.True(pairs != null);
Assert.True(pairs.Count > 0);
if (requiredPairs != null)
{
OutputWriter.WriteLine("Checked pairs:");
foreach (var requiredPair in requiredPairs)
{
var contains = pairs.Contains(requiredPair);
Assert.True(contains, $"Provider didn't return required {requiredPair} pair.");
OutputWriter.WriteLine(requiredPair.ToString());
}
}
OutputWriter.WriteLine("\nRemote pairs from exchange:");
foreach (var pair in pairs)
{
OutputWriter.WriteLine(pair.ToString());
}
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetCurrentServerTimeAsync().ConfigureAwait(false);
return(r != null);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var priceCtx = new PublicPriceContext("BTC_LTC".ToAssetPair(this));
var r = await GetPriceAsync(priceCtx).ConfigureAwait(false);
return(r != null && r.IsCompleted && r.FirstPrice != null);
}
public T GetApi(NetworkProviderContext context = null)
{
return(new RestClient(_apiUrl)
{
JsonSerializerSettings = JsonSerializerSettings,
//ResponseDeserializer = new DebugDeserialiser()
}.For <T>() as T);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi();
await api.PingAsync().ConfigureAwait(false);
return(true);
}
private void TestApiPublic(INetworkProvider provider)
{
var ctx = new NetworkProviderContext();
var r = AsyncContext.Run(() => provider.TestPublicApiAsync(ctx));
Assert.IsTrue(r);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetServerTimeAsync().ConfigureAwait(false);
CheckResponseErrors(r);
return(r.result.unixtime > 0);
}
public bool IsSafe(NetworkProviderContext context)
{
lock (_lock)
{
_hits.Add(DateTime.UtcNow);
var expired = DateTime.UtcNow.AddSeconds(-_perSeconds);
_hits.RemoveAll(x => x <= expired);
return(_hits.Count < _requests);
}
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi();
var rRaw = await api.PingAsync().ConfigureAwait(false);
CheckResponseErrors(rRaw);
return(true);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetTickerAsync("BTC_EUR").ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
return(r.data != null);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var products = await GetAllProductsAsync().ConfigureAwait(false);
var pairs = new AssetPairs();
foreach (var rCurrentTicker in products)
{
pairs.Add(rCurrentTicker.currency_pair_code.ToAssetPair(this, 3));
}
return(pairs);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetSymbolsAsync().ConfigureAwait(false);
var assetPairs = new AssetPairs();
foreach (var symbol in r.symbols)
{
assetPairs.Add(new AssetPair(symbol.commodity.ToAsset(this), symbol.currency.ToAsset(this)));
}
return(assetPairs);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetTickersAsync().ConfigureAwait(false);
var pairs = new AssetPairs();
foreach (var rTicker in r.data)
{
pairs.Add(rTicker.pair.ToAssetPair(this, ':'));
}
return(pairs);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetProductsAsync().ConfigureAwait(false);
var pairs = new AssetPairs();
foreach (var rProduct in r)
{
pairs.Add(new AssetPair(rProduct.base_currency, rProduct.quote_currency));
}
return(pairs);
}
private void TestPublicApi(INetworkProvider provider)
{
var ctx = new NetworkProviderContext();
try
{
var r = AsyncContext.Run(() => provider.TestPublicApiAsync(ctx));
Assert.IsTrue(r);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetSymbolsAsync().ConfigureAwait(false);
var assetPairs = new AssetPairs();
foreach (var symbol in r)
{
assetPairs.Add(new AssetPair(symbol.baseCurrency, symbol.quoteCurrency, this));
}
return(assetPairs);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var p = Networks.I.Providers.FirstProviderOf <CryptoCompareProvider>();
var r = await p.GetAssetPairsAllNetworksAsync().ConfigureAwait(false);
var d = r.Get(Network);
if (d == null)
{
throw new Exception($"CryptoCompare does not provide asset pair information for {Network}");
}
return(d);
}
