public IntegrationInfo( BlockchainInfo blockchain, IReadOnlyDictionary <string, DependencyInfo> dependencies) { Blockchain = blockchain ?? throw new ArgumentNullException(nameof(blockchain)); Dependencies = dependencies ?? throw new ArgumentNullException(nameof(dependencies)); }
public async Task Get_integration_info() { //ARRANGE var blockchainInfo = new BlockchainInfo(123, DateTime.UtcNow); var dependencies = new Dictionary <DependencyName, DependencyInfo>() { { "dependency", new DependencyInfo(new Semver("1.0.0"), new Semver("1.0.0")) } }; var client = PrepareClient <AppSettings>((options) => { var aggregator = CreateMocksAndSetupFactories(options); options.IntegrationName = $"{nameof(TransactionExecutorClientTests)}+{nameof(Get_integration_info)}"; aggregator.BlockchainInfoProvider.Setup(x => x.GetInfoAsync()).ReturnsAsync(blockchainInfo); aggregator.DependenciesInfoProvider.Setup(x => x.GetInfoAsync()).ReturnsAsync(dependencies); aggregator.HealthProvider.Setup(x => x.GetDiseaseAsync()).ReturnsAsync(Disease); }); //ACT var result = await client.GetIntegrationInfoAsync(); //ASSERT var(dependencyName, dependencyInfo) = dependencies.First(); Assert.True(result != null); Assert.True(result.Blockchain.LatestBlockMoment == blockchainInfo.LatestBlockMoment); Assert.True(result.Blockchain.LatestBlockNumber == blockchainInfo.LatestBlockNumber); Assert.True(result.Dependencies[dependencyName].LatestAvailableVersion.Equals(dependencyInfo.LatestAvailableVersion)); Assert.True(result.Dependencies[dependencyName].RunningVersion.Equals(dependencyInfo.RunningVersion)); }
public void GetBlockchainInfo() { HttpProvider client = new HttpProvider("https://api.zilliqa.com/"); BlockchainInfo blockchainInfo = client.GetBlockchainInfo().Result; Assert.IsNotNull(blockchainInfo); }
public SyncInfo(BlockchainInfo bcinfo) { Guard.NotNull(nameof(bcinfo), bcinfo); BlockCount = (int)bcinfo.Blocks; int headerCount = (int)bcinfo.Headers; BlockchainInfoUpdated = DateTimeOffset.UtcNow; IsCoreSynchornized = BlockCount == headerCount; }
public BlockchainInfo GetBlockchainInfo() { var info = new BlockchainInfo("B-Chain", "MainNode"); info.Difficulty = appSettings.Difficulty; info.Peers = dbService.GetPeers().Count; info.PendingTransactions = dbService.GetTransactions().Count; info.Blocks = dbService.GetAllBlocks().Count; return(info); }
private async Task DownloadBlockchainAsync(long startId) { var webInfo = await LicensorClient.Instance.GetBlockchainInfoAsync().ConfigureAwait(false); BlockchainDataRestorer dataRestorer = new BlockchainDataRestorer(); try { BlockchainInfo ownInfo = await BlockchainReadService.GetBlockchainInformationAsync().ConfigureAwait(false); List <BlockVm> newBlocks = default; for (long i = startId; i < webInfo.Count; i += 100) { if (webInfo.Count - ownInfo.Count > 100) { newBlocks = await LicensorClient.Instance.GetBlockchainBlocksAsync(i, i + 100).ConfigureAwait(false); } else { newBlocks = await LicensorClient.Instance.GetBlockchainBlocksAsync(ownInfo.Count, webInfo.Count).ConfigureAwait(false); } if (newBlocks != null) { foreach (BlockVm block in newBlocks) { using (BlockchainDbContext context = new BlockchainDbContext()) { try { await context.Blocks.AddAsync(BlockBuilder.GetBlock(block)).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); await dataRestorer.SaveBlockDataAsync(block).ConfigureAwait(false); } catch (Exception ex) { Logger.WriteLog(ex); } } } } } } catch (Exception ex) { Logger.WriteLog(ex); } }
public async Task HandleAsync() { try { BlockchainInfo info = await BlockchainReadService.GetBlockchainInformationAsync().ConfigureAwait(false); BlockchainInfoNodeResponse response = new BlockchainInfoNodeResponse(request.RequestId, info); NodeWebSocketCommunicationManager.SendResponse(response, current); } catch (Exception ex) { Logger.WriteLog(ex); NodeWebSocketCommunicationManager.SendResponse(new ResultNodeResponse(request.RequestId, ErrorCode.UnknownError), current); } }
public async Task CheckAndSyncBlockchainAsync() { var startBlockId = await CommonBlockchainPartSearchAsync().ConfigureAwait(false); BlockchainInfo blockchainInfo = await BlockchainReadService.GetBlockchainInformationAsync().ConfigureAwait(false); var webInfo = await LicensorClient.Instance.GetBlockchainInfoAsync().ConfigureAwait(false); if (startBlockId < blockchainInfo.Count) { await SaveAndRemoveOldBlocksAsync(startBlockId).ConfigureAwait(false); await DownloadBlockchainAsync(startBlockId).ConfigureAwait(false); await RestoreOldBlockchainDataAsync().ConfigureAwait(false); } else if (startBlockId < webInfo.Count) { await DownloadBlockchainAsync(startBlockId).ConfigureAwait(false); } }
private async void GetBalance() { Status = "Updating Balances..."; Errors = string.Empty; IsReceiving = true; BalanceApi api = null; switch (SettingsInstance.SelectedBalanceApi) { case BalanceServiceNames.BlockchainInfo: api = new BlockchainInfo(); break; case BalanceServiceNames.BlockExplorer: api = new BlockExplorer(); break; default: api = new BlockchainInfo(); break; } Response resp = await api.UpdateBalancesAsync(AddressList.ToList()); if (resp.Errors.Any()) { Errors = resp.Errors.GetErrors(); Status = "Encountered an error!"; } else { DataManager.WriteFile(AddressList, DataManager.FileType.Wallet); RaisePropertyChanged("BitcoinBalance"); Status = "Balance Update Success!"; } IsReceiving = false; }
private async Task <long> CommonBlockchainPartSearchAsync() { using (WebClient webClient = new WebClient()) { BlockchainInfo blockchainInfo = await BlockchainReadService.GetBlockchainInformationAsync().ConfigureAwait(false); long blockId = -1; long tempBlockId = blockchainInfo.BlockHashes.Min(opt => opt.FirstValue); byte[] responseData = await webClient.UploadDataTaskAsync( $"https://{NodeSettings.Configs.LicensorUrl}/api/Blockchain/FindMatch", ObjectSerializer.ObjectToByteArray(blockchainInfo)).ConfigureAwait(false); blockId = BitConverter.ToInt64(responseData); while (blockId == -1) { blockchainInfo = await BlockchainReadService.GetBlockchainInformationAsync(tempBlockId).ConfigureAwait(false); if (!blockchainInfo.BlockHashes.Any()) { return(1); } if (blockchainInfo.BlockHashes.Min(opt => opt.FirstValue) == 1) { return(1); } responseData = await webClient.UploadDataTaskAsync( $"https://{NodeSettings.Configs.LicensorUrl}/api/Blockchain/FindMatch", ObjectSerializer.ObjectToByteArray(blockchainInfo)).ConfigureAwait(false); blockId = BitConverter.ToInt64(responseData); tempBlockId = blockchainInfo.BlockHashes.Min(opt => opt.FirstValue); } if (blockId != -1) { return(blockId); } return(1); } }
public async Task <ActionResult> Restore([FromForm] BlockchainRestoreModel model) { BlockchainInfo blockchainInfo = await BlockchainReadService.GetBlockchainInformationAsync().ConfigureAwait(false); if (model.Start == null) { model.Start = blockchainInfo.FirstBlockTime; } if (model.End == null) { model.End = blockchainInfo.LastBlockTime; } if (model.End < model.Start) { return(BadRequest()); } List <BlockVm> blocks = await BlockchainReadService.GetBlocksAsync( model.Start.GetValueOrDefault().ToUnixTime(), model.End.GetValueOrDefault().ToUnixTime(), BLOCKS_LIMIT).ConfigureAwait(false); while (blocks.Count == BLOCKS_LIMIT && blocks.LastOrDefault().Header.CreationTime < model.End.GetValueOrDefault().ToUnixTime()) { foreach (var block in blocks) { await _blockchainDataRestorer.SaveBlockDataAsync(block).ConfigureAwait(false); } blocks = await BlockchainReadService.GetBlocksAsync( blocks.LastOrDefault().Header.CreationTime, null, BLOCKS_LIMIT).ConfigureAwait(false); } return(RedirectToAction("Index", "Configuration")); }
private static void Init() { var builder = new ConfigurationBuilder() .AddJsonFile($"appsettings.json", true, true) .AddEnvironmentVariables(); IConfigurationRoot Configuration = builder.Build(); // Retrieve configuration from sections Settings.ConnectionString = Configuration.GetSection("ConnectionString")?.Value; Settings.DatabaseId = Configuration.GetSection("DatabaseId")?.Value; Settings.ContractCollection = Configuration.GetSection("ContractCollection")?.Value; Settings.RabbitMQUsername = Configuration.GetSection("RabbitMQUsername")?.Value; Settings.RabbitMQPassword = Configuration.GetSection("RabbitMQPassword")?.Value; Settings.RabbitMQHostname = Configuration.GetSection("RabbitMQHostname")?.Value; Settings.RabbitMQPort = Convert.ToInt16(Configuration.GetSection("RabbitMQPort")?.Value); Settings.ContractDeploymentQueueName = Configuration.GetSection("ContractDeploymentQueueName")?.Value; Settings.KeyVaultCertificateName = Configuration.GetSection("KeyVaultCertificateName")?.Value; Settings.KeyVaultClientId = Configuration.GetSection("KeyVaultClientId")?.Value; Settings.KeyVaultClientSecret = Configuration.GetSection("KeyVaultClientSecret")?.Value; Settings.KeyVaultIdentifier = Configuration.GetSection("KeyVaultIdentifier")?.Value; Settings.KeyVaultEncryptionKey = Configuration.GetSection("KeyVaultEncryptionKey")?.Value; Settings.BlockchainRPCUrl = Configuration.GetSection("BlockchainRPCUrl")?.Value; Settings.BlockchainMasterAddress = Configuration.GetSection("BlockchainMasterAddress")?.Value; Settings.BlockchainMasterPrivateKey = Configuration.GetSection("BlockchainMasterPrivateKey")?.Value; Settings.BlockchainContractABI = Configuration.GetSection("BlockchainContractABI")?.Value; Settings.BlockchainContractByteCode = Configuration.GetSection("BlockchainContractByteCode")?.Value; mongoDBConnectionInfo = new MongoDBConnectionInfo() { ConnectionString = Settings.ConnectionString, DatabaseId = Settings.DatabaseId, ContractCollection = Settings.ContractCollection }; keyVaultConnectionInfo = new KeyVaultConnectionInfo() { CertificateName = Settings.KeyVaultCertificateName, ClientId = Settings.KeyVaultClientId, ClientSecret = Settings.KeyVaultClientSecret, KeyVaultIdentifier = Settings.KeyVaultIdentifier }; blockchainInfo = new BlockchainInfo() { RPCUrl = Settings.BlockchainRPCUrl, MasterAddress = Settings.BlockchainMasterAddress, MasterPrivateKey = Settings.BlockchainMasterPrivateKey, ContractABI = Settings.BlockchainContractABI, ContractByteCode = Settings.BlockchainContractByteCode }; using (KeyVaultHelper keyVaultHelper = new KeyVaultHelper(keyVaultConnectionInfo)) { secret = keyVaultHelper.GetVaultKeyAsync(Settings.KeyVaultEncryptionKey).Result; } account = new Account(blockchainInfo.MasterPrivateKey); web3 = new Web3(account, new RpcClient(new Uri(blockchainInfo.RPCUrl), null, null, new HttpClientHandler() { MaxConnectionsPerServer = 10, UseProxy = false })); }
public BlockchainInfoNodeResponse(long requestId, BlockchainInfo information) { Information = information; RequestId = requestId; ResponseType = NodeResponseType.BlockchainInfo; }
private async void GetBalance() { if (!AddressList.ToList().TrueForAll(x => !x.HasErrors)) { Errors = "Fix the errors in addresses first!"; return; } Status = "Updating Balances..."; Errors = string.Empty; IsReceiving = true; BalanceApi api = null; switch (SettingsInstance.SelectedBalanceApi) { case BalanceServiceNames.BlockchainInfo: api = new BlockchainInfo(); break; case BalanceServiceNames.BlockExplorer: api = new BlockExplorer(); break; case BalanceServiceNames.BlockCypher: api = new BlockCypher(); break; case BalanceServiceNames.Blockonomics: api = new Blockonomics(); break; default: api = new BlockchainInfo(); break; } // Not all exchanges support Bech32 addresses! // The following "if" is to solve that. bool hasSegWit = AddressList.Any(x => x.Address.StartsWith("bc1", System.StringComparison.InvariantCultureIgnoreCase)); if (hasSegWit && !SettingsInstance.SelectedBalanceApi.Equals(BalanceServiceNames.Blockonomics)) { BalanceApi segApi = new Blockonomics(); List <BitcoinAddress> legacyAddrs = new List <BitcoinAddress>(AddressList.Where(x => !x.Address.StartsWith("bc1", System.StringComparison.OrdinalIgnoreCase))); List <BitcoinAddress> segWitAddrs = new List <BitcoinAddress>(AddressList.Where(x => x.Address.StartsWith("bc1", System.StringComparison.OrdinalIgnoreCase))); Response respSW = await segApi.UpdateBalancesAsync(segWitAddrs); if (respSW.Errors.Any()) { Errors = "SegWit API error: " + respSW.Errors.GetErrors(); Status = "Error in SegWit API! Continue updating legacy balances..."; } Response resp = await api.UpdateBalancesAsync(legacyAddrs); if (resp.Errors.Any()) { Errors = resp.Errors.GetErrors(); Status = "Encountered an error!"; } else { DataManager.WriteFile(AddressList, DataManager.FileType.Wallet); RaisePropertyChanged("BitcoinBalance"); Status = "Balance Update Success!"; } } else { Response resp = await api.UpdateBalancesAsync(AddressList.ToList()); if (resp.Errors.Any()) { Errors = resp.Errors.GetErrors(); Status = "Encountered an error!"; } else { DataManager.WriteFile(AddressList, DataManager.FileType.Wallet); RaisePropertyChanged("BitcoinBalance"); Status = "Balance Update Success!"; } } IsReceiving = false; }