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()); }