public async Task <IChain> CreateChainTest() { var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.Zero }; var chainId = Hash.Generate(); var chain = await _chainCreationService.CreateNewChainAsync(chainId, new List <SmartContractRegistration> { reg }); var blockchain = _chainService.GetBlockChain(chainId); var getNextHeight = new Func <Task <ulong> >(async() => { var curHash = await blockchain.GetCurrentBlockHashAsync(); var indx = ((BlockHeader)await blockchain.GetHeaderByHashAsync(curHash)).Index; return(indx + 1); }); Assert.Equal(await getNextHeight(), GlobalConfig.GenesisBlockHeight + 1); return(chain); }
private async Task Init() { var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.Zero, Type = (int)SmartContractType.BasicContractZero }; var chain1 = await _chainCreationService.CreateNewChainAsync(ChainId1, new List <SmartContractRegistration> { reg }); DataProvider1 = DataProvider.GetRootDataProvider( chain1.Id, Address.FromRawBytes(ChainId1.OfType(HashType.AccountZero).ToByteArray()) ); DataProvider1.StateStore = StateStore; var chain2 = await _chainCreationService.CreateNewChainAsync(ChainId2, new List <SmartContractRegistration> { reg }); DataProvider2 = DataProvider.GetRootDataProvider( chain2.Id, Address.FromRawBytes(ChainId1.OfType(HashType.AccountZero).ToByteArray()) ); DataProvider2.StateStore = StateStore; }
public async Task <BlockchainNodeContext> StartAsync(BlockchainNodeContextStartDto dto) { _defaultContractZeroCodeProvider.SetDefaultContractZeroRegistrationByType(dto.ZeroSmartContractType); var context = new BlockchainNodeContext { ChainId = dto.ChainId, TxHub = _txHub, }; var chain = await _blockchainService.GetChainAsync(); chain = chain == null ? await _chainCreationService.CreateNewChainAsync(dto.Transactions) : await _blockchainService.ResetChainToLibAsync(chain); await _smartContractAddressUpdateService.UpdateSmartContractAddressesAsync( await _blockchainService.GetBlockHeaderByHashAsync(chain.BestChainHash)); await _consensusService.TriggerConsensusAsync(new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }); return(context); }
private async Task Init() { var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.Zero, Type = (int)SmartContractType.BasicContractZero }; var chain1 = await _chainCreationService.CreateNewChainAsync(ChainId1, new List <SmartContractRegistration> { reg }); var chain2 = await _chainCreationService.CreateNewChainAsync(ChainId2, new List <SmartContractRegistration> { reg }); }
public async Task SmartContractZeroByCreation() { var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.Zero }; var chain = await _chainCreationService.CreateNewChainAsync(ChainId, new List <SmartContractRegistration> { reg }); var contractAddressZero = AddressHelpers.GetSystemContractAddress(ChainId, GlobalConfig.GenesisBasicContract); var copy = await _smartContractManager.GetAsync(contractAddressZero); // throw exception if not registered Assert.Equal(reg, copy); }
public async Task <Address> Prepare(byte[] contractCode) { //create smart contact zero var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.FromRawBytes(SmartContractZeroCode), Type = (int)SmartContractType.BasicContractZero }; var chain = await _chainCreationService.CreateNewChainAsync(ChainId, new List <SmartContractRegistration> { reg }); var contractAddressZero = _chainCreationService.GenesisContractHash(ChainId, SmartContractType.BasicContractZero); //deploy token contract var code = contractCode; var txnDep = new Transaction() { From = Address.Zero, To = contractAddressZero, IncrementId = 0, MethodName = "DeploySmartContract", Params = ByteString.CopyFrom(ParamsPacker.Pack(1, code)) }; var txnCtxt = new TransactionContext() { Transaction = txnDep }; var executive = await _smartContractService.GetExecutiveAsync(contractAddressZero, ChainId); try { await executive.SetTransactionContext(txnCtxt).Apply(); await txnCtxt.Trace.CommitChangesAsync(_stateStore); } finally { await _smartContractService.PutExecutiveAsync(contractAddressZero, executive); } var contractAddr = txnCtxt.Trace.RetVal.Data.DeserializeToPbMessage <Address>(); return(contractAddr); }
public async Task <IChain> CreateChain() { var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.Zero }; var chainId = Hash.Generate(); return(await _chainCreationService.CreateNewChainAsync(chainId, new List <SmartContractRegistration> { reg })); }
public async Task Test() { // TODO: *** Contract Issues *** var reg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SmartContractZeroCode), ContractHash = Hash.FromRawBytes(SmartContractZeroCode) }; var chain = await _service.CreateNewChainAsync(Hash.FromString("Hello"), new List <SmartContractRegistration> { reg }); Assert.Equal(Hash.FromString("Hello").DumpHex(), chain.Id.DumpHex()); }
private void CreateNewChain(byte[] tokenContractCode, byte[] consensusContractCode, byte[] basicContractZero, byte[] sideChainGenesisContractCode) { var tokenCReg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(tokenContractCode), ContractHash = Hash.FromRawBytes(tokenContractCode), Type = (int)SmartContractType.TokenContract }; var consensusCReg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(consensusContractCode), ContractHash = Hash.FromRawBytes(consensusContractCode), Type = (int)SmartContractType.AElfDPoS }; var basicReg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(basicContractZero), ContractHash = Hash.FromRawBytes(basicContractZero), Type = (int)SmartContractType.BasicContractZero }; var sideChainCReg = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(sideChainGenesisContractCode), ContractHash = Hash.FromRawBytes(sideChainGenesisContractCode), Type = (int)SmartContractType.SideChainContract }; var res = _chainCreationService.CreateNewChainAsync(Hash.LoadHex(ChainConfig.Instance.ChainId), new List <SmartContractRegistration> { basicReg, tokenCReg, consensusCReg, sideChainCReg }).Result; _logger?.Debug($"Genesis block hash = {res.GenesisBlockHash.DumpHex()}"); }
private async Task Init() { var reg1 = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SideChainCode), ContractHash = Hash.FromRawBytes(SideChainCode), Type = (int)SmartContractType.SideChainContract }; var reg0 = new SmartContractRegistration { Category = 0, ContractBytes = ByteString.CopyFrom(SCZeroContractCode), ContractHash = Hash.FromRawBytes(SCZeroContractCode), Type = (int)SmartContractType.BasicContractZero }; var chain1 = await _chainCreationService.CreateNewChainAsync(ChainId1, new List <SmartContractRegistration> { reg0, reg1 }); }