public async Task BlockState_NoNeed_To_Merge_Test()
{
var lastIrreversibleBlockHeight = -2;
var lastIrreversibleBlockHash = Hash.FromString("hash");
await _blockchainStateService.MergeBlockStateAsync(lastIrreversibleBlockHeight,
lastIrreversibleBlockHash);
var chainStateInfo = await _blockStateSetManger.GetChainStateInfoAsync();
chainStateInfo.BlockHeight.ShouldNotBe(lastIrreversibleBlockHeight);
chainStateInfo.MergingBlockHash.ShouldNotBe(lastIrreversibleBlockHash);
}
public Task HandleEventAsync(NewIrreversibleBlockFoundEvent eventData)
{
_taskQueueManager.Enqueue(async() =>
{
await _blockchainStateService.MergeBlockStateAsync(eventData.BlockHeight,
eventData.BlockHash);
}, KernelConstants.MergeBlockStateQueueName);
_taskQueueManager.Enqueue(async() =>
{
// Clean chain branch
var chain = await _blockchainService.GetChainAsync();
var discardedBranch = await _blockchainService.GetDiscardedBranchAsync(chain);
if (discardedBranch.BranchKeys.Count > 0 || discardedBranch.NotLinkedKeys.Count > 0)
{
_taskQueueManager.Enqueue(
async() => { await _blockchainService.CleanChainBranchAsync(discardedBranch); },
KernelConstants.UpdateChainQueueName);
}
// Clean transaction block index cache
await _transactionBlockIndexService.CleanTransactionBlockIndexCacheAsync(eventData.BlockHeight);
}, KernelConstants.ChainCleaningQueueName);
return(Task.CompletedTask);
}
public async Task BlockExecutedData_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 chainKey = GetBlockExecutedDataKey <Chain>();
var dictionary = new Dictionary <string, ByteString>
{
{ chainKey, ByteString.CopyFrom(SerializationHelper.Serialize(chain)) }
};
await _blockchainExecutedDataManager.AddBlockExecutedCacheAsync(blockStateSet.BlockHash, dictionary);
var isInStore = await CheckExecutedDataInStoreAsync(blockStateSet, chainKey, dictionary[chainKey]);
isInStore.ShouldBeFalse();
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
isInStore = await CheckExecutedDataInStoreAsync(blockStateSet, chainKey, dictionary[chainKey]);
isInStore.ShouldBeTrue();
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
isInStore = await CheckExecutedDataInStoreAsync(blockStateSet, chainKey, dictionary[chainKey]);
isInStore.ShouldBeTrue();
}
public async Task GlobalSetup()
{
_chains = GetRequiredService <IBlockchainStore <Chain> >();
_chainStateInfoCollection = GetRequiredService <IStateStore <ChainStateInfo> >();
_blockchainStateService = GetRequiredService <IBlockchainStateService>();
_blockStateSetManger = GetRequiredService <IBlockStateSetManger>();
_blockchainService = GetRequiredService <IBlockchainService>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_chainManager = GetRequiredService <IChainManager>();
_blockManager = GetRequiredService <IBlockManager>();
_transactionManager = GetRequiredService <ITransactionManager>();
_transactionPoolService = GetRequiredService <ITransactionPoolService>();
_blockStateSets = new List <BlockStateSet>();
_blocks = new List <Block>();
_chain = await _blockchainService.GetChainAsync();
var blockHash = _chain.BestChainHash;
while (true)
{
var blockState = await _blockStateSetManger.GetBlockStateSetAsync(blockHash);
_blockStateSets.Add(blockState);
var blockHeader = await _blockchainService.GetBlockHeaderByHashAsync(blockHash);
blockHash = blockHeader.PreviousBlockHash;
if (blockHash == _chain.LastIrreversibleBlockHash)
{
break;
}
}
await _blockchainStateService.MergeBlockStateAsync(_chain.BestChainHeight, _chain.BestChainHash);
for (var i = 0; i < BlockCount; i++)
{
var transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);
await _osTestHelper.BroadcastTransactions(transactions);
var block = await _osTestHelper.MinedOneBlock();
_blocks.Add(block);
var blockState = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash());
_blockStateSets.Add(blockState);
}
var chain = await _blockchainService.GetChainAsync();
await _chainManager.SetIrreversibleBlockAsync(chain, chain.BestChainHash);
_chainStateInfo = await _chainStateInfoCollection.GetAsync(chain.Id.ToStorageKey());
}
public async Task HandleEventAsync(NewIrreversibleBlockFoundEvent eventData)
{
_taskQueueManager.Enqueue(async() =>
{
await _blockchainStateService.MergeBlockStateAsync(eventData.BlockHeight,
eventData.BlockHash);
}, KernelConstants.MergeBlockStateQueueName);
}
public void MergeBlockStateTest()
{
AsyncHelper.RunSync(async() =>
{
var chain = await _blockchainService.GetChainAsync();
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
});
_counter.Increment();
}
public async Task LimitCanBeSetByExecutingContract_Test()
{
const int targetLimit = 55;
await DeployContractsAsync();
var proposalId = (await _parliamentContractStub.CreateProposal.SendAsync(new CreateProposalInput
{
ContractMethodName = "SetConfiguration",
ExpiredTime = TimestampHelper.GetUtcNow().AddDays(1),
Params = new SetConfigurationInput
{
Key = BlockTransactionLimitConfigurationNameProvider.Name,
Value = new Int32Value {
Value = targetLimit
}.ToByteString()
}.ToByteString(),
ToAddress = ConfigurationContractAddress,
OrganizationAddress = await _parliamentContractStub.GetDefaultOrganizationAddress.CallAsync(new Empty())
})).Output;
await _parliamentContractStub.Approve.SendAsync(proposalId);
// Before
{
var result = await _configurationStub.GetConfiguration.CallAsync(new StringValue
{
Value = BlockTransactionLimitConfigurationNameProvider.Name
});
var limit = new Int32Value();
limit.MergeFrom(BytesValue.Parser.ParseFrom(result.ToByteString()).Value);
Assert.Equal(0, limit.Value);
}
var txResult = await _parliamentContractStub.Release.SendAsync(proposalId);
var configurationSet = ConfigurationSet.Parser.ParseFrom(txResult.TransactionResult.Logs
.First(l => l.Name == nameof(ConfigurationSet)).NonIndexed);
var limitFromLogEvent = new Int32Value();
limitFromLogEvent.MergeFrom(configurationSet.Value.ToByteArray());
Assert.Equal(limitFromLogEvent.Value, targetLimit);
// After
{
var result = await _configurationStub.GetConfiguration.CallAsync(new StringValue
{
Value = BlockTransactionLimitConfigurationNameProvider.Name
});
var limit = new Int32Value();
limit.MergeFrom(BytesValue.Parser.ParseFrom(result.ToByteString()).Value);
Assert.Equal(targetLimit, limit.Value);
}
var chain = await _blockchainService.GetChainAsync();
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
var limitNum = await _blockTransactionLimitProvider.GetLimitAsync(
new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
});
Assert.Equal(55, limitNum);
}
public async Task MergeBlockStateTest()
{
var chain = await _blockchainService.GetChainAsync();
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
}
public async Task BlockExecutedData_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 transactionDic = new Dictionary <string, Transaction>();
for (var i = 0; i < 5; i++)
{
var transaction = new Transaction
{
From = SampleAddress.AddressList[i],
To = SampleAddress.AddressList[i + 1],
RefBlockNumber = chain.BestChainHeight - 1,
MethodName = "Test"
};
transactionDic.Add(GetBlockExecutedDataKey <Transaction>(transaction.GetHash()), transaction);
}
await _transactionBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
}, transactionDic);
var transactionResult = new TransactionResult
{
TransactionId = transactionDic.First().Value.GetHash()
};
var transactionResultKey = GetBlockExecutedDataKey <TransactionResult>(transactionResult.TransactionId);
await _transactionResultBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
},
transactionResultKey,
transactionResult);
var chainKey = GetBlockExecutedDataKey <Chain>();
await _chainBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
},
chainKey, chain);
var newBlockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
newBlockStateSet.BlockHash.ShouldBe(blockStateSet.BlockHash);
newBlockStateSet.BlockHeight.ShouldBe(blockStateSet.BlockHeight);
newBlockStateSet.BlockExecutedData.Count.ShouldBe(7);
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(Transaction).Name));
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(TransactionResult).Name));
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(Chain).Name));
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, chain, transactionResult, transactionDic);
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
CheckBlockExecutedData(blockStateSet, chain, transactionResult, transactionDic);
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, chain, transactionResult, transactionDic);
}
public async Task WrongParallelTest()
{
var chain = await _blockchainService.GetChainAsync();
await _blockchainService.SetIrreversibleBlockAsync(chain, chain.BestChainHeight, chain.BestChainHash);
//prepare token for tx verify
var(tokenTransactions, groupUsers) =
await _parallelTestHelper.PrepareTokenForParallel(_groupCount, 1000_00000000);
await _parallelTestHelper.BroadcastTransactions(tokenTransactions);
var prepareBlock =
_parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, tokenTransactions);
prepareBlock =
(await _blockExecutingService.ExecuteBlockAsync(prepareBlock.Header,
tokenTransactions)).Block;
await _blockchainService.AddBlockAsync(prepareBlock);
await _blockAttachService.AttachBlockAsync(prepareBlock);
chain = await _blockchainService.GetChainAsync();
var transactions =
_parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(groupUsers, _transactionCount);
var transferTransaction = await _parallelTestHelper.GenerateTransferTransaction(Address.FromPublicKey(groupUsers[1].PublicKey)
, "ELF", 10);
transactions.Add(transferTransaction);
await _parallelTestHelper.BroadcastTransactions(transactions);
var otherTransactions = _parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(groupUsers, _transactionCount);
var otherTransferTransaction = await _parallelTestHelper.GenerateTransferTransaction(Address.FromPublicKey(groupUsers[2].PublicKey)
, "ELF", 10);
otherTransactions.Add(otherTransferTransaction);
await _parallelTestHelper.BroadcastTransactions(otherTransactions);
var transferTransactions = await _parallelTestHelper.GenerateTransferTransactions(16);
await _parallelTestHelper.BroadcastTransactions(transferTransactions);
var poolSize = (await _txHub.GetTransactionPoolStatusAsync()).AllTransactionCount;
poolSize.ShouldBe(transactions.Count * 2 + transferTransactions.Count);
var groupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight },
transactions);
groupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount + 1);
groupedTransactions.NonParallelizables.Count.ShouldBe(0);
for (var i = 0; i < transactions.Count; i++)
{
transactions[i].GetHash().ShouldBe(groupedTransactions.Parallelizables[i][0].GetHash());
}
var otherGroupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight },
otherTransactions);
otherGroupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount + 1);
otherGroupedTransactions.NonParallelizables.Count.ShouldBe(0);
var groupedTransferTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight },
transferTransactions);
groupedTransferTransactions.Parallelizables.Count.ShouldBe(1);
groupedTransferTransactions.Parallelizables[0].Count.ShouldBe(transferTransactions.Count);
groupedTransferTransactions.NonParallelizables.Count.ShouldBe(0);
_localEventBus.Subscribe <ConflictingTransactionsFoundInParallelGroupsEvent>(e =>
{
e.ConflictingSets.Count.ShouldBe(_groupCount + 1);
e.ExistingSets.Count.ShouldBe(_groupCount);
return(Task.CompletedTask);
});
var block = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, transactions);
block = (await _blockExecutingService.ExecuteBlockAsync(block.Header, transactions)).Block;
block.TransactionIds.Count().ShouldBe(_transactionCount + 1);
var transactionResults = await GetTransactionResultsAsync(block.Body.TransactionIds.ToList(), block.Header);
transactionResults.Count(t => t.Status == TransactionResultStatus.Mined).ShouldBe(_groupCount);
transactionResults.Count(t => t.Status == TransactionResultStatus.Conflict).ShouldBe(_groupCount + 1);
await _blockchainService.AddBlockAsync(block);
await _blockAttachService.AttachBlockAsync(block);
var accountAddress = await _accountService.GetAccountAsync();
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();
foreach (var transaction in transactions)
{
if (transaction.To == tokenContractAddress)
{
continue;
}
var param = IncreaseWinMoneyInput.Parser.ParseFrom(transaction.Params);
var input = new QueryTwoUserWinMoneyInput
{
First = param.First,
Second = param.Second
};
var queryTransaction = _parallelTestHelper.GenerateTransaction(accountAddress,
ParallelTestHelper.BasicFunctionWithParallelContractAddress,
nameof(BasicFunctionWithParallelContract.QueryTwoUserWinMoney), input);
var byteString = await _parallelTestHelper.ExecuteReadOnlyAsync(queryTransaction, block.GetHash(), block.Height);
var output = TwoUserMoneyOut.Parser.ParseFrom(byteString);
output.FirstInt64Value.ShouldBe(1);
var result = transactionResults.First(t => t.TransactionId == transaction.GetHash());
if (result.Status == TransactionResultStatus.Mined)
{
output.SecondInt64Value.ShouldBe(1);
}
else if (result.Status == TransactionResultStatus.Conflict)
{
output.SecondInt64Value.ShouldBe(0);
}
}
nonparallelContractCode =
await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(new ChainContext
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
}, ParallelTestHelper.BasicFunctionWithParallelContractAddress);
nonparallelContractCode.CodeHash.ShouldBe(HashHelper.ComputeFrom(_parallelTestHelper.BasicFunctionWithParallelContractCode));
var blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash());
blockStateSet.Changes.Count.ShouldBeGreaterThan(0);
var blockExecutedData = blockStateSet.BlockExecutedData.First();
var versionedState = await _versionedStates.GetAsync(blockExecutedData.Key);
versionedState.ShouldBeNull();
await _blockchainStateService.MergeBlockStateAsync(block.Height, block.GetHash());
blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash());
blockStateSet.ShouldBeNull();
nonparallelContractCode =
await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(new ChainContext
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
}, ParallelTestHelper.BasicFunctionWithParallelContractAddress);
nonparallelContractCode.CodeHash.ShouldBe(HashHelper.ComputeFrom(_parallelTestHelper.BasicFunctionWithParallelContractCode));
versionedState = await _versionedStates.GetAsync(blockExecutedData.Key);
versionedState.Key.ShouldBe(blockExecutedData.Key);
versionedState.Value.ShouldBe(blockExecutedData.Value);
groupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height },
transactions);
groupedTransactions.Parallelizables.Count.ShouldBe(1);
groupedTransactions.Parallelizables[0][0].To.ShouldBe(tokenContractAddress);
groupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount);
otherGroupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height },
otherTransactions);
otherGroupedTransactions.Parallelizables.Count.ShouldBe(1);
otherGroupedTransactions.Parallelizables[0][0].To.ShouldBe(tokenContractAddress);
otherGroupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount);
groupedTransferTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight },
transferTransactions);
groupedTransferTransactions.Parallelizables.Count.ShouldBe(1);
groupedTransferTransactions.Parallelizables[0].Count.ShouldBe(transferTransactions.Count);
groupedTransferTransactions.NonParallelizables.Count.ShouldBe(0);
poolSize = (await _txHub.GetTransactionPoolStatusAsync()).AllTransactionCount;
poolSize.ShouldBe(transactions.Count * 2 + transferTransactions.Count - block.TransactionIds.Count());
}
