protected override async Task ExecuteAsync() { var trustKeys = await _nexusQuery.GetTrustKeys(); var keyCache = await _redisCommand.GetAsync <List <TrustKeyDto> >(Settings.Redis.TrustKeyCache) ?? new List <TrustKeyDto>(); var keyAddressCache = await _redisCommand.GetAsync <List <AddressLiteDto> >(Settings.Redis.TrustKeyAddressCache) ?? new List <AddressLiteDto>(); var expiredKeys = keyCache .Where(x => trustKeys.All(y => y.TrustKey != x.TrustKey)) .ToList(); await RemoveExpiredKeysAsync(expiredKeys, keyCache); await AddOrUpdateTrustKeysAsync(trustKeys, keyCache); var newKeyAddressCache = await AddOrUpdateTrustKeyAddressCache(keyCache, keyAddressCache); await _redisCommand.SetAsync(Settings.Redis.TrustKeyCache, keyCache); await _redisCommand.SetAsync(Settings.Redis.TrustKeyAddressCache, newKeyAddressCache); Logger.LogInformation($"Trust keys updated {trustKeys.Count} and expired {expiredKeys.Count}"); }
private async Task SyncBlocks(int syncedHeight, int saveCount) { var streamCount = await _redisCommand.GetAsync <int>(Settings.Redis.BlockSyncStreamCacheHeight); while (streamCount < syncedHeight + saveCount) { await Task.Delay(TimeSpan.FromSeconds(1)); streamCount = await _redisCommand.GetAsync <int>(Settings.Redis.BlockSyncStreamCacheHeight); } _allowProgressUpdate = false; var nexusBlocks = new List <BlockDto>(); Console.WriteLine($"\nSyncing blocks from height {(syncedHeight + 1):N0} - {(syncedHeight + saveCount):N0}..."); for (var i = syncedHeight + 1; i <= syncedHeight + saveCount; i++) { nexusBlocks.Add(await _redisCommand.GetAsync <BlockDto>(CreateStreamKey(i))); } Console.WriteLine("Sync complete. Performing sync save..."); await _blockInsert.InsertBlocksAsync(nexusBlocks); foreach (var nexusBlock in nexusBlocks) { await _redisCommand.DeleteAsync(CreateStreamKey(nexusBlock.Height)); } _streamCount -= nexusBlocks.Count; }
public async Task <IActionResult> Index() { var vm = new MiningViewModel { ChartDurationMs = ChartDurationMs, ChannelStats = await CreateRecentChannelStatsAsync(), SuppyRates = await _redisCommand.GetAsync <SupplyRateDto>(Settings.Redis.SupplyRatesLatest) }; return(View(vm)); }
public async Task <IActionResult> Index() { var viemModel = new NetworkViewModel { PeerInfoDtos = await _redisCommand.GetAsync <List <PeerInfoDto> >(Settings.Redis.PeerInfoLatest) }; return(View(viemModel)); }
public async Task <List <BlockDto> > GetAsync() { var chainHeight = await _redisCommand.GetAsync <int>(Settings.Redis.ChainHeight); var blocks = new List <BlockDto>(); if (chainHeight == 0) { return(blocks); } for (var i = chainHeight; i > chainHeight - Settings.App.BlockCacheSize; i--) { blocks.Add(await _redisCommand.GetAsync <BlockDto>(Settings.Redis.BuildBlockCacheKey(i))); } return(blocks); }
public async Task <IActionResult> GetChannelStats() { var channelStats = await _statQuery.GetChannelStatsAsync(); var supplyRate = await _redis.GetAsync <SupplyRateDto>(Settings.Redis.SupplyRatesLatest); if (channelStats == null) { return(NotFound("There were no stats found")); } return(Ok(new ChainStats { TotalHeight = channelStats.Sum(x => x.Height), TotalSupply = supplyRate.MoneySupply, Channels = channelStats })); }
protected override async Task ExecuteAsync() { var sw = new Stopwatch(); sw.Start(); var miningInfo = await _nexusQuery.GetMiningInfoAsync(); var recentMiningInfos = await _redisCommand.GetAsync <List <MiningInfoDto> >(Settings.Redis.MiningInfo10Mins) ?? new List <MiningInfoDto>(); if (recentMiningInfos.All(x => x.CreatedOn != miningInfo.CreatedOn)) { recentMiningInfos.Add(miningInfo); recentMiningInfos.RemoveAll(x => x.CreatedOn < DateTime.UtcNow.AddMinutes(-10)); await _redisCommand.SetAsync(Settings.Redis.MiningInfo10Mins, recentMiningInfos); } await _redisCommand.SetAsync(Settings.Redis.MiningInfoLatest, miningInfo); sw.Stop(); Logger.LogInformation($"Mining info sync completed in {sw.Elapsed:c}"); }
public async Task <int> GetTransactionCountLastDay() { return(await _redisCommand.GetAsync <int>(Settings.Redis.TransactionCount24Hours)); }
public async Task <JsonResult> GetLatestTimeStampUtc() { return(Json(await _redisCommand.GetAsync <DateTime>(Settings.Redis.TimestampUtcLatest)));; }
public async Task <string> GetLatestAddressStats() { return(Helpers.JsonSerialise(await _redisCommand.GetAsync <AddressStatDto>(Settings.Redis.AddressStatPubSub))); }
public async Task <int> GetBlockCountLastDay() { return(await _redisCommand.GetAsync <int>(Settings.Redis.BlockCount24Hours)); }
public async Task <List <ChannelStatDto> > GetChannelStatsAsync() { const string sqlQ = @"SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED SELECT b.Channel, COUNT(*) AS Height FROM Block b GROUP BY b.Channel"; using (var sqlCon = await DbConnectionFactory.GetNexusDbConnectionAsync()) { var channelResult = (await sqlCon.QueryAsync(sqlQ)).ToList(); var miningInfo = await _redisCommand.GetAsync <MiningInfoDto>(Settings.Redis.MiningInfoLatest); if (miningInfo == null) { return(null); } var channelStatTasks = channelResult .Select(async x => { var channel = (BlockChannels)x.Channel; double diff = 0; double reward = 0; long rateSec = 0; double reserve = 0; switch (channel) { case BlockChannels.PoS: var lastPosBlock = await _blockQuery.GetLastBlockAsync(channel); diff = lastPosBlock.Difficulty; reward = lastPosBlock.Mint; break; case BlockChannels.Prime: diff = miningInfo.PrimeDifficulty; reward = miningInfo.PrimeValue; rateSec = miningInfo.PrimesPerSecond; reserve = miningInfo.PrimeReserve; break; case BlockChannels.Hash: diff = miningInfo.HashDifficulty; reward = miningInfo.HashValue; rateSec = miningInfo.HashPerSecond; reserve = miningInfo.HashReserve; break; } return(new ChannelStatDto { Channel = ((BlockChannels)x.Channel).ToString(), Height = (int)x.Height + await _blockQuery.GetChannelHeightAsync((BlockChannels)x.Channel), Difficulty = diff, Reward = reward, RatePerSecond = rateSec, Reserve = reserve, CreatedOn = miningInfo.CreatedOn }); }); return((await Task.WhenAll(channelStatTasks)).ToList()); } }
public async Task <BittrexSummaryDto> GetLatestBittrexSummaryAsync() { return(await _redis.GetAsync <BittrexSummaryDto>(Settings.Redis.BittrexSummaryPubSub)); }
public async Task <TrustKeyDto> GetAddressTrustKey(string addressHash) { var truskKeyCache = await _redisCommand.GetAsync <List <TrustKeyDto> >(Settings.Redis.TrustKeyCache); return(truskKeyCache.FirstOrDefault(x => x.AddressHash == addressHash)); }
public Task <DateTime> GetLatestTimestampUtc() { return(_redisCommand.GetAsync <DateTime>(Settings.Redis.TimestampUtcLatest)); }
public async Task <double> GetLatestBTCPriceInUSDAsync() { return(await _redis.GetAsync <double>(Settings.Redis.BittrexLastUsdBtcPrice)); }
protected override async Task ExecuteAsync() { var sw = new Stopwatch(); sw.Start(); Logger.LogInformation("Updating address stats..."); var dormantThreshold = await _blockQuery.GetBlockAsync(DateTime.Now.AddYears(-1)); var addressStats = await _redisCommand.GetAsync <AddressStatDto>(Settings.Redis.AddressStatPubSub) ?? new AddressStatDto(); addressStats.AddressCount = await _addressQuery.GetUniqueAddressCountAsync(); addressStats.CreatedPerHour = await _addressQuery.GetAddressesCreatedLastHourAsync(); addressStats.ZeroBalance = (int)(await _addressQuery.GetCountFilteredAsync(new AddressFilterCriteria { MaxBalance = 0 })); var stakeableAddresses = await _addressQuery.GetAddressLitesFilteredAsync(new AddressFilterCriteria { OrderBy = OrderAddressesBy.HighestBalance, MinBalance = StakeThreshold }, 0, int.MaxValue, false); addressStats.BalanceOverOneThousand = stakeableAddresses.Results.Count; var oldAddresses = await _addressQuery.GetAddressLitesFilteredAsync(new AddressFilterCriteria { OrderBy = OrderAddressesBy.MostRecentlyActive, MinBalance = 0.00000001d, HeightTo = dormantThreshold.Height }, 0, int.MaxValue, false); addressStats.DormantOverOneYear = oldAddresses.Results.Count; var stakingAddresses = await _addressQuery.GetAddressLitesFilteredAsync(new AddressFilterCriteria { IsStaking = true }, 0, int.MaxValue, false); addressStats.StakingCount = stakingAddresses.Results.Count; addressStats.TotalStakedCoins = Math.Round(stakingAddresses.Results.Sum(x => x.Balance), 8); addressStats.AverageBalance = await _addressQuery.GetAverageBalanceAsync(false); var distributionBands = Enum.GetValues(typeof(AddressBalanceDistributionBands)) .Cast <AddressBalanceDistributionBands>() .ToList(); var distributionBalances = new List <double>(); var distributionCounts = new List <int>(); var supplyInfo = await _nexusQuery.GetSupplyRate(); var distributionDtos = new List <AddressDistrubtionBandDto>(); foreach (var distributionBand in distributionBands) { var bandFilter = GetDistrubutionBands(distributionBand); var addCount = (int)(await _addressQuery.GetCountFilteredAsync(bandFilter)); var coinBalance = await _addressQuery.GetBalanceSumFilteredAsync(bandFilter); distributionDtos.Add(new AddressDistrubtionBandDto { DistributionBand = distributionBand, AddressCount = addCount, AddressPercent = (addCount / (double)(addressStats.AddressCount - addressStats.ZeroBalance)) * 100, CoinBalance = coinBalance, CoinPercent = (coinBalance / supplyInfo.MoneySupply) * 100 }); } await _redisCommand.SetAsync(Settings.Redis.AddressDistributionStats, distributionDtos); await _redisCommand.SetAsync(Settings.Redis.AddressStatPubSub, addressStats); await _redisCommand.PublishAsync(Settings.Redis.AddressStatPubSub, addressStats); Logger.LogInformation($"Updated address stats in {sw.Elapsed:g}"); }