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);
}
}
private Transaction GetTransactionForDeployment(byte[] code, Hash systemContractName,
int category,
List <ContractInitializationMethodCall> contractInitializationMethodCallList = null)
{
var transactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
if (contractInitializationMethodCallList != null)
{
transactionMethodCallList.Value.Add(contractInitializationMethodCallList.Select(call =>
new SystemContractDeploymentInput.Types.SystemTransactionMethodCall
{
MethodName = call.MethodName,
Params = call.Params ?? ByteString.Empty
}));
}
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
return(new Transaction()
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.DeploySystemSmartContract),
Params = new SystemContractDeploymentInput()
{
Name = systemContractName,
Category = category,
Code = ByteString.CopyFrom(code),
TransactionMethodCallList = transactionMethodCallList
}.ToByteString()
});
}
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 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 Get_Chain_Information_Success()
{
var chainId = _blockchainService.GetChainId();
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var response = await JsonCallAsJObject("/chain", "GetChainInformation");
var responseZeroContractAddress = response["result"]["GenesisContractAddress"].ToString();
var responseChainId = ChainHelpers.ConvertBase58ToChainId(response["result"]["ChainId"].ToString());
responseZeroContractAddress.ShouldBe(basicContractZero.GetFormatted());
responseChainId.ShouldBe(chainId);
}
private void CheckInterestedEvent <T>(InterestedEvent interestedEvent) where T : IEvent <T>, new()
{
var zeroSmartContractAddress = _smartContractAddressService.GetZeroSmartContractAddress();
var logEvent = new T().ToLogEvent(zeroSmartContractAddress);
var contractDeployedEvent = new InterestedEvent
{
LogEvent = logEvent,
Bloom = logEvent.GetBloom()
};
interestedEvent.LogEvent.ShouldBe(contractDeployedEvent.LogEvent);
interestedEvent.Bloom.Data.ShouldBe(contractDeployedEvent.Bloom.Data);
}
public async Task <Address> DeployContract <T>()
{
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var accountAddress = await _accountService.GetAccountAsync();
var transaction = GenerateTransaction(accountAddress, basicContractZero,
nameof(BasicContractZeroContainer.BasicContractZeroBase.DeploySmartContract), new ContractDeploymentInput()
{
Category = KernelConstants.CodeCoverageRunnerCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(T).Assembly.Location))
});
var signature = await _accountService.SignAsync(transaction.GetHash().ToByteArray());
transaction.Signature = ByteString.CopyFrom(signature);
await BroadcastTransactions(new List <Transaction> {
transaction
});
await MinedOneBlock();
var txResult = await _transactionResultService.GetTransactionResultAsync(transaction.GetHash());
return(Address.Parser.ParseFrom(txResult.ReturnValue));
}
/// <summary>
/// Get the current status of the block chain.
/// </summary>
/// <returns></returns>
public async Task <ChainStatusDto> GetChainStatusAsync()
{
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var chain = await _blockchainService.GetChainAsync();
var branches = chain.Branches.ToDictionary(b => HashHelper.Base64ToHash(b.Key).ToHex(), b => b.Value);
var notLinkedBlocks = chain.NotLinkedBlocks.ToDictionary(b => HashHelper.Base64ToHash(b.Key).ToHex(),
b => HashHelper.Base64ToHash(b.Value).ToHex());
return(new ChainStatusDto
{
ChainId = ChainHelper.ConvertChainIdToBase58(chain.Id),
GenesisContractAddress = basicContractZero?.GetFormatted(),
Branches = branches,
NotLinkedBlocks = notLinkedBlocks,
LongestChainHeight = chain.LongestChainHeight,
LongestChainHash = chain.LongestChainHash?.ToHex(),
GenesisBlockHash = chain.GenesisBlockHash.ToHex(),
LastIrreversibleBlockHash = chain.LastIrreversibleBlockHash?.ToHex(),
LastIrreversibleBlockHeight = chain.LastIrreversibleBlockHeight,
BestChainHash = chain.BestChainHash?.ToHex(),
BestChainHeight = chain.BestChainHeight
});
}
private Transaction GetTransactionForDeployment(int chainId, Type contractType, Hash systemContractName,
int category, SystemContractDeploymentInput.Types.SystemTransactionMethodCallList transactionMethodCallList = null)
{
if (transactionMethodCallList == null)
{
transactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
}
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
var code = File.ReadAllBytes(contractType.Assembly.Location);
return(new Transaction()
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ISmartContractZero.DeploySystemSmartContract),
// TODO: change cagtegory to 0
Params = new SystemContractDeploymentInput()
{
Name = systemContractName,
Category = category,
Code = ByteString.CopyFrom(code),
TransactionMethodCallList = transactionMethodCallList
}.ToByteString()
});
}
public async Task InitAsync()
{
var byteString = await CallContractMethodAsync(_smartContractAddressService.GetZeroSmartContractAddress(),
"GetDeployedContractAddressList", new Empty());
var addressList = AddressList.Parser.ParseFrom(byteString).Value.ToList();
_deployedContractAddressProvider.Init(addressList);
}
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);
}
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);
}
}
private List <Transaction> GetTransactions()
{
return(new List <Transaction>
{
new Transaction
{
From = SampleAddress.AddressList[0],
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(ACS0Container.ACS0Stub.GetContractInfo),
Params = _smartContractAddressService.GetZeroSmartContractAddress().ToByteString()
},
new Transaction
{
From = SampleAddress.AddressList[0],
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(ACS0Container.ACS0Stub.GetContractHash),
Params = _smartContractAddressService.GetZeroSmartContractAddress().ToByteString()
}
});
}
/// <summary>
/// Get the current status of the block chain.
/// </summary>
/// <returns></returns>
public async Task <ChainStatusDto> GetChainStatusAsync()
{
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var chain = await _blockchainService.GetChainAsync();
var result = _objectMapper.Map <Kernel.Chain, ChainStatusDto>(chain);
result.GenesisContractAddress = basicContractZero?.ToBase58();
return(result);
}
/// <summary>
/// Only deploy provided contracts as system contract.
/// Should initial each contract after if necessary.
/// </summary>
/// <param name="nameToCode"></param>
/// <param name="deployConsensusContract"></param>
/// <returns></returns>
public async Task <Dictionary <Hash, Address> > DeploySystemContractsAsync(Dictionary <Hash, byte[]> nameToCode,
bool deployConsensusContract = true)
{
var map = new Dictionary <Hash, Address>();
var zeroContractStub =
_contractTesterFactory.Create <BasicContractZeroContainer.BasicContractZeroStub>(
_smartContractAddressService.GetZeroSmartContractAddress(),
MissionedECKeyPairs.InitialKeyPairs.First());
if (!nameToCode.Keys.Contains(ConsensusSmartContractAddressNameProvider.Name) && deployConsensusContract)
{
nameToCode.Add(ConsensusSmartContractAddressNameProvider.Name,
ContractsDeployer.GetContractCodes <ContractTestAEDPoSExtensionModule>().First().Value);
}
foreach (var(name, code) in nameToCode)
{
var address = (await zeroContractStub.DeploySystemSmartContract.SendAsync(
new SystemContractDeploymentInput
{
Name = name,
Category = KernelConstants.CodeCoverageRunnerCategory,
Code = ByteString.CopyFrom(code),
})).Output;
if (address == null)
{
//throw new Exception($"Failed to deploy contract {name}");
}
map.Add(name, address);
if (name == ConsensusSmartContractAddressNameProvider.Name)
{
_consensusContractAddress = address;
}
if (name == ParliamentSmartContractAddressNameProvider.Name)
{
_parliamentContractAddress = address;
}
}
_isSystemContractsDeployed = true;
var currentBlockTime = TimestampHelper.GetUtcNow().ToDateTime();
_testDataProvider.SetBlockTime(currentBlockTime.ToTimestamp()
.AddMilliseconds(AEDPoSExtensionConstants.MiningInterval));
InitialContractStubs();
await InitialConsensus(currentBlockTime);
return(map);
}
private void PrepareBloom()
{
if (_bloom != null)
{
// already prepared
return;
}
_contractAddress =
_smartContractAddressService.GetZeroSmartContractAddress();
_interestedEvent = new ChainPrimaryTokenSymbolSet();
_logEvent = _interestedEvent.ToLogEvent(_contractAddress);
_bloom = _logEvent.GetBloom();
}
private Transaction GetTransactionForDeployment(byte[] code, Hash systemContractName,
int category,
SystemContractDeploymentInput.Types.SystemTransactionMethodCallList transactionMethodCallList = null)
{
if (transactionMethodCallList == null)
{
transactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
}
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
return(new Transaction()
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(BasicContractZero.DeploySystemSmartContract),
Params = new SystemContractDeploymentInput()
{
Name = systemContractName,
Category = category,
Code = ByteString.CopyFrom(code),
TransactionMethodCallList = transactionMethodCallList
}.ToByteString()
});
}
public override Task <InterestedEvent> GetInterestedEventAsync(IChainContext chainContext)
{
if (InterestedEvent != null)
{
return(Task.FromResult(InterestedEvent));
}
var address = _smartContractAddressService.GetZeroSmartContractAddress();
if (address == null)
{
return(null);
}
InterestedEvent = GetInterestedEvent <CodeUpdated>(address);
return(Task.FromResult(InterestedEvent));
}
public async Task Get_Chain_Status_Success()
{
var chain = await _blockchainService.GetChainAsync();
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var response = await GetResponseAsObjectAsync <ChainStatusDto>("/api/blockChain/chainStatus");
response.Branches.ShouldNotBeNull();
var responseChainId = ChainHelpers.ConvertBase58ToChainId(response.ChainId);
responseChainId.ShouldBe(chain.Id);
response.GenesisContractAddress.ShouldBe(basicContractZero.GetFormatted());
response.BestChainHeight.ShouldBe(11);
response.BestChainHash.ShouldBe(chain.BestChainHash?.ToHex());
response.LongestChainHeight = chain.LongestChainHeight;
response.LongestChainHash = chain.LongestChainHash?.ToHex();
response.GenesisBlockHash = chain.GenesisBlockHash.ToHex();
response.LastIrreversibleBlockHash = chain.LastIrreversibleBlockHash?.ToHex();
response.LastIrreversibleBlockHeight = chain.LastIrreversibleBlockHeight;
}
/// <summary>
/// Get the current status of the block chain.
/// </summary>
/// <returns></returns>
public async Task <ChainStatusDto> GetChainStatus()
{
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var chain = await _blockchainService.GetChainAsync();
var branches = JsonConvert.DeserializeObject <Dictionary <string, long> >(chain.Branches.ToString());
var formattedNotLinkedBlocks = new List <NotLinkedBlockDto>();
foreach (var notLinkedBlock in chain.NotLinkedBlocks)
{
var block = await GetBlock(Hash.LoadBase64(notLinkedBlock.Value));
formattedNotLinkedBlocks.Add(new NotLinkedBlockDto
{
BlockHash = block.GetHash().ToHex(),
Height = block.Height,
PreviousBlockHash = block.Header.PreviousBlockHash.ToHex()
}
);
}
return(new ChainStatusDto()
{
ChainId = ChainHelpers.ConvertChainIdToBase58(chain.Id),
GenesisContractAddress = basicContractZero?.GetFormatted(),
Branches = branches,
NotLinkedBlocks = formattedNotLinkedBlocks,
LongestChainHeight = chain.LongestChainHeight,
LongestChainHash = chain.LongestChainHash?.ToHex(),
GenesisBlockHash = chain.GenesisBlockHash.ToHex(),
LastIrreversibleBlockHash = chain.LastIrreversibleBlockHash?.ToHex(),
LastIrreversibleBlockHeight = chain.LastIrreversibleBlockHeight,
BestChainHash = chain.BestChainHash?.ToHex(),
BestChainHeight = chain.BestChainHeight
});
}
public void Deploy_Contract_ThrowNoPermissionException()
{
Should.Throw <NoPermissionException>(() =>
_bridgeContext.DeployContract(_smartContractAddressService.GetZeroSmartContractAddress(),
new SmartContractRegistration(), null));
}
public Address GetZeroSmartContractAddress()
{
return(_smartContractAddressService.GetZeroSmartContractAddress());
}