public void Monitor()
{
try
{
foreach (var coin in _exchange.Coins)
{
foreach (var childCoin in coin.Coins)
{
try
{
var ticker = _apiService.Get <ResponseDto <List <TickerDto> > >(_apiService.PublicUrl, $"/getticker?market={coin.Symbol}_{childCoin.Symbol}").result.First();
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(ticker).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Bleutrade, coin.Symbol, childCoin.Symbol, pricingItem);
}
catch (Exception e)
{
//Colorful.Console.WriteLine(e, Color.Red);
}
Task.Delay(500).Wait();
}
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Bleutrade Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
var eligibleSymbols = _exchange.Coins.Select(m => m.Symbol)
.Union(_exchange.Coins.SelectMany(m => m.Coins).Select(m => m.Symbol)).Distinct().ToList();
var eligibleCombinedSymbols = new List <SymbolDto>();
foreach (var symbol1 in eligibleSymbols)
{
foreach (var symbol2 in eligibleSymbols.Where(m => m != symbol1))
{
eligibleCombinedSymbols.Add(new SymbolDto($"{symbol1}{symbol2}", symbol1, symbol2));
}
}
var tickers = _apiService.Get <ResponseDto <List <TickerDto> > >(_apiService.PublicUrl, "/LiveTickers").tickers;
tickers = tickers.Where(m => eligibleCombinedSymbols.Select(n => n.Combined).Contains(m.currencyPair)).ToList();
foreach (var ticker in tickers)
{
var symbolDto = eligibleCombinedSymbols.FirstOrDefault(m => m.Combined == ticker.currencyPair);
if (symbolDto != null)
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(ticker).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.TrustDex, symbolDto.From, symbolDto.To, pricingItem);
}
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Gatecoin Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
var tickers = _apiService.Get <Dictionary <string, TickerDto> >(_apiService.PublicUrl, "/ticker");
foreach (var ticker in tickers)
{
ticker.Value.from_symbol = ticker.Key.Split("_")[0];
ticker.Value.to_symbol = ticker.Key.Split("_")[1];
}
var products = tickers.Select(m => m.Value).ToList();
var validProducts = products.Where(m =>
!SymbolConstants.FiatCurrency.Contains(m.from_symbol) &&
!SymbolConstants.FiatCurrency.Contains(m.to_symbol)).ToList();
foreach (var product in validProducts)
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(product).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Exmo, product.from_symbol, product.to_symbol, pricingItem);
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Exmo Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
var eligibleSymbols = _exchange.Coins.Select(m => m.Symbol)
.Union(_exchange.Coins.SelectMany(m => m.Coins).Select(m => m.Symbol)).Distinct().ToList();
var response = _apiService.Get <JArray>(_apiService.PublicUrl, "/return_ticket.php");
var tickers = new BuilderFactory().CreateCollection <JToken, TickerDto>(response).Build();
tickers = tickers.Where(m =>
m.active &&
eligibleSymbols.Contains(m.fromSymbol) &&
eligibleSymbols.Contains(m.toSymbol) &&
!SymbolConstants.FiatCurrency.Contains(m.fromSymbol) &&
!SymbolConstants.FiatCurrency.Contains(m.toSymbol)).ToList();
foreach (var ticker in tickers)
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(ticker).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.TrustDex, ticker.fromSymbol,
ticker.toSymbol, pricingItem);
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"TrustDex Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
//try
//{
// var socket = new ClientWebSocket();
// var task = socket.ConnectAsync(new Uri("wss://api.poloniex.com"), CancellationToken.None);
// task.Wait();
// var readThread = new Thread(() => MessageRecived(socket)) { IsBackground = true };
// readThread.Start();
// var json = "{\"type\":\"subscribe\",\"channels\":[{\"name\":\"ticker\", \"product_ids\": [" + BuildProductIdString() + "]}]}";
// var bytes = Encoding.UTF8.GetBytes(json);
// var subscriptionMessageBuffer = new ArraySegment<byte>(bytes);
// socket.SendAsync(subscriptionMessageBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
//}
//catch (Exception ex)
//{
//}
//while (true)
//{
// Thread.Sleep(60000);
//foreach (var coin in _exchange.Coins)
//{
// foreach (var childCoin in coin.Coins)
// {
// }
//}
//}
//PricingService.Instance.GetCurrentPrice(_exchange.Name, coin.Symbol, childCoin.Symbol);
try
{
var response = _apiService.Get <Dictionary <string, TickerDto> >(_apiService.PublicUrl, "?command=returnTicker");
foreach (var key in response.Keys)
{
response[key].FromSymbol = key.Split("_")[1];
response[key].ToSymbol = key.Split("_")[0];
}
var products = response.Values.Where(m => m.IsFrozenBool == false).ToList();
foreach (var product in products)
{
if (product != null)
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(product).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Poloniex, product.FromSymbol, product.ToSymbol, pricingItem);
}
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Poloniex Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
private string BuildProductIdString()
{
var ids = new List <string>();
var products = _apiService.Get <List <ProductDto> >(_apiService.PublicUrl, "/products");
foreach (var product in products.Where(m => !m.Id.Contains("-GBP") && !m.Id.Contains("-EUR")))
{
ids.Add(product.Id);
}
return(string.Join(",", ids.Select(m => $"\"{m}\"")));
}
public void Monitor()
{
try
{
var markets = _apiService.Get <Dictionary <string, MarketDto> >(_apiService.PublicUrl, "/").Select(m => m.Value).ToList();
foreach (var market in markets)
{
var pricingItem = _builderFactory.Create <MarketDto, PricingItem>(market).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.BXinth, market.secondary_currency, market.primary_currency, pricingItem);
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"BXinth Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
//Should probably also use the getticker endpoint as the data is not cached as long and more up-to-date.
var response = _apiService.Get <ResponseDto <List <MarketSummaryDto> > >(_apiService.PublicUrl, "/public/getmarketsummaries");
var products = response.Result.OrderByDescending(m => m.BaseVolume).ThenByDescending(m => m.Volume).ToList();
foreach (var product in products)
{
var pricingItem = _builderFactory.Create <MarketSummaryDto, PricingItem>(product).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.BitTrex, product.MarketCurrency, product.BaseCurrency, pricingItem);
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Bittrex Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
foreach (var coin in _exchange.Coins)
{
foreach (var childCoin in coin.Coins)
{
var ticker = _apiService.Get <TickerDto>(_apiService.PublicUrl, $"/v1/pubticker/{coin.Symbol.ToLower()}{childCoin.Symbol.ToLower()}");
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(ticker).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Gemini, coin.Symbol, childCoin.Symbol, pricingItem);
}
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Gemini Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
foreach (var coin in _exchange.Coins)
{
foreach (var childCoin in coin.Coins)
{
var product = _apiService.Get <TickerDto>(_apiService.PublicUrl, $"/products/{coin.Symbol}-{childCoin.Symbol}/ticker");
if (product != null)
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(product).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Abucoins, coin.Symbol, childCoin.Symbol, pricingItem);
}
}
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Abucoins Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
var response = _apiService.Get <List <TickerDto> >(_apiService.PublicUrl, "/tickers");
var symbolList = _exchange.Coins.Select(n => n.Symbol)
.Union(_exchange.Coins.SelectMany(n => n.Coins).Select(n => n.Symbol)).ToList();
var products = response
.OrderByDescending(m => m.Volume24Hour)
.Where(m =>
symbolList.Contains(m.FromSymbol) &&
symbolList.Contains(m.ToSymbol)).ToList();
foreach (var product in products)
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(product).Build();
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.WavesDex, product.FromSymbol, product.ToSymbol, pricingItem);
}
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"WavesDex Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
