public async Task GenerateTransactions_Test()
{
var sideChainId = 123;
var sideChainBlockInfoCache = new List <IBlockCacheEntity>();
var previousBlockHash = Hash.FromString("PreviousBlockHash");
var previousBlockHeight = 1;
var crossChainBlockData = new CrossChainBlockData
{
PreviousBlockHeight = previousBlockHeight
};
var cachingCount = 5;
for (int i = 1; i < cachingCount + CrossChainConstants.DefaultBlockCacheEntityCount; i++)
{
var sideChainBlockData = new SideChainBlockData()
{
ChainId = sideChainId,
Height = (i + 1),
TransactionStatusMerkleTreeRoot = Hash.FromString((sideChainId + 1).ToString())
};
sideChainBlockInfoCache.Add(sideChainBlockData);
if (i <= CrossChainConstants.DefaultBlockCacheEntityCount)
{
crossChainBlockData.SideChainBlockDataList.Add(sideChainBlockData);
}
}
_crossChainTestHelper.AddFakeSideChainIdHeight(sideChainId, 1);
AddFakeCacheData(new Dictionary <int, List <IBlockCacheEntity> > {
{ sideChainId, sideChainBlockInfoCache }
});
var res = await _crossChainIndexingDataService.PrepareExtraDataForNextMiningAsync(previousBlockHash,
previousBlockHeight);
Assert.Empty(res);
var smartContractAddress = SampleAddress.AddressList[0];
_smartContractAddressService.SetAddress(CrossChainSmartContractAddressNameProvider.Name,
smartContractAddress);
var transactions =
await _crossChainIndexingTransactionGenerator.GenerateTransactionsAsync(SampleAddress.AddressList[0],
previousBlockHeight, previousBlockHash);
transactions.Count.ShouldBe(1);
transactions[0].From.ShouldBe(SampleAddress.AddressList[0]);
transactions[0].To.ShouldBe(smartContractAddress);
transactions[0].RefBlockNumber.ShouldBe(previousBlockHeight);
transactions[0].RefBlockPrefix.ShouldBe(ByteString.CopyFrom(previousBlockHash.Value.Take(4).ToArray()));
transactions[0].MethodName
.ShouldBe(nameof(CrossChainContractContainer.CrossChainContractStub.ProposeCrossChainIndexing));
var crossChainBlockDataInParam = CrossChainBlockData.Parser.ParseFrom(transactions[0].Params);
Assert.Equal(crossChainBlockData, crossChainBlockDataInParam);
}
private async Task UpdateSmartContractAddressesAsync(BlockHeader blockHeader,
ISmartContractAddressNameProvider smartContractAddressNameProvider)
{
var t = new Transaction()
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(Acs0.ACS0Container.ACS0Stub.GetContractAddressByName),
Params = smartContractAddressNameProvider.ContractName.ToByteString()
};
var transactionResult =
(await _transactionExecutingService.ExecuteAsync(
new ChainContext()
{
BlockHash = blockHeader.GetHash(), BlockHeight = blockHeader.Height
}, t,
TimestampHelper.GetUtcNow()));
if (!transactionResult.IsSuccessful())
{
throw new InvalidOperationException();
}
var address = Address.Parser.ParseFrom(transactionResult.ReturnValue);
if (!address.Value.IsEmpty)
{
_smartContractAddressService.SetAddress(smartContractAddressNameProvider.ContractName, address);
}
}
/// <inheritdoc/>
public Task DeployContractAsync(ContractDto contractDto)
{
CheckRunner(contractDto.SmartContractRegistration.Category);
if (contractDto.ContractName != null)
{
_smartContractAddressService.SetAddress(contractDto.ContractName, contractDto.ContractAddress);
}
return(Task.CompletedTask);
}
public GrpcServerTests()
{
ParentChainGrpcServerBase = GetRequiredService <GrpcParentChainServerBase>();
SideChainGrpcServerBase = GetRequiredService <GrpcSideChainServerBase>();
BasicCrossChainRpcBase = GetRequiredService <GrpcBasicServerBase>();
_smartContractAddressService = GetRequiredService <SmartContractAddressService>();
_smartContractAddressService.SetAddress(CrossChainSmartContractAddressNameProvider.Name,
SampleAddress.AddressList[0]);
}
public async Task GenerateTransactions_Test()
{
var transactions = new List <Transaction>();
_crossChainIndexingTransactionGenerator.GenerateTransactions(SampleAddress.AddressList[0], 0, Hash.Empty, ref transactions);
transactions.Count.ShouldBe(0);
var chainId = _kernelTestHelper.BestBranchBlockList[0].Header.ChainId;
var previousBlockHash = _kernelTestHelper.BestBranchBlockList[3].GetHash();
var previousBlockHeight = _kernelTestHelper.BestBranchBlockList[3].Height;
_crossChainTestHelper.AddFakeSideChainIdHeight(chainId, previousBlockHeight);
var blockInfoCache = new List <IBlockCacheEntity>();
var cachingCount = CrossChainConstants.MinimalBlockCacheEntityCount + 1;
for (var i = 1; i <= cachingCount; i++)
{
var sideChainBlockData = new SideChainBlockData
{
ChainId = chainId,
Height = previousBlockHeight + i,
};
blockInfoCache.Add(sideChainBlockData);
}
var fakeCache = new Dictionary <int, List <IBlockCacheEntity> > {
{ chainId, blockInfoCache }
};
AddFakeCacheData(fakeCache);
var smartContractAddress = SampleAddress.AddressList[0];
_smartContractAddressService.SetAddress(CrossChainSmartContractAddressNameProvider.Name,
smartContractAddress);
await _crossChainIndexingDataService.GetCrossChainBlockDataForNextMiningAsync(previousBlockHash, previousBlockHeight);
_crossChainIndexingTransactionGenerator.GenerateTransactions(SampleAddress.AddressList[0], previousBlockHeight, previousBlockHash, ref transactions);
transactions.Count.ShouldBe(1);
transactions[0].From.ShouldBe(SampleAddress.AddressList[0]);
transactions[0].To.ShouldBe(smartContractAddress);
transactions[0].RefBlockNumber.ShouldBe(previousBlockHeight);
transactions[0].RefBlockPrefix.ShouldBe(ByteString.CopyFrom(previousBlockHash.Value.Take(4).ToArray()));
transactions[0].MethodName.ShouldBe(CrossChainConstants.CrossChainIndexingMethodName);
var crossChainBlockData = CrossChainBlockData.Parser.ParseFrom(transactions[0].Params);
crossChainBlockData.PreviousBlockHeight.ShouldBe(previousBlockHeight);
crossChainBlockData.ParentChainBlockData.Count.ShouldBe(0);
crossChainBlockData.SideChainBlockData.Count.ShouldBe(
cachingCount - CrossChainConstants.MinimalBlockCacheEntityCount);
crossChainBlockData.SideChainBlockData[0].ChainId.ShouldBe(chainId);
crossChainBlockData.SideChainBlockData[0].Height.ShouldBe(previousBlockHeight + 1);
}
public IrreversibleBlockDiscoveryServiceTests()
{
_smartContractAddressService = GetRequiredService <ISmartContractAddressService>();
_blockchainService = GetRequiredService <IBlockchainService>();
_irreversibleBlockDiscoveryService = GetRequiredService <IIrreversibleBlockDiscoveryService>();
_kernelTestHelper = GetRequiredService <KernelTestHelper>();
_smartContractAddressService.SetAddress(ConsensusSmartContractAddressNameProvider.Name, _consensusAddress);
}
/// <inheritdoc/>
public Task DeployContractAsync(ContractDto contractDto)
{
// get runner
var runner = _smartContractRunnerContainer.GetRunner(contractDto.SmartContractRegistration.Category);
if (contractDto.ContractName != null)
{
_smartContractAddressService.SetAddress(contractDto.ContractName, contractDto.ContractAddress);
}
//Todo New version metadata handle it
// var contractType = runner.GetContractType(registration);
// var contractTemplate = runner.ExtractMetadata(contractType);
// await _functionMetadataService.DeployContract(contractAddress, contractTemplate);
return(Task.CompletedTask);
}
public async Task ValidateTransaction_Test()
{
var tx = _kernelTestHelper.GenerateTransaction();
var result = await _validationProvider.ValidateTransactionAsync(tx);
result.ShouldBe(true);
_smartContractAddressService.SetAddress(TokenSmartContractAddressNameProvider.Name,
SampleAddress.AddressList.Last());
tx.To = SampleAddress.AddressList.Last();
tx.MethodName = "ClaimTransactionFees";
result = await _validationProvider.ValidateTransactionAsync(tx);
result.ShouldBe(false);
}
/// <inheritdoc/>
public async Task DeployContractAsync(Address contractAddress,
SmartContractRegistration registration, bool isPrivileged, Hash name)
{
// get runner
var runner = _smartContractRunnerContainer.GetRunner(registration.Category);
await Task.Run(() => runner.CodeCheck(registration.Code.ToByteArray(), isPrivileged));
if (name != null)
{
_smartContractAddressService.SetAddress(name, contractAddress);
}
//Todo New version metadata handle it
// var contractType = runner.GetContractType(registration);
// var contractTemplate = runner.ExtractMetadata(contractType);
// await _functionMetadataService.DeployContract(contractAddress, contractTemplate);
}
/// <inheritdoc/>
public async Task DeployContractAsync(ContractDto contractDto)
{
// get runner
var runner = _smartContractRunnerContainer.GetRunner(contractDto.SmartContractRegistration.Category);
await Task.Run(() => runner.CodeCheck(contractDto.SmartContractRegistration.Code.ToByteArray(), contractDto.IsPrivileged));
if (contractDto.ContractName != null)
{
_smartContractAddressService.SetAddress(contractDto.ContractName, contractDto.ContractAddress);
}
await _smartContractExecutiveService.SetContractInfoAsync(contractDto.ContractAddress,
contractDto.BlockHeight);
//Todo New version metadata handle it
// var contractType = runner.GetContractType(registration);
// var contractTemplate = runner.ExtractMetadata(contractType);
// await _functionMetadataService.DeployContract(contractAddress, contractTemplate);
}
private async Task UpdateSmartContractAddressesAsync(BlockHeader blockHeader,
ISmartContractAddressNameProvider smartContractAddressNameProvider)
{
var transaction = new Transaction()
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(Acs0.ACS0Container.ACS0Stub.GetContractAddressByName),
Params = smartContractAddressNameProvider.ContractName.ToByteString()
};
var address = await _transactionExecutingService.ExecuteAsync <Address>(
new ChainContext { BlockHash = blockHeader.GetHash(), BlockHeight = blockHeader.Height }, transaction,
TimestampHelper.GetUtcNow(), true);
if (!address.Value.IsEmpty)
{
_smartContractAddressService.SetAddress(smartContractAddressNameProvider.ContractName, address);
}
}
public GrpcServerTests()
{
CrossChainGrpcServer = GetRequiredService <CrossChainRpc.CrossChainRpcBase>();
_smartContractAddressService = GetRequiredService <SmartContractAddressService>();
_smartContractAddressService.SetAddress(CrossChainSmartContractAddressNameProvider.Name, Address.Generate());
}