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