public async Task ExecuteBlocks_Success()
{
var chain = await _smartContractExecutionHelper.CreateChainAsync();
var block = _kernelTestHelper.GenerateBlock(chain.BestChainHeight, chain.BestChainHash);
var transactions = new List <Transaction>
{
new Transaction
{
From = SampleAddress.AddressList[0],
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(ACS0Container.ACS0Stub.GetContractInfo),
Params = _smartContractAddressService.GetZeroSmartContractAddress().ToByteString()
}
};
var blockExecutedSet = await _blockExecutingService.ExecuteBlockAsync(block.Header, transactions);
await _blockStateSetManger.RemoveBlockStateSetsAsync(new List <Hash> {
blockExecutedSet.GetHash()
});
await _blockchainService.AddTransactionsAsync(transactions);
await ExecuteBlocksAsync(new List <Block> {
blockExecutedSet.Block
});
}
public async Task Execute_Block_NonCancellable_Without_SystemTransactionCount()
{
var chain = await _smartContractExecutionHelper.CreateChainAsync();
var blockHeader = _kernelTestHelper.GenerateBlock(chain.BestChainHeight, chain.BestChainHash).Header;
var transactions = GetTransactions();
var blockExecutedSet = await _blockExecutingService.ExecuteBlockAsync(blockHeader, transactions);
await CheckBlockExecutedSetAsync(blockExecutedSet, 2);
}
public async Task ProcessAsync_Test()
{
var chain = await _smartContractExecutionHelper.CreateChainAsync();
var block = await _blockchainService.GetBlockByHashAsync(chain.BestChainHash);
var tasks = block.Body.TransactionIds
.Select(t => _transactionResultQueryService.GetTransactionResultAsync(t)).ToList();
var transactionResultList = await Task.WhenAll(tasks);
await ProcessTransactionResultsAsync(transactionResultList, block);
var transaction = new Transaction
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(ACS0Container.ACS0Stub.DeploySmartContract),
Params = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(
_smartContractExecutionHelper.ContractCodes["AElf.Contracts.MultiToken"])
}.ToByteString()
};
var blockExecutedSet = await _smartContractExecutionHelper.ExecuteTransactionAsync(transaction);
await ProcessTransactionResultsAsync(blockExecutedSet.TransactionResultMap.Values.ToArray(), blockExecutedSet.Block);
await ProcessCodeUpdateAsync(chain);
}
public async Task AttachBlockAsync_Test()
{
var chain = await _smartContractExecutionHelper.CreateChainAsync();
await _blockAttachService.AttachBlockAsync(_kernelTestHelper.GenerateBlock(0, Hash.Empty));
var blockHeader = new BlockHeader
{
Height = chain.BestChainHeight + 1,
PreviousBlockHash = chain.BestChainHash,
Time = TimestampHelper.GetUtcNow(),
SignerPubkey = ByteString.CopyFrom(CryptoHelper.GenerateKeyPair().PublicKey)
};
var transactions = new List <Transaction>
{
new Transaction
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(ACS0Container.ACS0Stub.DeploySmartContract),
Params = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(
_smartContractExecutionHelper.ContractCodes["AElf.Contracts.MultiToken"])
}.ToByteString()
}
};
var blockExecutedSet = await _blockExecutingService.ExecuteBlockAsync(blockHeader, transactions);
await _blockchainService.AddBlockAsync(blockExecutedSet.Block);
_blockAttachService.AttachBlockAsync(blockExecutedSet.Block).ShouldThrow <Exception>();
await _blockchainService.AddTransactionsAsync(transactions);
await _blockAttachService.AttachBlockAsync(blockExecutedSet.Block);
var newChain = await _blockchainService.GetChainAsync();
newChain.BestChainHeight.ShouldBe(chain.BestChainHeight + 1);
}
public async Task GetSmartContractRegistrationAsync_Test()
{
var chain = await _smartContractExecutionHelper.CreateChainAsync();
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var smartContractRegistration = await _smartContractRegistrationInStateProvider.GetSmartContractRegistrationAsync(chainContext,
SampleAddress.AddressList[0]);
smartContractRegistration.ShouldBe(new SmartContractRegistration());
smartContractRegistration = await _smartContractRegistrationInStateProvider.GetSmartContractRegistrationAsync(chainContext,
_defaultContractZeroCodeProvider.ContractZeroAddress);
smartContractRegistration.Category.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.Category);
smartContractRegistration.Code.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.Code);
smartContractRegistration.CodeHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
}