public async Task <List <Transaction> > GenerateTransferFromTransactionsWithoutConflictWithMultiSenderAsync(List <ECKeyPair> keyPairs, int count = 1) { var transactions = new List <Transaction>(); foreach (var keyPair in keyPairs) { var from = Address.FromPublicKey(keyPair.PublicKey); for (var i = 0; i < count; i++) { var to = CryptoHelper.GenerateKeyPair(); var transaction = GenerateTransaction(from, await _smartContractAddressService.GetAddressByContractNameAsync(await GetChainContextAsync(), TokenSmartContractAddressNameProvider.StringName), nameof(TokenContractContainer.TokenContractStub.TransferFrom), new TransferFromInput { From = from, To = Address.FromPublicKey(to.PublicKey), Amount = 1, Symbol = "ELF" }); var signature = CryptoHelper.SignWithPrivateKey(keyPair.PrivateKey, transaction.GetHash().ToByteArray()); transaction.Signature = ByteString.CopyFrom(signature); transactions.Add(transaction); } } return(transactions); }
public async Task SmartContractAddress_Set_And_Get_Test() { var chain = await _smartContractHelper.CreateChainWithGenesisContractAsync(); var chainContext = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var address = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TestSmartContractAddressNameProvider.StringName); address.ShouldBeNull(); var dto = await _smartContractAddressService.GetSmartContractAddressAsync(chainContext, TestSmartContractAddressNameProvider.StringName); dto.ShouldBeNull(); dto = await _smartContractAddressService.GetSmartContractAddressAsync(chainContext, ZeroSmartContractAddressNameProvider.StringName); dto.SmartContractAddress.Address.ShouldBe(_smartContractAddressService.GetZeroSmartContractAddress()); dto.Irreversible.ShouldBeFalse(); address = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, ZeroSmartContractAddressNameProvider.StringName); address.ShouldBe(_smartContractAddressService.GetZeroSmartContractAddress()); await _smartContractAddressService.SetSmartContractAddressAsync(chainContext, TestSmartContractAddressNameProvider.StringName, SampleAddress.AddressList[0]); address = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TestSmartContractAddressNameProvider.StringName); address.ShouldBe(SampleAddress.AddressList[0]); var smartContractAddressDto = await _smartContractAddressService.GetSmartContractAddressAsync(chainContext, TestSmartContractAddressNameProvider.StringName); smartContractAddressDto.SmartContractAddress.ShouldBe(new SmartContractAddress { Address = SampleAddress.AddressList[0], BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }); smartContractAddressDto.Irreversible.ShouldBeTrue(); var map = await _smartContractAddressService.GetSystemContractNameToAddressMappingAsync(chainContext); map.Count.ShouldBe(2); map[ZeroSmartContractAddressNameProvider.Name].ShouldBe(_smartContractAddressService.GetZeroSmartContractAddress()); map[TestSmartContractAddressNameProvider.Name].ShouldBe(SampleAddress.AddressList[0]); }
/// <summary> /// Compare /// </summary> /// <param name="block"></param> /// <returns></returns> public async Task <bool> ValidateBlockAfterExecuteAsync(IBlock block) { if (block.Header.Height == AElfConstants.GenesisBlockHeight) { return(true); } var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Header.Height }, TokenSmartContractAddressNameProvider.StringName); if (tokenContractAddress == null) { return(true); } var hashFromState = await _contractReaderFactory.Create(new ContractReaderContext { BlockHash = block.GetHash(), BlockHeight = block.Header.Height, ContractAddress = tokenContractAddress }).GetLatestTotalResourceTokensMapsHash.CallAsync(new Empty()); var totalResourceTokensMapsFromProvider = await _totalResourceTokensMapsProvider.GetTotalResourceTokensMapsAsync(new ChainContext { BlockHash = block.Header.PreviousBlockHash, BlockHeight = block.Header.Height - 1 }); if (hashFromState.Value.IsEmpty) { // If hash from state is empty, data from provider must be null. return(totalResourceTokensMapsFromProvider == null); } if (hashFromState == HashHelper.ComputeFrom(new TotalResourceTokensMaps { BlockHash = block.Header.PreviousBlockHash, BlockHeight = block.Header.Height - 1 })) { if (totalResourceTokensMapsFromProvider == null) { return(true); } return(totalResourceTokensMapsFromProvider.BlockHeight != block.Header.Height - 1); } if (totalResourceTokensMapsFromProvider == null) { return(false); } var hashFromProvider = HashHelper.ComputeFrom(totalResourceTokensMapsFromProvider); return(hashFromState == hashFromProvider); }
public async Task <Transaction> GenerateTransactionAsync(Hash contractName, string methodName, ByteString param) { var pubkey = await _accountService.GetPublicKeyAsync(); var chain = await _blockchainService.GetChainAsync(); var address = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, contractName.ToStorageKey()); var transaction = new Transaction { From = Address.FromPublicKey(pubkey), To = address, MethodName = methodName, Params = param, RefBlockNumber = chain.BestChainHeight, RefBlockPrefix = ByteString.CopyFrom(chain.BestChainHash.Value.Take(4).ToArray()) }; //Logger.LogDebug($"[Boilerplate]Generated test tx: {transaction}. tx id: {transaction.GetHash()}"); return(transaction); }
public async Task <List <Transaction> > GenerateTransactionsAsync(Address @from, long preBlockHeight, Hash preBlockHash) { var transactions = new List <Transaction>(); var transaction = new Transaction { From = _addressWithoutToken, To = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = preBlockHash, BlockHeight = preBlockHeight }, TokenSmartContractAddressNameProvider.StringName), MethodName = nameof(TokenContractImplContainer.TokenContractImplStub.Transfer), Params = new TransferInput { Amount = 1000, Memo = "transfer test", Symbol = "ELF", To = SampleAddress.AddressList[0] } .ToByteString(), RefBlockNumber = preBlockHeight, RefBlockPrefix = ByteString.CopyFrom(preBlockHash.Value.Take(4).ToArray()) }; transactions.Add(transaction); return(transactions); }
public async Task <Transaction> GenerateTransferTransactionAsync() { var chain = await BlockchainService.GetChainAsync(); var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, TokenSmartContractAddressNameProvider.StringName); var getBalanceInput = new GetBalanceInput { Owner = Address.FromPublicKey(CryptoHelper.GenerateKeyPair().PublicKey), Symbol = _nativeSymbol }; var transaction = new Transaction { From = await _accountService.GetAccountAsync(), To = tokenContractAddress, MethodName = nameof(TokenContractContainer.TokenContractStub.GetBalance), Params = getBalanceInput.ToByteString(), RefBlockNumber = chain.BestChainHeight, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(chain.BestChainHash) }; var sig = await _accountService.SignAsync(transaction.GetHash().ToByteArray()); transaction.Signature = ByteString.CopyFrom(sig); return(transaction); }
public async Task <IEnumerable <Transaction> > GetPostTransactionsAsync( IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext) { if (!IsTargetAcsSymbol(descriptors)) { return(new List <Transaction>()); } var chainContext = new ChainContext { BlockHash = transactionContext.PreviousBlockHash, BlockHeight = transactionContext.BlockHeight - 1 }; // Generate token contract stub. var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TokenSmartContractAddressNameProvider.StringName); if (tokenContractAddress == null) { return(new List <Transaction>()); } var tokenStub = _contractReaderFactory.Create(new ContractReaderContext { ContractAddress = tokenContractAddress, Sender = transactionContext.Transaction.To }); if (transactionContext.Transaction.To == tokenContractAddress && transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeResourceToken)) { return(new List <Transaction>()); } if (transactionContext.Transaction.MethodName == nameof(ResourceConsumptionContractContainer .ResourceConsumptionContractStub.BuyResourceToken)) { return(new List <Transaction>()); } var chargeResourceTokenInput = new ChargeResourceTokenInput { Caller = transactionContext.Transaction.From }; var feeCalculationResult = await _resourceTokenFeeService.CalculateFeeAsync(transactionContext, chainContext); chargeResourceTokenInput.CostDic.Add(feeCalculationResult); var chargeResourceTokenTransaction = tokenStub.ChargeResourceToken.GetTransaction(chargeResourceTokenInput); return(new List <Transaction> { chargeResourceTokenTransaction }); }
public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync( IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext) { if (!IsTargetAcsSymbol(descriptors)) { return(new List <Transaction>()); } var thresholdSettingStub = _thresholdSettingContractReaderFactory.Create(new ContractReaderContext { BlockHash = transactionContext.PreviousBlockHash, BlockHeight = transactionContext.BlockHeight - 1, ContractAddress = transactionContext.Transaction.To, Sender = transactionContext.Transaction.To, Timestamp = transactionContext.CurrentBlockTime, StateCache = transactionContext.StateCache }); var threshold = await thresholdSettingStub.GetMethodCallingThreshold.CallAsync(new StringValue { Value = transactionContext.Transaction.MethodName }); // Generate token contract stub. var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = transactionContext.PreviousBlockHash, BlockHeight = transactionContext.BlockHeight - 1 }, TokenSmartContractAddressNameProvider.StringName); if (tokenContractAddress == null) { return(new List <Transaction>()); } var tokenStub = _tokenContractReaderFactory.Create(new ContractReaderContext { Sender = transactionContext.Transaction.To, ContractAddress = tokenContractAddress }); if (transactionContext.Transaction.To == tokenContractAddress && transactionContext.Transaction.MethodName == nameof(tokenStub.CheckThreshold)) { return(new List <Transaction>()); } var checkThresholdTransaction = tokenStub.CheckThreshold.GetTransaction(new CheckThresholdInput { Sender = transactionContext.Transaction.From, SymbolToThreshold = { threshold.SymbolToAmount }, IsCheckAllowance = threshold.ThresholdCheckType == ThresholdCheckType.Allowance }); return(new List <Transaction> { checkThresholdTransaction }); }
public async Task <Transaction> GenerateTransferTransaction() { var newUserKeyPair = CryptoHelper.GenerateKeyPair(); var accountAddress = await _accountService.GetAccountAsync(); var transaction = GenerateTransaction(accountAddress, await _smartContractAddressService.GetAddressByContractNameAsync(await GetChainContextAsync(), TokenSmartContractAddressNameProvider.StringName), nameof(TokenContractContainer.TokenContractStub.Transfer), new TransferInput { To = Address.FromPublicKey(newUserKeyPair.PublicKey), Amount = 10, Symbol = "ELF" }); var signature = await _accountService.SignAsync(transaction.GetHash().ToByteArray()); transaction.Signature = ByteString.CopyFrom(signature); return(transaction); }
public async Task <List <Transaction> > GenerateTransactionsAsync(Address @from, long preBlockHeight, Hash preBlockHash) { var generatedTransactions = new List <Transaction>(); var chainContext = new ChainContext { BlockHash = preBlockHash, BlockHeight = preBlockHeight }; var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TokenSmartContractAddressNameProvider.StringName); if (tokenContractAddress == null) { return(generatedTransactions); } var totalResourceTokensMaps = await _totalResourceTokensMapsProvider.GetTotalResourceTokensMapsAsync( chainContext); ByteString input; if (totalResourceTokensMaps != null && totalResourceTokensMaps.BlockHeight == preBlockHeight && totalResourceTokensMaps.BlockHash == preBlockHash) { // If totalResourceTokensMaps match current block. input = totalResourceTokensMaps.ToByteString(); } else { input = new TotalResourceTokensMaps { BlockHash = preBlockHash, BlockHeight = preBlockHeight }.ToByteString(); } generatedTransactions.AddRange(new List <Transaction> { new Transaction { From = from, MethodName = nameof(TokenContractImplContainer.TokenContractImplStub.DonateResourceToken), To = tokenContractAddress, RefBlockNumber = preBlockHeight, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(preBlockHash), Params = input } }); Logger.LogTrace("Tx DonateResourceToken generated."); return(generatedTransactions); }
private async Task ProcessCodeUpdateAsync(Chain chain) { var chainContext = new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }; var address = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, ConfigurationSmartContractAddressNameProvider.StringName); var transaction = new Transaction { From = _smartContractAddressService.GetZeroSmartContractAddress(), To = _smartContractAddressService.GetZeroSmartContractAddress(), MethodName = nameof(ACS0Container.ACS0Stub.UpdateSmartContract), Params = new ContractUpdateInput { Code = ByteString.CopyFrom( _smartContractExecutionHelper.ContractCodes["AElf.Contracts.MultiToken"]), Address = address }.ToByteString() }; var blockExecutedSet = await _smartContractExecutionHelper.ExecuteTransactionAsync(transaction, chain); var interestedEvent = await _codeUpdatedLogEventProcessor.GetInterestedEventAsync(chainContext); foreach (var transactionResult in blockExecutedSet.TransactionResultMap.Values) { var logEvent = transactionResult.Logs.First(l => l.Address == interestedEvent.LogEvent.Address && l.Name == interestedEvent.LogEvent.Name); var codeUpdated = new CodeUpdated(); codeUpdated.MergeFrom(logEvent); var smartContractRegistration = await _smartContractRegistrationProvider.GetSmartContractRegistrationAsync(chainContext, codeUpdated.Address); await _codeUpdatedLogEventProcessor.ProcessAsync(blockExecutedSet.Block, new Dictionary <TransactionResult, List <LogEvent> > { { transactionResult, new List <LogEvent> { logEvent } } }); chainContext = new ChainContext { BlockHash = blockExecutedSet.Block.GetHash(), BlockHeight = blockExecutedSet.Block.Height }; var updatedSmartContractRegistration = await _smartContractRegistrationProvider.GetSmartContractRegistrationAsync(chainContext, codeUpdated.Address); updatedSmartContractRegistration.ShouldNotBe(smartContractRegistration); updatedSmartContractRegistration.Code.ShouldBe(ByteString.CopyFrom( _smartContractExecutionHelper.ContractCodes["AElf.Contracts.MultiToken"])); } }
private async Task <bool> TryDiscoverIndexedSideChainBlockDataAsync(IBlock block) { var crossChainContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Header.Height }, CrossChainSmartContractAddressNameProvider.StringName); return(new SideChainBlockDataIndexed().ToLogEvent(crossChainContractAddress).GetBloom() .IsIn(new Bloom(block.Header.Bloom.ToByteArray()))); }
public async Task <List <Transaction> > GenerateTransactionsAsync(Address @from, long preBlockHeight, Hash preBlockHash) { var generatedTransactions = new List <Transaction>(); if (preBlockHeight < AElfConstants.GenesisBlockHeight) { return(generatedTransactions); } var chainContext = new ChainContext { BlockHash = preBlockHash, BlockHeight = preBlockHeight }; var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TokenSmartContractAddressNameProvider.StringName); if (tokenContractAddress == null) { return(generatedTransactions); } var totalTxFeesMap = await _totalTransactionFeesMapProvider.GetTotalTransactionFeesMapAsync(chainContext); if (totalTxFeesMap == null || !totalTxFeesMap.Value.Any() || totalTxFeesMap.BlockHeight != preBlockHeight || totalTxFeesMap.BlockHash != preBlockHash) { Logger.LogDebug( "Won't generate ClaimTransactionFees because no tx fee charged in previous block."); // If previous block doesn't contain logEvent named TransactionFeeCharged, won't generate this tx. return(new List <Transaction>()); } generatedTransactions.AddRange(new List <Transaction> { new Transaction { From = from, MethodName = nameof(TokenContractImplContainer.TokenContractImplStub.ClaimTransactionFees), To = tokenContractAddress, RefBlockNumber = preBlockHeight, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(preBlockHash), Params = totalTxFeesMap.ToByteString() } }); Logger.LogTrace("Tx ClaimTransactionFees generated."); return(generatedTransactions); }
public async Task SentTransaction_Token_Check_Test() { //user without token - NotExisted { var keyPair = CryptoHelper.GenerateKeyPair(); var tokenAddress = await _smartContractAddressService.GetAddressByContractNameAsync(await _osTestHelper.GetChainContextAsync(), TokenSmartContractAddressNameProvider.StringName); //approve transaction var transaction = await GenerateTransaction(keyPair, tokenAddress, "Approve", new ApproveInput { Amount = 100, Spender = Address.FromPublicKey(CryptoHelper.GenerateKeyPair().PublicKey), // TODO: valid symbol needed for a test case not related to token symbol Symbol = "Check user without token whether can sent transaction" }); var transactionId = await SendTransactionAsync(transaction); var transactionResult = await QueryTransactionResultAsync(transactionId); Enum.TryParse <TransactionResultStatus>(transactionResult.Status, true, out var status); status.ShouldBe(TransactionResultStatus.Failed); } //bp user with token - Mined { var transaction = await _osTestHelper.GenerateTransferTransaction(); var transactionId = await SendTransactionAsync(transaction); var transactionResult = await QueryTransactionResultAsync(transactionId); Enum.TryParse <TransactionResultStatus>(transactionResult.Status, true, out var status); status.ShouldBe(TransactionResultStatus.Mined); } }
public async Task <List <Transaction> > GenerateTransactionsAsync(Address from, long preBlockHeight, Hash preBlockHash) { var generatedTransactions = new List <Transaction>(); var chainContext = new ChainContext { BlockHash = preBlockHash, BlockHeight = preBlockHeight }; if (!_transactionPackingOptionProvider.IsTransactionPackable(chainContext)) { return(generatedTransactions); } var parliamentContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync( chainContext, ParliamentSmartContractAddressNameProvider.StringName); if (parliamentContractAddress == null) { return(generatedTransactions); } var proposalIdList = await _proposalService.GetNotApprovedProposalIdListAsync(from, preBlockHash, preBlockHeight); if (proposalIdList == null || proposalIdList.Count == 0) { return(generatedTransactions); } var generatedTransaction = new Transaction { From = from, MethodName = nameof(ParliamentContractContainer.ParliamentContractStub.ApproveMultiProposals), To = parliamentContractAddress, RefBlockNumber = preBlockHeight, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(preBlockHash), Params = new ProposalIdList { ProposalIds = { proposalIdList } }.ToByteString() }; generatedTransactions.Add(generatedTransaction); Logger.LogTrace("Proposal approval transaction generated."); return(generatedTransactions); }
public async Task <ContractReaderContext> GetContractReaderContextAsync(IChainContext chainContext) { var timestamp = _blockTimeProvider.GetBlockTime(); var sender = Address.FromPublicKey(await _accountService.GetPublicKeyAsync()); var consensusContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync( chainContext, ConsensusSmartContractAddressNameProvider.StringName); return(new ContractReaderContext { BlockHash = chainContext.BlockHash, BlockHeight = chainContext.BlockHeight, ContractAddress = consensusContractAddress, Sender = sender, Timestamp = timestamp }); }
public async Task <ByteString> GetConfigurationDataAsync(string configurationName, ChainContext chainContext) { var indexedSideChainBlockData = await _contractReaderFactory .Create(new ContractReaderContext { BlockHash = chainContext.BlockHash, BlockHeight = chainContext.BlockHeight, ContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, ConfigurationSmartContractAddressNameProvider.StringName) }) .GetConfiguration.CallAsync(new StringValue() { Value = configurationName }); return(indexedSideChainBlockData.Value); }
/// <summary> /// Compare /// </summary> /// <param name="block"></param> /// <returns></returns> public async Task <bool> ValidateBlockAfterExecuteAsync(IBlock block) { var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Header.Height }, TokenSmartContractAddressNameProvider.StringName); if (tokenContractAddress == null) { return(true); } var hashFromState = await _contractReaderFactory.Create(new ContractReaderContext { BlockHash = block.GetHash(), BlockHeight = block.Header.Height, ContractAddress = tokenContractAddress }).GetLatestTotalTransactionFeesMapHash.CallAsync(new Empty()); var totalTransactionFeesMapFromProvider = await _totalTransactionFeesMapProvider.GetTotalTransactionFeesMapAsync(new ChainContext { BlockHash = block.Header.PreviousBlockHash, BlockHeight = block.Header.Height - 1 }); if (totalTransactionFeesMapFromProvider == null) { Logger.LogDebug("totalTransactionFeesMapFromProvider == null"); return(hashFromState.Value.IsEmpty); } var hashFromProvider = HashHelper.ComputeFrom(totalTransactionFeesMapFromProvider); var result = hashFromProvider == hashFromState; if (!result) { Logger.LogDebug($"Hash from provider: {hashFromProvider}\nHash from state: {hashFromState}"); } return(result); }
/// <summary> /// Create a txn with provided data. /// </summary> /// <param name="from"></param> /// <param name="methodName"></param> /// <param name="blockIndex"></param> /// <param name="bytes"></param> /// <returns></returns> private async Task <Transaction> GenerateNotSignedTransactionAsync(Address from, string methodName, IBlockIndex blockIndex, ByteString bytes) { var address = await _smartContractAddressService.GetAddressByContractNameAsync( new ChainContext { BlockHash = blockIndex.BlockHash, BlockHeight = blockIndex.BlockHeight }, CrossChainSmartContractAddressNameProvider.StringName); return(new Transaction { From = from, To = address, RefBlockNumber = blockIndex.BlockHeight, RefBlockPrefix = ByteString.CopyFrom(blockIndex.BlockHash.Value.Take(4).ToArray()), MethodName = methodName, Params = bytes, }); }
public async Task <IEnumerable <Transaction> > GetPostTransactionsAsync( IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext) { return(transactionContext.Transaction.To == await _smartContractAddressService.GetAddressByContractNameAsync(new ChainContext { BlockHash = transactionContext.PreviousBlockHash, BlockHeight = transactionContext.BlockHeight - 1, StateCache = transactionContext.StateCache }, ConsensusSmartContractAddressNameProvider.StringName) && new List <string> { "FirstRound", "UpdateValue", "UpdateTinyBlockInformation", "NextRound", "NextTerm" } .Contains(transactionContext.Transaction.MethodName) ? await _transactionListProvider.GetTransactionListAsync() : new List <Transaction>()); }
public Task <Address> GetAddressByContractNameAsync(IChainContext chainContext, string contractName) { return(_smartContractAddressService.GetAddressByContractNameAsync(chainContext, contractName)); }
private Task <Address> GetParliamentContractAddressAsync(IChainContext chainContext) { return(_smartContractAddressService.GetAddressByContractNameAsync(chainContext, ParliamentSmartContractAddressNameProvider.StringName)); }
public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync( IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext) { try { var chainContext = new ChainContext { BlockHash = transactionContext.PreviousBlockHash, BlockHeight = transactionContext.BlockHeight - 1 }; var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TokenSmartContractAddressNameProvider.StringName); if (transactionContext.BlockHeight < AElfConstants.GenesisBlockHeight + 1 || tokenContractAddress == null) { return(new List <Transaction>()); } if (!IsTargetAcsSymbol(descriptors) && transactionContext.Transaction.To != tokenContractAddress) { return(new List <Transaction>()); } var tokenStub = _contractReaderFactory.Create(new ContractReaderContext { Sender = transactionContext.Transaction.From, ContractAddress = tokenContractAddress }); if (transactionContext.Transaction.To == tokenContractAddress && transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeTransactionFees)) { // Skip ChargeTransactionFees itself return(new List <Transaction>()); } var txCost = await _txFeeService.CalculateFeeAsync(transactionContext, chainContext); var chargeTransactionFeesInput = new ChargeTransactionFeesInput { MethodName = transactionContext.Transaction.MethodName, ContractAddress = transactionContext.Transaction.To, TransactionSizeFee = txCost, }; var transactionSizeFeeSymbols = await _transactionSizeFeeSymbolsProvider.GetTransactionSizeFeeSymbolsAsync(chainContext); if (transactionSizeFeeSymbols != null) { foreach (var transactionSizeFeeSymbol in transactionSizeFeeSymbols.TransactionSizeFeeSymbolList) { chargeTransactionFeesInput.SymbolsToPayTxSizeFee.Add(new SymbolToPayTxSizeFee { TokenSymbol = transactionSizeFeeSymbol.TokenSymbol, BaseTokenWeight = transactionSizeFeeSymbol.BaseTokenWeight, AddedTokenWeight = transactionSizeFeeSymbol.AddedTokenWeight }); } } var chargeFeeTransaction = tokenStub.ChargeTransactionFees.GetTransaction(chargeTransactionFeesInput); return(new List <Transaction> { chargeFeeTransaction }); } catch (Exception e) { Logger.LogError(e, "Failed to generate ChargeTransactionFees tx."); throw; } }
public async Task TokenTransferParallelTest() { var chain = await _blockchainService.GetChainAsync(); var tokenAmount = _transactionCount / _groupCount; var(prepareTransactions, keyPairs) = await _parallelTestHelper.PrepareTokenForParallel(_groupCount, 1000000000); await _parallelTestHelper.BroadcastTransactions(prepareTransactions); var block = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, prepareTransactions); block = (await _blockExecutingService.ExecuteBlockAsync(block.Header, prepareTransactions)).Block; await _blockchainService.AddBlockAsync(block); await _blockAttachService.AttachBlockAsync(block); var systemTransactions = await _parallelTestHelper.GenerateTransferTransactions(1); var cancellableTransactions = await _parallelTestHelper.GenerateTransactionsWithoutConflictAsync(keyPairs, tokenAmount); var allTransaction = systemTransactions.Concat(cancellableTransactions).ToList(); await _parallelTestHelper.BroadcastTransactions(allTransaction); var groupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, cancellableTransactions); groupedTransactions.Parallelizables.Count.ShouldBe(_groupCount); groupedTransactions.NonParallelizables.Count.ShouldBe(0); block = _parallelTestHelper.GenerateBlock(block.GetHash(), block.Height, allTransaction); block = (await _blockExecutingService.ExecuteBlockAsync(block.Header, systemTransactions, cancellableTransactions, CancellationToken.None)).Block; await _blockchainService.AddBlockAsync(block); await _blockAttachService.AttachBlockAsync(block); var chainContext = new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }; var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TokenSmartContractAddressNameProvider.StringName); var nonparallelContractCode = await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(chainContext, tokenContractAddress); nonparallelContractCode.ShouldBeNull(); groupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, cancellableTransactions); groupedTransactions.Parallelizables.Count.ShouldBe(_groupCount); groupedTransactions.NonParallelizables.Count.ShouldBe(0); block.TransactionIds.Count().ShouldBe(allTransaction.Count); }