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]);
}
public async Task GetExecutive_ThrowSmartContractFindRegistrationException()
{
var chain = await _smartContractHelper.CreateChainWithGenesisContractAsync();
_smartContractExecutiveService.GetExecutiveAsync(new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
}, SampleAddress.AddressList[0]).ShouldThrow <SmartContractFindRegistrationException>();
}
public async Task ExecuteAsync_Test()
{
var chain = await _smartContractHelper.CreateChainWithGenesisContractAsync();
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = new Transaction
{
From = SampleAddress.AddressList[0],
To = SampleAddress.AddressList[0],
MethodName = "NotExistMethod",
Params = ByteString.Empty
};
_transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction, TimestampHelper.GetUtcNow())
.ShouldThrow <SmartContractFindRegistrationException>();
_transactionReadOnlyExecutionService.ExecuteAsync <Address>(chainContext, transaction, TimestampHelper.GetUtcNow(), false)
.ShouldThrow <SmartContractFindRegistrationException>();
transaction = new Transaction
{
From = SampleAddress.AddressList[0],
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = "NotExistMethod",
Params = ByteString.Empty
};
var trace = await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction,
TimestampHelper.GetUtcNow());
trace.Error.ShouldContain("Failed to find handler for NotExistMethod");
trace.ExecutionStatus.ShouldBe(ExecutionStatus.SystemError);
var hash = await _transactionReadOnlyExecutionService.ExecuteAsync <Hash>(chainContext, transaction,
TimestampHelper.GetUtcNow(), false);
hash.ShouldBeNull();
_transactionReadOnlyExecutionService.ExecuteAsync <Hash>(chainContext, transaction,
TimestampHelper.GetUtcNow(), true).ShouldThrow <SmartContractExecutingException>();
_smartContractExecutiveProvider.GetPool(_defaultContractZeroCodeProvider.ContractZeroAddress).Single()
.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
transaction = new Transaction
{
From = SampleAddress.AddressList[0],
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.GetSmartContractRegistrationByAddress),
Params = _defaultContractZeroCodeProvider.ContractZeroAddress.ToByteString()
};
trace = await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction,
TimestampHelper.GetUtcNow());
trace.ExecutionStatus.ShouldBe(ExecutionStatus.Executed);
var smartContractRegistration = SmartContractRegistration.Parser.ParseFrom(trace.ReturnValue);
CheckSmartContractRegistration(smartContractRegistration);
_smartContractExecutiveProvider.GetPool(_defaultContractZeroCodeProvider.ContractZeroAddress).Single()
.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
smartContractRegistration = await _transactionReadOnlyExecutionService.ExecuteAsync <SmartContractRegistration>(chainContext, transaction,
TimestampHelper.GetUtcNow(), true);
CheckSmartContractRegistration(smartContractRegistration);
_smartContractExecutiveProvider.GetPool(_defaultContractZeroCodeProvider.ContractZeroAddress).Single()
.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
}
