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}");
}
