public async Task TransactionReadOnlyExecutionServiceExtensions_Test() { var chain = await BlockchainService.GetChainAsync(); var context = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0], SmartContractAddressService.GetAddressByContractName(TokenSmartContractAddressNameProvider.Name), "GetBalance", new GetBalanceInput { Owner = SampleAddress.AddressList[0], Symbol = "ELF" }); var result = await TransactionReadOnlyExecutionService.ExecuteAsync <GetBalanceOutput>(context, transaction, TimestampHelper.GetUtcNow(), true); result.Balance.ShouldBe(0); result.Symbol.ShouldBe("ELF"); //without such method and call transaction.MethodName = "NotExist"; await Should.ThrowAsync <SmartContractExecutingException>(async() => { await TransactionReadOnlyExecutionService.ExecuteAsync <GetBalanceOutput>(context, transaction, TimestampHelper.GetUtcNow(), true); }); }
public async Task ParallelExecuteAsync_Test() { var chain = await BlockchainService.GetChainAsync(); (PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10); Block = OsTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, PrepareTransactions); //await BlockExecutingService.ExecuteBlockAsync(Block.Header, PrepareTransactions); await OsTestHelper.BroadcastTransactions(PrepareTransactions); Block = await MinerService.MineAsync(chain.BestChainHash, chain.BestChainHeight, TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromSeconds(4)); await BlockchainService.AddBlockAsync(Block); await BlockAttachService.AttachBlockAsync(Block); SystemTransactions = await OsTestHelper.GenerateTransferTransactions(1); CancellableTransactions = OsTestHelper.GenerateTransactionsWithoutConflict(KeyPairs); Block = OsTestHelper.GenerateBlock(Block.GetHash(), Block.Height, SystemTransactions.Concat(CancellableTransactions)); await OsTestHelper.BroadcastTransactions(SystemTransactions.Concat(CancellableTransactions)); var block = await BlockExecutingService.ExecuteBlockAsync(Block.Header, SystemTransactions, CancellableTransactions, CancellationToken.None); block.TransactionIds.Count().ShouldBeGreaterThan(10); }
public async Task RecordSideChainData() { var parentChainId = 123; var lockedToken = 10L; long parentChainHeightOfCreation = 10; var sideChainId = await InitAndCreateSideChainAsync(parentChainHeightOfCreation, parentChainId, lockedToken); var fakeSideChainBlockHash = Hash.FromString("sideChainBlockHash"); var fakeTxMerkleTreeRoot = Hash.FromString("txMerkleTreeRoot"); var sideChainBlockData = CreateSideChainBlockData(fakeSideChainBlockHash, 1, sideChainId, fakeTxMerkleTreeRoot); var crossChainBlockData = new CrossChainBlockData { SideChainBlockData = {sideChainBlockData} }; var indexingTx = await CrossChainContractStub.RecordCrossChainData.SendAsync(crossChainBlockData); Assert.True(indexingTx.TransactionResult.Status == TransactionResultStatus.Mined); var balance = await CrossChainContractStub.GetSideChainBalance.CallAsync(new SInt32Value {Value = sideChainId}); Assert.Equal(lockedToken - 1, balance.Value); var blockHeader = await BlockchainService.GetBestChainLastBlockHeaderAsync(); var indexedCrossChainBlockData = await CrossChainContractStub.GetIndexedCrossChainBlockDataByHeight.CallAsync(new SInt64Value {Value = blockHeader.Height}); Assert.Equal(crossChainBlockData, indexedCrossChainBlockData); }
public async Task <JObject> GetChainStatus() { var chain = await BlockchainService.GetChainAsync(); var branches = (JObject)JsonConvert.DeserializeObject(chain.Branches.ToString()); var formattedNotLinkedBlocks = new JArray(); foreach (var notLinkedBlock in chain.NotLinkedBlocks) { var block = await this.GetBlock(Hash.LoadBase64(notLinkedBlock.Value)); formattedNotLinkedBlocks.Add(new JObject { ["BlockHash"] = block.GetHash().ToHex(), ["Height"] = block.Height, ["PreviousBlockHash"] = block.Header.PreviousBlockHash.ToHex() } ); } return(new JObject { ["Branches"] = branches, ["NotLinkedBlocks"] = formattedNotLinkedBlocks, ["LongestChainHeight"] = chain.LongestChainHeight, ["LongestChainHash"] = chain.LongestChainHash?.ToHex(), ["GenesisBlockHash"] = chain.GenesisBlockHash.ToHex(), ["LastIrreversibleBlockHash"] = chain.LastIrreversibleBlockHash?.ToHex(), ["LastIrreversibleBlockHeight"] = chain.LastIrreversibleBlockHeight, ["BestChainHash"] = chain.BestChainHash?.ToHex(), ["BestChainHeight"] = chain.BestChainHeight }); }
public AccountController(MySQLContext context, BlockchainService service, IHostingEnvironment hostingEnvironment) { _context = context; _blockchainService = service; _hostingEnvironment = hostingEnvironment; }
public async Task IsViewTransactionAsync_Test() { var chain = await BlockchainService.GetChainAsync(); var context = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0], await SmartContractAddressService.GetAddressByContractNameAsync(context, TokenSmartContractAddressNameProvider.StringName), "GetBalance", new GetBalanceInput { Owner = SampleAddress.AddressList[0], Symbol = "ELF" }); var result = await TransactionReadOnlyExecutionService.IsViewTransactionAsync(context, transaction); result.ShouldBeTrue(); transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0], await SmartContractAddressService.GetAddressByContractNameAsync(context, TokenSmartContractAddressNameProvider.StringName), "Transfer", new TransferInput { To = SampleAddress.AddressList[1], Symbol = "ELF", Amount = 10 }); result = await TransactionReadOnlyExecutionService.IsViewTransactionAsync(context, transaction); result.ShouldBeFalse(); }
public MedicalController(MySQLContext context, BlockchainService service, IHostingEnvironment hostingEnvironment) { _context = context; _hostingEnvironment = hostingEnvironment; _blockchainService = service; _blockchainService.Initialize(); }
public virtual async Task ChoiceReceivedAsync(IDialogContext context, IAwaitable <string> activity) { string response = await activity; var service = new BlockchainService(); await service.SetRating(Constants.Ratings[response]); await context.PostAsync("Thank you. Is there anything else I can help you with?"); context.Done(true); }
public ConnectionHandler(IConnectionManager connectionManager, BlockchainService blockchain, ILogger <ConnectionHandler> logger) { Guard.NotNull(connectionManager, nameof(connectionManager)); Guard.NotNull(blockchain, nameof(blockchain)); Guard.NotNull(logger, nameof(logger)); _connectionManager = connectionManager; _blockchain = blockchain; _logger = logger; }
public async Task RecordSideChainData_WithChainNotExist() { int parentChainId = 123; long lockedToken = 10; long parentChainHeightOfCreation = 10; var sideChainId1 = await InitAndCreateSideChainAsync(parentChainHeightOfCreation, parentChainId, lockedToken); // create second side chain long lockedTokenAmount = 10; await ApproveBalanceAsync(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.Empty); var sideChainId2 = ChainHelper.GetChainId(2); await BlockMiningService.MineBlockAsync(new List<Transaction> { CrossChainContractStub.CreateSideChain.GetTransaction(sideChainCreationRequest) }, true); var fakeSideChainBlockHash = Hash.FromString("sideChainBlockHash"); var fakeTxMerkleTreeRoot = Hash.FromString("txMerkleTreeRoot"); var sideChainBlockData1 = CreateSideChainBlockData(fakeSideChainBlockHash, 1, sideChainId1, fakeTxMerkleTreeRoot); var sideChainBlockData2 = CreateSideChainBlockData(fakeSideChainBlockHash, 2, sideChainId2, fakeTxMerkleTreeRoot); int fakeChainId = 124; var sideChainBlockData3 = CreateSideChainBlockData(fakeSideChainBlockHash, 1, fakeChainId, fakeTxMerkleTreeRoot); var crossChainBlockData = new CrossChainBlockData { SideChainBlockData = {sideChainBlockData1, sideChainBlockData2, sideChainBlockData3} }; await BlockMiningService.MineBlockAsync(new List<Transaction> { CrossChainContractStub.RecordCrossChainData.GetTransaction(crossChainBlockData) }); var balance = await CrossChainContractStub.GetSideChainBalance.CallAsync(new SInt32Value {Value = sideChainId1}); Assert.Equal(lockedToken - 1, balance.Value); var blockHeader = await BlockchainService.GetBestChainLastBlockHeaderAsync(); var indexedCrossChainBlockData = await CrossChainContractStub.GetIndexedCrossChainBlockDataByHeight.CallAsync(new SInt64Value {Value = blockHeader.Height}); var expectedCrossChainBlocData = new CrossChainBlockData(); expectedCrossChainBlocData.SideChainBlockData.Add(sideChainBlockData1); Assert.Equal(expectedCrossChainBlocData, indexedCrossChainBlockData); }
public Task <JObject> GetChainInformation() { var map = SmartContractAddressService.GetSystemContractNameToAddressMapping(); var basicContractZero = SmartContractAddressService.GetZeroSmartContractAddress(); var response = new JObject { ["GenesisContractAddress"] = basicContractZero?.GetFormatted(), ["ChainId"] = ChainHelpers.ConvertChainIdToBase58(BlockchainService.GetChainId()) }; return(Task.FromResult(response)); }
public BlockchainController(IConfiguration config, ILogger <BlockchainController> logger, QueueSender queueSender, TransactionBroadcastManager transactionBroadcastManager, BlockchainService blockchainService) { this.config = config; this.logger = logger; this.queueSender = queueSender; this.transactionBroadcastManager = transactionBroadcastManager; this.blockchainService = blockchainService; }
public BlockchainController( ILogger <BlockchainController> logger, ApplicationDbContext context, BitcoinService bitcoin, BlockchainService blockchain, TickerService ticker) { _logger = logger; _context = context; _bitcoin = bitcoin; _blockchain = blockchain; _ticker = ticker; }
public async Task ExecuteAsync_Test() { var chain = await BlockchainService.GetChainAsync(); (PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10); Block = OsTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, PrepareTransactions); PrepareTransactions[0].To = SampleAccount.Accounts[0].Address; await OsTestHelper.BroadcastTransactions(PrepareTransactions); var executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto { Transactions = PrepareTransactions, BlockHeader = Block.Header }, CancellationToken.None); executionReturnSets.Count.ShouldBe(PrepareTransactions.Count); executionReturnSets.Count(set => set.TransactionResult.Status == TransactionResultStatus.Failed) .ShouldBe(1); executionReturnSets.First(set => set.TransactionResult.Status == TransactionResultStatus.Failed).TransactionResult.Error.ShouldBe("Invalid contract address."); executionReturnSets.Count(set => set.TransactionResult.Status == TransactionResultStatus.Mined).ShouldBe(9); (PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10); Block = OsTestHelper.GenerateBlock(Block.GetHash(), Block.Height, PrepareTransactions); await OsTestHelper.BroadcastTransactions(PrepareTransactions); var cancelTokenSource = new CancellationTokenSource(); cancelTokenSource.Cancel(); executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto { Transactions = PrepareTransactions, BlockHeader = Block.Header }, cancelTokenSource.Token); executionReturnSets.Count.ShouldBe(0); (PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10); Block = OsTestHelper.GenerateBlock(Block.GetHash(), Block.Height, PrepareTransactions); _systemTransactionExtraDataProvider.SetSystemTransactionCount(1, Block.Header); executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto { Transactions = PrepareTransactions, BlockHeader = Block.Header }, CancellationToken.None); executionReturnSets.Count.ShouldBe(PrepareTransactions.Count); executionReturnSets.ShouldAllBe(set => set.TransactionResult.Status == TransactionResultStatus.Mined); }
public async Task GetFileDescriptorsAsync_Test() { var chain = await BlockchainService.GetChainAsync(); var context = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var tokenAddress = SmartContractAddressService.GetAddressByContractName(TokenSmartContractAddressNameProvider.Name); var fileDescriptor = (await TransactionReadOnlyExecutionService.GetFileDescriptorsAsync(context, tokenAddress)).ToList(); fileDescriptor.Count.ShouldBeGreaterThan(0); fileDescriptor.ShouldAllBe(o => o.Name.Contains("proto")); }
public async Task HandleEventAsync(BlockMinedEventData eventData) { if (eventData?.BlockHeader == null) { Logger.LogWarning("Block header is null, cannot broadcast."); return; } var blockWithTransactions = await BlockchainService.GetBlockWithTransactionsByHash(eventData.BlockHeader.GetHash()); if (blockWithTransactions == null) { Logger.LogWarning($"Could not find {eventData.BlockHeader.GetHash()}."); return; } var _ = NetworkService.BroadcastBlockWithTransactionsAsync(blockWithTransactions); }
public async Task TokenFeeProviderBase_Calculate_Test() { var genesisBlock = KernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>()); var chain = await BlockchainService.CreateChainAsync(genesisBlock, new List <Transaction>()); var blockStateSet = new BlockStateSet { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet); var functionMap = GenerateFunctionMap(); await _calculateFunctionProvider.AddCalculateFunctions(new BlockIndex { BlockHash = blockStateSet.BlockHash, BlockHeight = blockStateSet.BlockHeight }, functionMap); var transaction = new Transaction { Params = new SInt64Value { Value = 100 }.ToByteString() }; var transactionContext = new TransactionContext { Transaction = transaction }; var size = transaction.Size(); var chainContext = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var sizeFee = await _primaryTokenFeeProvider.CalculateFeeAsync(transactionContext, chainContext); var feeCalculatedByCoefficients = GetFeeForTx(size); sizeFee.ShouldBe(feeCalculatedByCoefficients); }
public async Task CalculateFunctionMap_Test() { var genesisBlock = KernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>()); var chain = await BlockchainService.CreateChainAsync(genesisBlock, new List <Transaction>()); var blockStateSet = new BlockStateSet { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet); var functionMapDict = new Dictionary <string, Dictionary <string, CalculateFunction> >(); var functionMap = GenerateFunctionMap(); functionMapDict.Add(GetBlockExecutedDataKey(), functionMap); await _calculateFunctionExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex { BlockHash = blockStateSet.BlockHash, BlockHeight = blockStateSet.BlockHeight }, functionMapDict); var newBlockStateSet = await BlockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash); newBlockStateSet.BlockHash.ShouldBe(blockStateSet.BlockHash); newBlockStateSet.BlockHeight.ShouldBe(blockStateSet.BlockHeight); newBlockStateSet.BlockExecutedData.Count.ShouldBe(1); newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(AllCalculateFeeCoefficients).Name)); blockStateSet = await AddBlockStateSetAsync(blockStateSet); CheckBlockExecutedData(blockStateSet, functionMap); await BlockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash); CheckBlockExecutedData(blockStateSet, functionMap); blockStateSet = await AddBlockStateSetAsync(blockStateSet); CheckBlockExecutedData(blockStateSet, functionMap); }
public async Task GetTransactionParametersAsync_Test() { var chain = await BlockchainService.GetChainAsync(); var context = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var transaction = await OsTestHelper.GenerateTransferTransaction(); var jsonResult = await TransactionReadOnlyExecutionService.GetTransactionParametersAsync(context, transaction); jsonResult.ShouldNotBeEmpty(); jsonResult.ShouldContain("to"); jsonResult.ShouldContain("symbol"); jsonResult.ShouldContain("amount"); }
public async Task MineWithTxHubAsync() { var txCount = 0; var preBlockHash = _chain.BestChainHash; var preBlockHeight = _chain.BestChainHeight; while (txCount < TransactionCount) { var blockExecutedSet = await _minerService.MineAsync(preBlockHash, preBlockHeight, TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromMilliseconds(4000)); txCount += blockExecutedSet.TransactionIds.Count(); _transactionIdList.AddRange(blockExecutedSet.TransactionIds.ToList()); await BlockchainService.SetBestChainAsync(_chain, preBlockHeight, preBlockHash); await TransactionPoolService.CleanByTransactionIdsAsync(blockExecutedSet.TransactionIds); await TransactionPoolService.UpdateTransactionPoolByBestChainAsync(preBlockHash, preBlockHeight); } }
public async Task CalculateFunctionMap_Test() { var genesisBlock = KernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>()); var chain = await BlockchainService.CreateChainAsync(genesisBlock, new List <Transaction>()); var blockStateSet = new BlockStateSet { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet); var blockExecutedDataKey = "BlockExecutedData/AllCalculateFeeCoefficients"; blockStateSet.BlockExecutedData.ShouldNotContainKey(blockExecutedDataKey); var functionMap = GenerateFunctionMap(); await _calculateFunctionProvider.AddCalculateFunctions(new BlockIndex { BlockHash = blockStateSet.BlockHash, BlockHeight = blockStateSet.BlockHeight }, functionMap); var newBlockStateSet = await BlockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash); newBlockStateSet.BlockHash.ShouldBe(blockStateSet.BlockHash); newBlockStateSet.BlockHeight.ShouldBe(blockStateSet.BlockHeight); newBlockStateSet.BlockExecutedData.Count.ShouldBe(1); newBlockStateSet.BlockExecutedData.ShouldContainKey(blockExecutedDataKey); blockStateSet = await AddBlockStateSetAsync(blockStateSet); CheckBlockExecutedData(blockStateSet, functionMap); await BlockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash); CheckBlockExecutedData(blockStateSet, functionMap); blockStateSet = await AddBlockStateSetAsync(blockStateSet); CheckBlockExecutedData(blockStateSet, functionMap); }
protected override void OnStart(string[] args) { Task.Factory.StartNew(() => { while (!_isStopped) { using (var localAccountService = new AccountService()) { if (!localAccountService.UpdateData()) { Thread.Sleep(1000 * 60 * 1); } else { Thread.Sleep(1000 * 60 * 10); } } } }); Task.Factory.StartNew(() => { while (!_isStopped) { using (var localAccountService = new AccountService()) { var localBlockchainService = new BlockchainService(localAccountService); if (!localBlockchainService.UpdateData()) { Thread.Sleep(1000 * 60 / 6); } else { Thread.Sleep(1000 * 60); } } } }); }
private async Task <ItemData> GetItemData(string id) { var service = new BlockchainService(); return(await service.GetItemData(id)); }
internal async Task <Hash> AEDPoSContract_GetRandomNumber_Test() { var order = await AEDPoSContract_RequestRandomNumber_Test(); var currentRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty()); var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount) .Select(i => Hash.FromString($"random{i}")).ToList(); var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i => new AElfConsensusTriggerInformation { Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey), RandomHash = randomHashes[i] }).ToDictionary(t => t.Pubkey.ToHex(), t => t); // Exactly one round except extra block time slot. foreach (var minerInRound in currentRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order)) { var currentKeyPair = InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey); KeyPairProvider.SetKeyPair(currentKeyPair); BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime); var stub = GetAEDPoSContractStub(currentKeyPair); var headerInformation = (await stub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey] .ToBytesValue())).ToConsensusHeaderInformation(); // Update consensus information. var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey); await stub.UpdateValue.SendAsync(toUpdate); { var chain = await BlockchainService.GetChainAsync(); if (chain.BestChainHeight < order.BlockHeight) { // Not enough. var transactionResult = (await AEDPoSContractStub.GetRandomNumber.SendAsync(order.TokenHash)) .TransactionResult; transactionResult.Error.ShouldContain("Still preparing random number."); } } for (var i = 0; i < 7; i++) { await stub.UpdateTinyBlockInformation.SendAsync(new TinyBlockInput { ActualMiningTime = TimestampHelper.GetUtcNow(), RoundId = currentRound.RoundId }); } } // Now it's enough. { var randomNumber = (await AEDPoSContractStub.GetRandomNumber.SendAsync(order.TokenHash)).Output; randomNumber.Value.ShouldNotBeEmpty(); } return(order.TokenHash); }
public DonateController(BlockchainService blockchainService) { _blockchainService = blockchainService; }
public BlockchainProposalsController(BlockchainService blockchainService) { this.BlockchainService = blockchainService ?? throw new ArgumentNullException(nameof(blockchainService)); }
public async Task GlobalSetup() { await InitializeChainAsync(); _chain = await BlockchainService.GetChainAsync(); }
public DisbandForm(int myTeammateId) { _accountService = new AccountService(); _me = _accountService.GetTeammate(myTeammateId); _curAddress = _me.BtcAddressCurrent; _prevAddress = _me.BtcAddressPrevious; _user = _accountService.GetUser(); InitializeComponent(); _textBoxAuxAddress.Text = _accountService.GetAuxWallet(_me.Team.Network).ToString(); _textBoxAddressTo.Text = _me.CurDisbanding.WithdrawAddr; UpdateStatuses(); UpdateWithdrawalControls(); UpdateCosignerOfControls(); Task.Factory.StartNew(() => { if (!_accountService.Closed) // todo: change it to separate contexts { var blockchainService = new BlockchainService(_accountService); blockchainService.TryFetchAuxWalletUtxos(true, _me.Team.Network); if (!_closing) { try { this.Invoke((MethodInvoker) delegate() { UpdateStatuses(); }); } catch (Exception ex) { Logger.WriteException(ex); } } } }); Task.Factory.StartNew(() => { if (!_accountService.Closed) // todo: change it to separate contexts { var blockchainService = new BlockchainService(_accountService); if (_curAddress != null) { _amountSatoshisCurent = blockchainService.FetchBalance(_curAddress); } if (_prevAddress != null) { _amountSatoshisPrevious = blockchainService.FetchBalance(_prevAddress); } if (!_closing) { try { this.Invoke((MethodInvoker) delegate() { UpdateWithdrawalControls(); }); } catch (Exception ex) { Logger.WriteException(ex); } } } }); }
public HomeController(BlockchainService service) { _blockchainService = service; _blockchainService.Initialize(); }
public SmartContractController(MySQLContext context, BlockchainService service) { _context = context; _blockchainService = service; }