/// <summary>
/// Enables the API.
/// </summary>
public void Enable()
{
if (this.apiSchema == ApiSchema.Pro && this.ApiData.ApiKey == string.Empty)
{
throw new Exception("API Key missing!");
}
if (this.apiSchema == ApiSchema.Pro)
{
this.client = new CoinMarketCapClient(this.apiSchema, this.ApiData.ApiKey);
}
else
{
string apiKey = "29bc6cc3-7219-42f6-af87-f0147e9ee089";
this.client = new CoinMarketCapClient(this.apiSchema, apiKey);
}
if (this.assetUpdateWorker.IsAlive)
{
throw new Exception("Already running!");
}
this.assetUpdateWorker = new Thread(this.AssetUpdateWorker);
this.assetUpdateWorker.Start();
}
public async static Task <CoinDetails> GetCoinTicker(string id)
{
CoinDetails Coin = null;
var Client = CoinMarketCapClient.GetInstance();
var Ticker = await Client.GetTickerAsync(id);
Coin = new CoinDetails()
{
AvailableSupply = Ticker.AvailableSupply,
Id = Ticker.Id,
Name = Ticker.Name,
PercentChange1h = Ticker.PercentChange1h,
PercentChange24h = Ticker.PercentChange24h,
PercentChange7d = Ticker.PercentChange7d,
PriceBtc = Ticker.PriceBtc,
Rank = Ticker.Rank,
Symbol = Ticker.Symbol,
TotalSupply = Ticker.TotalSupply,
LastUpdatedUnixTime = Ticker.LastUpdatedUnixTime,
LastUpdated = Ticker.LastUpdated,
MarketCapUsd = Ticker.MarketCapUsd,
MarketCapOther = Ticker.MarketCapOther.ToEntity(),
PriceOther = Ticker.PriceOther.ToEntity(),
PriceUsd = Ticker.PriceUsd,
Volume24hOther = Ticker.Volume24hOther.ToEntity(),
Volume24hUsd = Ticker.Volume24hUsd
};
return(Coin);
}
public async static Task <GetCoinMetadataResponse> GetCoinMetadata(string symbol, string id, string baseCoinSymbol = "BTC")
{
var Response = new GetCoinMetadataResponse();
var List = await GetCoinList();
if (!List.ContainsKey(symbol))
{
var Client = CoinMarketCapClient.GetInstance();
Response.Details = await GetCoinTicker(id);
return(Response);
}
if (Exchanges == null)
{
Exchanges = await GetExchanges();
}
var CryptoId = Int32.Parse(List[symbol].Id);
var SnapshotTask = GetCoinSnapshot(CryptoId);
var TickerTask = GetCoinTicker(id);
var SocialTask = GetSocialStats(CryptoId);
var ChartDataTask = GetCandleData(symbol, baseCoinSymbol);
await Task.WhenAll(SnapshotTask, TickerTask, ChartDataTask, SocialTask);
var ExchangeList = Exchanges.Where(x => x.Value.ContainsKey(symbol)).Select(x => x.Key).ToList();
Response.Metadata = SnapshotTask.Result;
Response.Details = TickerTask.Result;
Response.CandleData = ChartDataTask.Result;
Response.SocialStats = SocialTask.Result;
Response.Exchanges = ExchangeList;
return(Response);
}
public void Start()
{
_startDate = DateTime.UtcNow;
_logger.LogInformation("Starting Telegram Bot");
_telegramBotClient.OnMessage += BotOnMessageReceived;
_telegramBotClient.OnMessageEdited += BotOnMessageReceived;
//_telegramBotClient.OnCallbackQuery += BotOnCallbackQueryReceived;
//_telegramBotClient.OnInlineQuery += BotOnInlineQueryReceived;
//_telegramBotClient.OnInlineResultChosen += BotOnChosenInlineResultReceived;
//_telegramBotClient.OnReceiveError += BotOnReceiveError;
var me = _telegramBotClient.GetMeAsync().Result;
Console.Title = me.Username;
_logger.LogInformation($"Telegram Bot testing connection => {me.Username}");
_coinMarketCapClient = new CoinMarketCapClient();
_telegramBotClient.StartReceiving();
_started = true;
_logger.LogInformation("Telegram Bot started");
}
public async static Task <MarketInfo> GetGlobalStats()
{
var Client = CoinMarketCapClient.GetInstance();
var Stats = await Client.GetGlobalDataAsync();
return(Stats.ToEntity());
}
public void GetTickerExpected()
{
var httpClientMock = new Mock <IRestClient>();
IDeserializer deserializer = null;
httpClientMock.Setup(x => x.AddHandler("application/json", It.IsAny <IDeserializer>())).Callback <string, IDeserializer>((c, d) => deserializer = d);
httpClientMock.SetupAllProperties();
httpClientMock.Setup(x => x.Execute <List <Ticker> >(It.IsAny <IRestRequest>())).Returns <IRestRequest>(request =>
{
var responseMock = new Mock <IRestResponse <List <Ticker> > >();
responseMock.Setup(x => x.Content).Returns(Properties.Resources.CoinMarketCap_Sample);
responseMock.Setup(x => x.Request).Returns(request);
responseMock.Setup(x => x.ContentType).Returns("application/json");
responseMock.Setup(x => x.Data).Returns(() => deserializer.Deserialize <List <Ticker> >(responseMock.Object));
return(responseMock.Object);
});
var client = new CoinMarketCapClient(httpClientMock.Object, 3);
var res = client.GetTicker();
Assert.IsNotNull(res);
res = client.GetTicker(FiatCurrency.EUR);
Assert.IsNotNull(res);
res = client.GetTicker(4, FiatCurrency.EUR);
Assert.IsNotNull(res);
}
/// <summary>
/// Gets price change last 24 hour.
/// </summary>
/// <param name="currency">Cryptocurrency name</param>
/// <returns></returns>
public static async Task <string> CoinMarketCapPriceLastDay(string currency)
{
// Get instance
var client = new CoinMarketCapClient();
// Get price change last day.
var ticker = await client.GetTickerAsync(currency);
return(ticker.PercentChange24h.Value.ToString());
}
/// <summary>
/// Gets the price of the currency that you supply.
/// </summary>
/// <param name="currency">Cryptocurrency name</param>
/// <returns></returns>
public static async Task <string> CoinMarketCapPrice(string currency)
{
// Get instance
var client = new CoinMarketCapClient();
// Get current price.
var ticker = await client.GetTickerAsync(currency);
return(ticker.PriceUsd.Value.ToString());
}
public CoinMarketCapClientTests()
{
this.httpClientFactoryMock = new Mock <IHttpClientFactory>();
this.errorLoggerMock = new Mock <IErrorLogger>();
this.coinMarketCapClient =
new CoinMarketCapClient(
this.httpClientFactoryMock.Object,
this.errorLoggerMock.Object);
this.errorLoggerMock.Setup(x => x.LogAsync(It.IsAny <string>())).Returns(Task.CompletedTask);
this.errorLoggerMock.Setup(x => x.LogAsync(It.IsAny <string>(), It.IsAny <Exception>())).Returns(Task.CompletedTask);
}
public async Task <JsonResult> ApiUpdatePriceForTicker(string listId)
{
try {
CoinMarketCapClient _client = new CoinMarketCapClient();
IDictionary <string, CyproPriceEntity> coinmaketresult = await _client.GetListPriceCyptoItemAsync(listId);
foreach (CyproPriceEntity Item in coinmaketresult.Values)
{
CyptoItemPriceViewModel objCyptoItemPrice = new CyptoItemPriceViewModel();
objCyptoItemPrice.id = Item.id;
objCyptoItemPrice.name = Item.name;
objCyptoItemPrice.symbol = Item.symbol;
objCyptoItemPrice.slug = Item.slug;
objCyptoItemPrice.CyptoItemPriceUpdate = DateTime.Now;
objCyptoItemPrice.is_active = true;
objCyptoItemPrice.cmc_rank = Item.cmc_rank;
objCyptoItemPrice.num_market_pairs = Item.num_market_pairs;
objCyptoItemPrice.circulating_supply = Item.circulating_supply;
objCyptoItemPrice.total_supply = Item.total_supply;
objCyptoItemPrice.max_supply = Item.max_supply ?? 0;
try
{
objCyptoItemPrice.last_updated = DateTime.Parse(Item.last_updated);
}
catch
{
objCyptoItemPrice.last_updated = DateTime.Now;
}
PriceEntity USD = Item.quote.Values.First();
objCyptoItemPrice.USD_price = USD.price;
objCyptoItemPrice.USD_volume_24h = USD.volume_24h;
objCyptoItemPrice.USD_percent_change_1h = USD.percent_change_1h;
objCyptoItemPrice.USD_percent_change_7d = USD.percent_change_7d;
objCyptoItemPrice.USD_market_cap = USD.market_cap;
CyptoItemPrice modelmain = objCyptoItemPrice._MainObj;
await cms_db.CreateCyptoItemPrice(objCyptoItemPrice._MainObj);
}
HttpContext.Application["LastTimePriceUpdate"] = DateTime.Now.ToString();
return(Json(coinmaketresult, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
cms_db.AddToExceptionLog("ApiUpdatePriceForTicker", "Member", e.ToString());
return(Json(e, JsonRequestBehavior.AllowGet));
}
}
private Interpreter CreateInterpreter(string text)
{
var connectionStringFactory = new TestConnectionStringFactory();
var currencyService = new CurrencyService(connectionStringFactory);
var lexer = new Lexer(text, currencyService);
var tokenQueueFactory = new TokenQueueFactory();
var parser = new Parser(lexer, tokenQueueFactory);
var coinMarketCapClient = new CoinMarketCapClient();
var fixerClient = new FixerClient();
var currencyConverter = new CurrencyConverter(coinMarketCapClient, fixerClient);
var currencyAmountTokenConverter = new TokenConverter(currencyConverter, currencyService, coinMarketCapClient, fixerClient);
return(new Interpreter(parser, currencyAmountTokenConverter));
}
/// <summary>
/// Adds coin sources to the <paramref name="services" />.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection" />.</param>
/// <param name="configurationRoot">Configuration</param>
/// <returns></returns>
public static IServiceCollection AddClients(this IServiceCollection services, IConfigurationRoot configurationRoot)
{
#if NOT_DEPRECATED
// currently returning errors
CoinMarketCapClient.Register(services);
#endif
BinanceClient.Register(services);
BittrexClient.Register(services);
GdaxClient.Register(services);
GateIoClient.Register(services);
KrakenClient.Register(services);
PoloniexClient.Register(services);
FunFairClientBase.Register(services: services,
configurationRoot.GetSection(key: "Sources:FunFair")
.Get <FunFairClientConfiguration>());
return(services);
}
static async Task <Dictionary <string, Dictionary <string, string> > > GetTickersAsync()
{
using (var response = await CoinMarketCapClient.GetAsync(Endpoint))
using (var content = response.Content)
{
var json = await content.ReadAsStringAsync();
var deserialized = JsonConvert
.DeserializeObject <IEnumerable <Dictionary <string, string> > >(json);
return(KeywordKeys
.Select(key => deserialized
.Select(coin => new KeyValuePair <string, Dictionary <string, string> >(
coin.FirstOrDefault(x => x.Key == key).Value.ToLower(),
coin)))
.SelectMany(x => x)
.GroupBy(x => x.Key)
.Select(x => x.FirstOrDefault())
.ToDictionary(x => x.Key, x => x.Value));
}
}
public async Task <IActionResult> Post(string cryptoName, [FromBody] StoreViewModel vm)
{
try
{
if (ModelState.IsValid)
{
var newStore = Mapper.Map <Store>(vm);
var client = new CoinMarketCapClient();
var result = await client.GetTickerAsync();
//if (!result)
//{
// _logger.LogError("Cant find it");
//}
//else
{
newStore.Price = result.Data.LastUpdated;
newStore.supply = result.Data.MaxSupply;
newStore.CryptoName = result.Data.Name;
_repositiry.AddStore(cryptoName, newStore, User.Identity.Name);
if (await _repositiry.SaveChangesAsync())
{
return(Created($"/api/Likes/{cryptoName}/Store/{newStore.CryptoName}",
Mapper.Map <StoreViewModel>(newStore)));
}
}
}
}
catch (Exception ex)
{
_logger.LogError("Failed to save new like: {0}", ex);
}
return(BadRequest("Failed"));
}
public ExchangeApiTests()
{
_coinMarketCapClient = new CoinMarketCapClient(new HttpClientHandler(), ApiEnvironment.Sandbox, "5bb4185b-ebb3-4cf7-942a-66a280f5db8b");
}
public void Initialize()
{
_client = new CoinMarketCapClient(Settings.Default.cmc_api_key);
}
public ClientInstancedTests()
{
_client = new CoinMarketCapClient();
}
public CoinMarketCapTests()
{
_client = CoinMarketCapClient.GetInstance();
}
public async static Task <List <CoinDetails> > GetTicker()
{
var Coins = new List <CoinDetails>();
var Client = CoinMarketCapClient.GetInstance();
var TickerList = await Client.GetTickerListAsync(1000);
TickerList.Reverse();
try
{
var Tasks = new List <Task <KeyValuePair <long, decimal> > >();
foreach (var Ticker in TickerList)
{
int?daysOld = null;
double?Vol = 0;
try
{
Vol = Ticker.Volume24hUsd.GetValueOrDefault();
}
catch { }
try
{
daysOld = GetCoinAgeInDays(Ticker.Symbol, Ticker.Id);
}
catch (Exception ex)
{
var E = ex;
Debug.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Debug.WriteLine(ex.InnerException.Message);
}
}
var Info = new CoinDetails()
{
AvailableSupply = Ticker.AvailableSupply.GetValueOrDefault(),
Id = Ticker.Id,
Name = Ticker.Name,
PercentChange1h = Ticker.PercentChange1h.GetValueOrDefault(),
PercentChange24h = Ticker.PercentChange24h.GetValueOrDefault(),
PercentChange7d = Ticker.PercentChange7d.GetValueOrDefault(),
PriceBtc = Ticker.PriceBtc,
Rank = Ticker.Rank,
Symbol = Ticker.Symbol,
TotalSupply = Ticker.TotalSupply.GetValueOrDefault(),
LastUpdatedUnixTime = Ticker.LastUpdatedUnixTime,
LastUpdated = Ticker.LastUpdated,
MarketCapUsd = Ticker.MarketCapUsd.GetValueOrDefault(),
MarketCapOther = Ticker.MarketCapOther.ToEntity(),
PriceOther = Ticker.PriceOther.ToEntity(),
PriceUsd = Ticker.PriceUsd,
Volume24hOther = Ticker.Volume24hOther.ToEntity(),
Volume24hUsd = Vol,
DaysOld = daysOld
};
Tasks.Add(GetATH(Ticker.Id));
Coins.Add(Info);
}
var Completed = await Task.WhenAll(Tasks);
for (var i = 0; i < Completed.Length; i++)
{
var ATH = Completed[i];
Coins[i].ATH = (float)ATH.Value;
Coins[i].LastATH = FromUnixTime(ATH.Key);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
if (ex.InnerException != null)
{
Debug.WriteLine(ex.InnerException.Message);
}
}
return(Coins);
}
private static async Task Main()
{
var apikey = ""; // <-- Your API Key here
//var apikey = System.IO.File.ReadAllLines($"{Environment.CurrentDirectory}\\ApiKey.txt")[0];
var client = new CoinMarketCapClient(ApiSchema.Sandbox, apikey);
var a = await client.GetCurrencyInfoAsync(new List <string> {
"BTC", "ETH", "LTC"
});
$"Full names of BTC, ETH and LTC codes: {string.Join(", ", a.Data.Select(x => x.Value.Name))}".ToConsoleNotify();
var b = await client.GetCurrencyInfoAsync(87);
$"Name of currency with id #87: {b.Data.FirstOrDefault().Value.Name}".ToConsoleNotify();
var c = await client.GetCurrencyMapAsync(new List <string> {
"BTC", "ETH", "ETC", "ZEC"
}, ParamListingStatus.Active, 1, 20);
$"Slug of BTC, ETH, ETC and ZEC: {string.Join(", ", c.Data.Select(x=>x.Slug))}".ToConsoleNotify();
//Not implemented by CoinMarketCap
//var d = await client.GetCurrencyListingsHistoricalAsync("2018-08-01");
//$"Coin with rank #9 on 01/08/2018: {d.Data.FirstOrDefault(x => x.CmcRank == 9)?.Name}".ToConsoleNotify();
var e = await client.GetCurrencyListingsAsync();
$"Coin with rank #9 now: {e.Data.FirstOrDefault(x => x.CmcRank == 9)?.Name}".ToConsoleNotify();
var f = await client.GetCurrencyMarketPairsAsync(2, limit : 5000);
$"Count of market pairs with coin {f.Data.Name}: {f.Data.NumMarketPairs}".ToConsoleNotify();
var g = await client.GetCurrencyMarketOHLCVHistoricalAsync(1, time_start : "2018-08-01", time_end : "2018-08-09",
convert : new List <string> {
Fiat.EUR.ToString()
});
$"BTC highest price in EUR between 01/08/2018 and 09/08/2018: {g.Data.Quotes.Select(z => z.Quote).Select(x => x.GetValueOrDefault("EUR")).Max(x => x.High)}".ToConsoleNotify();
var h = await client.GetCurrencyMarketQuotesHistoricalAsync(1, time_start : "2018-08-01", time_end : "2018-08-09");
$"BTC highest daily volume in USD between 01/08/2018 and 09/08/2018: {h.Data.Quotes.Select(z => z.Quote).Select(x => x.GetValueOrDefault("USD")).Max(x => x.Volume24h)}".ToConsoleNotify();
var j = await client.GetCurrencyMarketQuotesAsync(new List <int> {
1
});
$"BTC average price in USD: {j.Data.Values.Select(z=>z.Quote).Select(x=>x.GetValueOrDefault("USD")).FirstOrDefault()?.Price}".ToConsoleNotify();
var i = await client.GetExchangeInfoAsync(new List <string> {
"bittrex"
});
$"Bittrex twitter: {i.Data.Values.FirstOrDefault()?.Urls.Twitter.FirstOrDefault()}".ToConsoleNotify();
var k = await client.GetExchangeMapAsync();
$"Exchange with id #24: {k.Data.FirstOrDefault(x=>x.Id==24)?.Name}".ToConsoleNotify();
//"Not implemented by CoinMarketCap
//var l = await client.GetExchangeListingsHistoriacalAsync("2018-08-01", market_type: MarketType.All, limit:1);
//$"Top volume exchange on 01/08/2018: {l.}".ToConsoleNotify();
var m = await client.GetExchangeListingsAsync(limit : 100, market_type : MarketType.All);
$"Top volume exchange now: {m.Data.FirstOrDefault()?.Name}".ToConsoleNotify();
var n = await client.GetExchangeMarketPairsAsync(m.Data.First().Id);
$"Top pair of top market: {n.Data.MarketPairs.OrderByDescending(z=>z.Quote.Values.FirstOrDefault()?.Volume24hBase).FirstOrDefault()?.MarketPair}".ToConsoleNotify();
var o = await client.ExchangeMarketQuotesHistoricalAsync(270, "2018-08-01", "2018-08-09", interval : ParamInterval.D1);
$"Binance average daily volume on period between 01/08/2018 and 09/08/2018: {o.ExchangeMarketQuotesHistoricalData.Quotes.Average(z => z.Quote.Values.FirstOrDefault()?.Volume24h)}"
.ToConsoleNotify();
var p = await client.ExchangeMarketQuotesAsync(new List <int> {
270
});
$"Binance volume now: {p.Data.FirstOrDefault().Value.Quote.FirstOrDefault().Value.Volume24h}".ToConsoleNotify();
var q = await client.GlobalMetricsQuotesHistoricalAsync("2018-08-01", "2018-08-09");
$"Average BTC dominance on perid between 01/08/2018 and 09/08/2018: {q.Data.Quotes.Average(x=>x.BtcDominance)}".ToConsoleNotify();
var r = await client.GlobalMetricsQuotesAsync();
$"BTC dominance now: {r.Data.BtcDominance}".ToConsoleNotify();
var s = await client.ToolsPriceConversionAsync("ZEC", 1, convert : new List <string> {
"BTC"
});
$"1.0 ZEC = {s.Data.Quote.FirstOrDefault().Value.Price} BTC".ToConsoleNotify();
Console.ReadKey();
}
public TickerTests()
{
_client = CoinMarketCapClient.Instance;
}
public CoinMarketManagerController()
{
_client = CoinMarketCapClient.GetInstance();
// _client = new CoinMarketCapClient();
}
public CoinMarketCapService(ICoinMarketCapRepository coinMarketCapRepository)
{
_coinMarketCapRepository = coinMarketCapRepository;
_coinMarketCapClient = new CoinMarketCapClient(new HttpClientHandler(), ApiEnvironment.Pro, "c572865c-d03a-4be2-8cba-84c963e48869");
}
public CoinMarketCapClientTest()
{
this.client = new CoinMarketCapClient();
}
public void Initialize()
{
_client = new CoinMarketCapClient("your-api-key");
}
public void Setup()
{
var loggingMock = new Mock <ILogger <CoinMarketCapClient> >();
Client = new CoinMarketCapClient(new HttpClient(), new ServiceConfig(), loggingMock.Object);
}
