private BlockStateSet CreateBlockStateSet(Hash previousBlockHash, long blockHeight,
ExecutionReturnSetCollection executionReturnSetCollection)
{
var blockStateSet = new BlockStateSet
{
BlockHeight = blockHeight,
PreviousHash = previousBlockHash
};
foreach (var returnSet in executionReturnSetCollection.Executed)
{
foreach (var change in returnSet.StateChanges)
{
blockStateSet.Changes[change.Key] = change.Value;
blockStateSet.Deletes.Remove(change.Key);
}
foreach (var delete in returnSet.StateDeletes)
{
blockStateSet.Deletes.AddIfNotContains(delete.Key);
blockStateSet.Changes.Remove(delete.Key);
}
}
return(blockStateSet);
}
internal async Task MineBlockAsync(Block block)
{
var transactions = block.Body.TransactionIds.Count > 0
? await _blockchainService.GetTransactionsAsync(block.TransactionIds)
: new List <Transaction>();
var executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto
{
BlockHeader = block.Header,
Transactions = transactions,
}, CancellationToken.None);
await _transactionResultManager.AddTransactionResultsAsync(
executionReturnSets.Select(s => s.TransactionResult).ToList(), block.GetHash());
var blockStateSet = new BlockStateSet
{
BlockHash = block.GetHash(),
PreviousHash = block.Header.PreviousBlockHash,
BlockHeight = block.Height
};
foreach (var stateChange in executionReturnSets.SelectMany(executionReturnSet => executionReturnSet.StateChanges))
{
blockStateSet.Changes[stateChange.Key] = stateChange.Value;
}
await _blockStateSetManger.SetBlockStateSetAsync(blockStateSet);
}
public async Task <Block> AttachBlockToBestChain(List <Transaction> transactions = null,
List <TransactionResult> transactionResults = null)
{
var chain = await _blockchainService.GetChainAsync();
var block = await AttachBlock(chain.BestChainHeight, chain.BestChainHash, transactions, transactionResults);
var blockStateSet = new BlockStateSet
{
BlockHash = block.GetHash(),
BlockHeight = block.Height,
PreviousHash = block.Header.PreviousBlockHash
};
await _blockStateSetManger.SetBlockStateSetAsync(blockStateSet);
chain = await _blockchainService.GetChainAsync();
await _blockchainService.SetBestChainAsync(chain, block.Height, block.GetHash());
var chainBlockLink = await _chainManager.GetChainBlockLinkAsync(block.GetHash());
await _chainManager.SetChainBlockLinkExecutionStatusAsync(chainBlockLink,
ChainBlockLinkExecutionStatus.ExecutionSuccess);
return(block);
}
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();
}
private void CheckBlockExecutedData(BlockStateSet blockStateSet, Chain chain,
TransactionResult transactionResult, Dictionary <string, Transaction> transactionDic)
{
var chainContext = new ChainContext
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
};
var chainFromBlockExecutedData =
_chainBlockchainExecutedDataService.GetBlockExecutedData(chainContext,
GetBlockExecutedDataKey <Chain>());
chainFromBlockExecutedData.ShouldBe(chain);
var transactionResultFromBlockExecutedData =
_transactionResultBlockchainExecutedDataService.GetBlockExecutedData(chainContext,
GetBlockExecutedDataKey <TransactionResult>(transactionResult.TransactionId));
transactionResultFromBlockExecutedData.ShouldBe(transactionResult);
foreach (var keyPair in transactionDic)
{
var transaction =
_transactionBlockchainExecutedDataService.GetBlockExecutedData(chainContext, keyPair.Key);
transaction.ShouldBe(keyPair.Value);
}
}
protected virtual async Task <Block> FillBlockAfterExecutionAsync(BlockHeader blockHeader, List <Transaction> transactions,
ReturnSetCollection returnSetCollection)
{
Logger.LogTrace("Start block field filling after execution.");
var bloom = new Bloom();
var blockStateSet = new BlockStateSet
{
BlockHeight = blockHeader.Height,
PreviousHash = blockHeader.PreviousBlockHash
};
foreach (var returnSet in returnSetCollection.Executed)
{
foreach (var change in returnSet.StateChanges)
{
blockStateSet.Changes[change.Key] = change.Value;
blockStateSet.Deletes.Remove(change.Key);
}
foreach (var delete in returnSet.StateDeletes)
{
blockStateSet.Deletes.AddIfNotContains(delete.Key);
blockStateSet.Changes.Remove(delete.Key);
}
bloom.Combine(new[] { new Bloom(returnSet.Bloom.ToByteArray()) });
}
blockHeader.Bloom = ByteString.CopyFrom(bloom.Data);
blockHeader.MerkleTreeRootOfWorldState = CalculateWorldStateMerkleTreeRoot(blockStateSet);
var allExecutedTransactionIds = transactions.Select(x => x.GetHash()).ToList();
var orderedReturnSets = returnSetCollection.ToList().AsParallel()
.OrderBy(d => allExecutedTransactionIds.IndexOf(d.TransactionId)).ToList();
blockHeader.MerkleTreeRootOfTransactionStatus =
CalculateTransactionStatusMerkleTreeRoot(orderedReturnSets);
blockHeader.MerkleTreeRootOfTransactions = CalculateTransactionMerkleTreeRoot(allExecutedTransactionIds);
var blockHash = blockHeader.GetHashWithoutCache();
var blockBody = new BlockBody();
blockBody.TransactionIds.AddRange(allExecutedTransactionIds);
var block = new Block
{
Header = blockHeader,
Body = blockBody
};
blockStateSet.BlockHash = blockHash;
Logger.LogTrace("Set block state set.");
await _blockchainStateService.SetBlockStateSetAsync(blockStateSet);
Logger.LogTrace("Finish block field filling after execution.");
return(block);
}
public async Task BlockState_MergeBlock_Normal()
{
var blockStateSet1 = new BlockStateSet()
{
BlockHeight = 1,
BlockHash = Hash.Generate(),
PreviousHash = Hash.Empty
};
var blockStateSet2 = new BlockStateSet()
{
BlockHeight = 2,
BlockHash = Hash.Generate(),
PreviousHash = blockStateSet1.BlockHash
};
var blockStateSet3 = new BlockStateSet()
{
BlockHeight = 3,
BlockHash = Hash.Generate(),
PreviousHash = blockStateSet2.BlockHash
};
//test merge block height 1
{
await _blockchainStateManager.SetBlockStateSetAsync(blockStateSet1);
await _blockchainStateMergingService.MergeBlockStateAsync(blockStateSet1.BlockHeight,
blockStateSet1.BlockHash);
var chainStateInfo = await _blockchainStateManager.GetChainStateInfoAsync();
chainStateInfo.BlockHeight.ShouldBe(1);
chainStateInfo.BlockHash.ShouldBe(blockStateSet1.BlockHash);
}
//test merge block height 2
{
await _blockchainStateManager.SetBlockStateSetAsync(blockStateSet2);
await _blockchainStateMergingService.MergeBlockStateAsync(blockStateSet2.BlockHeight,
blockStateSet2.BlockHash);
var chainStateInfo = await _blockchainStateManager.GetChainStateInfoAsync();
chainStateInfo.BlockHeight.ShouldBe(2);
chainStateInfo.BlockHash.ShouldBe(blockStateSet2.BlockHash);
}
//test merge height 3 without block state set before
{
await Should.ThrowAsync <InvalidOperationException>(() => _blockchainStateMergingService.MergeBlockStateAsync(blockStateSet3.BlockHeight,
blockStateSet3.BlockHash));
var chainStateInfo = await _blockchainStateManager.GetChainStateInfoAsync();
chainStateInfo.BlockHeight.ShouldBe(2);
chainStateInfo.BlockHash.ShouldBe(blockStateSet2.BlockHash);
}
}
private async Task <bool> CheckExecutedDataInStoreAsync(BlockStateSet blockStateSet, string key,
ByteString blockExecutedData)
{
var stateReturn = await _blockchainExecutedDataManager.GetExecutedCacheAsync(key, blockStateSet.BlockHeight,
blockStateSet.BlockHash);
stateReturn.Value.ShouldBe(blockExecutedData);
return(stateReturn.IsInStore);
}
public static TieredStateCache ToTieredStateCache(this BlockStateSet blockStateSet)
{
var groupStateCache = blockStateSet == null
? new TieredStateCache()
: new TieredStateCache(
new StateCacheFromPartialBlockStateSet(blockStateSet));
return(groupStateCache);
}
public async Task <Block> FillBlockAfterExecutionAsync(BlockHeader blockHeader, List <Transaction> transactions,
List <ExecutionReturnSet> blockExecutionReturnSet)
{
var bloom = new Bloom();
var blockStateSet = new BlockStateSet
{
BlockHeight = blockHeader.Height,
PreviousHash = blockHeader.PreviousBlockHash
};
foreach (var returnSet in blockExecutionReturnSet)
{
foreach (var change in returnSet.StateChanges)
{
blockStateSet.Changes[change.Key] = change.Value;
}
if (returnSet.Status == TransactionResultStatus.Mined)
{
bloom.Combine(new[] { new Bloom(returnSet.Bloom.ToByteArray()) });
}
}
blockHeader.Bloom = ByteString.CopyFrom(bloom.Data);
var merkleTreeRootOfWorldState = ComputeHash(GetDeterministicByteArrays(blockStateSet));
blockHeader.MerkleTreeRootOfWorldState = merkleTreeRootOfWorldState;
var allExecutedTransactionIds = transactions.Select(x => x.GetHash()).ToList();
var bmt = new BinaryMerkleTree();
bmt.AddNodes(allExecutedTransactionIds);
blockHeader.MerkleTreeRootOfTransactions = bmt.ComputeRootHash();
_blockExtraDataService.FillMerkleTreeRootExtraDataForTransactionStatus(blockHeader,
blockExecutionReturnSet.Select(executionReturn =>
(executionReturn.TransactionId, executionReturn.Status)));
var blockBody = new BlockBody();
blockBody.Transactions.AddRange(allExecutedTransactionIds);
blockBody.TransactionList.AddRange(transactions);
var block = new Block
{
Header = blockHeader,
Body = blockBody
};
blockBody.BlockHeader = blockHeader.GetHash();
blockStateSet.BlockHash = blockHeader.GetHash();
await _blockchainStateManager.SetBlockStateSetAsync(blockStateSet);
return(block);
}
private async Task AddBlockStateSetAsync(Block block)
{
var blockStateSet = new BlockStateSet
{
BlockHash = block.GetHash(),
BlockHeight = block.Height,
PreviousHash = block.Header.PreviousBlockHash
};
await _blockStateSetManger.SetBlockStateSetAsync(blockStateSet);
}
public void TryGetExecutedCache_Test()
{
var blockStateSet = new BlockStateSet();
blockStateSet.TryGetExecutedCache("key1", out var value).ShouldBeFalse();
blockStateSet.BlockExecutedData.Add("key1", ByteString.CopyFromUtf8("key1"));
blockStateSet.TryGetExecutedCache("key1", out value).ShouldBeTrue();
value.ShouldBe(ByteString.CopyFromUtf8("key1"));
}
private IEnumerable <byte[]> GetDeterministicByteArrays(BlockStateSet blockStateSet)
{
var keys = blockStateSet.Changes.Keys;
foreach (var k in new SortedSet <string>(keys))
{
yield return(Encoding.UTF8.GetBytes(k));
yield return(blockStateSet.Changes[k].ToByteArray());
}
}
public async Task Mine_Test()
{
var chain = await _blockchainService.GetChainAsync();
var blockStateSet = new BlockStateSet
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight,
};
await _blockStateSetManger.SetBlockStateSetAsync(blockStateSet);
var transactions = _kernelTestHelper.GenerateTransactions(5, chain.BestChainHeight, chain.BestChainHash);
await _transactionPoolService.UpdateTransactionPoolByBestChainAsync(chain.BestChainHash,
chain.BestChainHeight);
await _transactionPoolService.AddTransactionsAsync(transactions);
await Task.Delay(200);
await _transactionPoolService.UpdateTransactionPoolByBestChainAsync(chain.BestChainHash,
chain.BestChainHeight);
{
await _transactionPackingOptionProvider.SetTransactionPackingOptionAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
}, false);
var blockTime = TimestampHelper.GetUtcNow();
var result = await _minerService.MineAsync(chain.BestChainHash, chain.BestChainHeight, blockTime,
TimestampHelper.DurationFromSeconds(4));
await CheckMiningResultAsync(result, blockTime, 0);
}
{
await _transactionPackingOptionProvider.SetTransactionPackingOptionAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
}, true);
await _blockTransactionLimitProvider.SetLimitAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
}, 3);
var blockTime = TimestampHelper.GetUtcNow();
var result = await _minerService.MineAsync(chain.BestChainHash, chain.BestChainHeight, blockTime,
TimestampHelper.DurationFromSeconds(4));
await CheckMiningResultAsync(result, blockTime, 2);
}
}
public static bool TryGetExecutedCache(this BlockStateSet blockStateSet, string key, out ByteString value)
{
value = null;
if (blockStateSet.BlockExecutedData.ContainsKey(key))
{
value = blockStateSet.BlockExecutedData[key];
return(true);
}
return(false);
}
public async Task <Block> FillBlockAfterExecutionAsync(BlockHeader blockHeader, List <Transaction> transactions,
List <ExecutionReturnSet> blockExecutionReturnSet)
{
var bloom = new Bloom();
var blockStateSet = new BlockStateSet
{
BlockHeight = blockHeader.Height,
PreviousHash = blockHeader.PreviousBlockHash
};
foreach (var returnSet in blockExecutionReturnSet)
{
foreach (var change in returnSet.StateChanges)
{
blockStateSet.Changes[change.Key] = change.Value;
}
if (returnSet.Status == TransactionResultStatus.Mined)
{
bloom.Combine(new[] { new Bloom(returnSet.Bloom.ToByteArray()) });
}
}
blockHeader.Bloom = ByteString.CopyFrom(bloom.Data);
blockHeader.MerkleTreeRootOfWorldState = CalculateWorldStateMerkleTreeRoot(blockStateSet);
blockHeader.MerkleTreeRootOfTransactionStatus =
CalculateTransactionStatusMerkleTreeRoot(blockExecutionReturnSet);
var allExecutedTransactionIds = transactions.Select(x => x.GetHash()).ToList();
blockHeader.MerkleTreeRootOfTransactions = CalculateTransactionMerkleTreeRoot(allExecutedTransactionIds);
var blockHash = blockHeader.GetHashWithoutCache();
var blockBody = new BlockBody
{
BlockHeader = blockHash
};
blockBody.TransactionIds.AddRange(allExecutedTransactionIds);
var block = new Block
{
Header = blockHeader,
Body = blockBody
};
blockBody.BlockHeader = blockHash;
blockStateSet.BlockHash = blockHash;
await _blockchainStateManager.SetBlockStateSetAsync(blockStateSet);
return(block);
}
protected async Task <BlockStateSet> AddBlockStateSetAsync(BlockStateSet previousBlockStateSet)
{
var block = await KernelTestHelper.AttachBlockToBestChain();
var blockStateSet = new BlockStateSet
{
BlockHash = block.GetHash(),
BlockHeight = block.Height,
PreviousHash = previousBlockStateSet.BlockHash
};
await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet);
return(blockStateSet);
}
public BlockStateSet ToBlockStateSet()
{
var blockStateSet = new BlockStateSet();
foreach (var returnSet in _executed)
{
foreach (var change in returnSet.StateChanges)
{
blockStateSet.Changes[change.Key] = change.Value;
}
}
return(blockStateSet);
}
public static bool TryGetState(this BlockStateSet blockStateSet, string key, out ByteString value)
{
value = null;
if (blockStateSet.Deletes.Contains(key))
{
return(true);
}
if (blockStateSet.Changes.ContainsKey(key))
{
value = blockStateSet.Changes[key];
return(true);
}
return(false);
}
private Hash CalculateWorldStateMerkleTreeRoot(BlockStateSet blockStateSet)
{
Hash merkleTreeRootOfWorldState;
var byteArrays = GetDeterministicByteArrays(blockStateSet);
using (var hashAlgorithm = SHA256.Create())
{
foreach (var bytes in byteArrays)
{
hashAlgorithm.TransformBlock(bytes, 0, bytes.Length, null, 0);
}
hashAlgorithm.TransformFinalBlock(new byte[0], 0, 0);
merkleTreeRootOfWorldState = Hash.FromByteArray(hashAlgorithm.Hash);
}
return(merkleTreeRootOfWorldState);
}
public void TryGetState_Test()
{
var blockStateSet = new BlockStateSet();
blockStateSet.TryGetState("key1", out var value).ShouldBeFalse();
blockStateSet.Deletes.Add("key1");
blockStateSet.TryGetState("key1", out value).ShouldBeTrue();
value.ShouldBeNull();
blockStateSet.Changes.Add("key1", ByteString.CopyFromUtf8("key1"));
blockStateSet.TryGetState("key1", out value).ShouldBeTrue();
value.ShouldBeNull();
blockStateSet.Changes.Add("key2", ByteString.CopyFromUtf8("key2"));
blockStateSet.TryGetState("key2", out value).ShouldBeTrue();
value.ShouldBe(ByteString.CopyFromUtf8("key2"));
}
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 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);
}
private void CheckBlockExecutedData(BlockStateSet blockStateSet,
Dictionary <string, CalculateFunction> functionMap)
{
var chainContext = new ChainContext
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
};
var functionMapFromBlockExecutedData =
_calculateFunctionProvider.GetCalculateFunctions(chainContext);
foreach (var key in functionMap.Keys)
{
var fromExecutedData = functionMapFromBlockExecutedData.Values.Single(d =>
((FeeTypeEnum)d.CalculateFeeCoefficients.FeeTokenType).ToString().ToUpper() == key);
var actual = functionMap.Values.Single(d =>
((FeeTypeEnum)d.CalculateFeeCoefficients.FeeTokenType).ToString().ToUpper() == key);
fromExecutedData.CalculateFeeCoefficients.ShouldBe(actual.CalculateFeeCoefficients);
}
}
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);
}
public async Task SmartContractRegistrationSetAndGet_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/SmartContractRegistration/{SampleAddress.AddressList[0]}";
blockStateSet.BlockExecutedData.ShouldNotContainKey(blockExecutedDataKey);
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var smartContractRegistration = new SmartContractRegistration
{
CodeHash = Hash.FromString(blockExecutedDataKey),
Category = KernelConstants.CodeCoverageRunnerCategory,
Version = 1
};
await _smartContractRegistrationProvider.SetSmartContractRegistrationAsync(chainContext,
SampleAddress.AddressList[0], smartContractRegistration);
blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
blockStateSet.BlockExecutedData.ShouldContainKey(blockExecutedDataKey);
var smartContractRegistrationFromState =
await _smartContractRegistrationProvider.GetSmartContractRegistrationAsync(chainContext,
SampleAddress.AddressList[0]);
smartContractRegistrationFromState.ShouldBe(smartContractRegistration);
}
public BlockStateSet ToBlockStateSet()
{
var blockStateSet = new BlockStateSet();
foreach (var returnSet in _executed)
{
foreach (var change in returnSet.StateChanges)
{
blockStateSet.Changes[change.Key] = change.Value;
blockStateSet.Deletes.Remove(change.Key);
}
foreach (var delete in returnSet.StateDeletes)
{
blockStateSet.Deletes.AddIfNotContains(delete.Key);
blockStateSet.Changes.Remove(delete.Key);
}
}
return(blockStateSet);
}
public void StateCacheFromPartialBlockStateSet_Test()
{
var path = new StatePath();
var deleteStatePath = new ScopedStatePath
{
Address = SampleAddress.AddressList[0],
Path = path
};
var changeStatePath = new ScopedStatePath
{
Address = SampleAddress.AddressList[1],
Path = path
};
var blockStateSet = new BlockStateSet
{
Deletes = { deleteStatePath.ToStateKey() },
Changes = { { changeStatePath.ToStateKey(), ByteString.Empty } },
};
var stateCacheFromPartialBlockStateSet = new StateCacheFromPartialBlockStateSet(blockStateSet);
var notExistStatePath = new ScopedStatePath
{
Address = SampleAddress.AddressList[2],
Path = path
};
stateCacheFromPartialBlockStateSet.TryGetValue(deleteStatePath, out var deletedValue).ShouldBeTrue();
deletedValue.ShouldBeNull();
stateCacheFromPartialBlockStateSet[deleteStatePath].ShouldBeNull();
stateCacheFromPartialBlockStateSet.TryGetValue(changeStatePath, out var changeValue).ShouldBeTrue();
changeValue.ShouldBe(ByteString.Empty);
stateCacheFromPartialBlockStateSet[changeStatePath].ShouldBe(ByteString.Empty.ToByteArray());
stateCacheFromPartialBlockStateSet.TryGetValue(notExistStatePath, out var value).ShouldBeFalse();
value.ShouldBeNull();
stateCacheFromPartialBlockStateSet[notExistStatePath].ShouldBeNull();
stateCacheFromPartialBlockStateSet[notExistStatePath] = ByteString.Empty.ToByteArray();
stateCacheFromPartialBlockStateSet[notExistStatePath].ShouldBeNull();
}
private async Task <ExecutionReturnSetMergeResult> ExecuteParallelizableTransactionsAsync(
List <List <Transaction> > groupedTransactions, BlockHeader blockHeader, BlockStateSet blockStateSet,
CancellationToken cancellationToken)
{
var tasks = groupedTransactions.Select(
txns => ExecuteAndPreprocessResult(new TransactionExecutingDto
{
BlockHeader = blockHeader,
Transactions = txns,
PartialBlockStateSet = blockStateSet
}, cancellationToken));
var results = await Task.WhenAll(tasks);
Logger.LogTrace("Executed parallelizables.");
var executionReturnSets = MergeResults(results, out var conflictingSets);
Logger.LogTrace("Merged results from parallelizables.");
return(new ExecutionReturnSetMergeResult
{
ExecutionReturnSets = executionReturnSets,
ConflictingReturnSets = conflictingSets
});
}
private string GetKey(BlockStateSet blockStateSet)
{
return(blockStateSet.BlockHash.ToStorageKey());
}
