public async Task Request_SideChain_Creation_Twice() { await InitializeCrossChainContract(); long lockedTokenAmount = 20; await ApproveBalance(lockedTokenAmount * 2); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var tx = await GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), null, sideChainCreationRequest); await MineAsync(new List <Transaction> { tx }); var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest); var expectedChainId = ChainHelpers.GetChainId(2); Assert.Equal(expectedChainId, RequestChainCreationOutput.Parser.ParseFrom(txResult.ReturnValue).ChainId); }
public override void ConfigureServices(ServiceConfigurationContext context) { Configure <ChainOptions>(o => { o.ChainId = ChainHelpers.ConvertBase58ToChainId("AELF"); }); var ecKeyPair = CryptoHelpers.GenerateKeyPair(); var nodeAccount = Address.FromPublicKey(ecKeyPair.PublicKey).GetFormatted(); var nodeAccountPassword = "******"; Configure <AccountOptions>(o => { o.NodeAccount = nodeAccount; o.NodeAccountPassword = nodeAccountPassword; }); context.Services.AddSingleton <IKeyStore>(o => { var keyStore = new Mock <IKeyStore>(); ECKeyPair keyPair = null; keyStore.Setup(k => k.GetAccountKeyPair(It.IsAny <string>())).Returns(() => keyPair); keyStore.Setup(k => k.OpenAsync(It.IsAny <string>(), It.IsAny <string>(), false)).Returns(() => { keyPair = ecKeyPair; return(Task.FromResult(AElfKeyStore.Errors.None)); }); return(keyStore.Object); }); context.Services.AddTransient <AccountService>(); }
public async Task Request_SideChain_Creation() { await InitializeCrossChainContract(); long lockedTokenAmount = 10; await ApproveBalance(lockedTokenAmount); var balanceResult = GetBalanceOutput.Parser.ParseFrom(await Tester.CallContractMethodAsync(TokenContractAddress, nameof(TokenContract.GetBalance), new GetBalanceInput { Owner = Address.FromPublicKey(Tester.KeyPair.PublicKey), Symbol = "ELF" })); Assert.Equal(_balanceOfStarter, balanceResult.Balance); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest); var status = txResult.Status; Assert.True(status == TransactionResultStatus.Mined); var expectedChainId = ChainHelpers.GetChainId(1); Assert.Equal(expectedChainId, RequestChainCreationOutput.Parser.ParseFrom(txResult.ReturnValue).ChainId); }
public override void ConfigureServices(ServiceConfigurationContext context) { var services = context.Services; services.AddKeyValueDbContext <BlockchainKeyValueDbContext>(o => o.UseInMemoryDatabase()); services.AddKeyValueDbContext <StateKeyValueDbContext>(o => o.UseInMemoryDatabase()); services.AddTransient <IGenesisSmartContractDtoProvider, GenesisSmartContractDtoProvider>(); services.TryAddSingleton <ISmartContractAddressNameProvider, ConsensusSmartContractAddressNameProvider>(); services.TryAddSingleton <ISmartContractAddressNameProvider, ElectionSmartContractAddressNameProvider>(); services.TryAddSingleton <ISmartContractAddressNameProvider, ProfitSmartContractAddressNameProvider>(); services.TryAddSingleton <ISmartContractAddressNameProvider, TokenSmartContractAddressNameProvider>(); services.TryAddSingleton <ISmartContractAddressNameProvider, VoteSmartContractAddressNameProvider>(); Configure <ChainOptions>(options => { options.ChainId = ChainHelpers.ConvertBase58ToChainId(context.Services.GetConfiguration()["ChainId"]); }); Configure <HostSmartContractBridgeContextOptions>(options => { options.ContextVariables[ContextVariableDictionary.NativeSymbolName] = Symbol; }); }
public async Task Get_SideChain_Height() { long lockedTokenAmount = 10; await InitializeCrossChainContract(); await ApproveBalance(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var tx1 = await GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), null, sideChainCreationRequest); await MineAsync(new List <Transaction> { tx1 }); var chainId = ChainHelpers.GetChainId(1); await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.CreateSideChain), new SInt32Value() { Value = chainId }); var height = SInt64Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress, nameof(CrossChainContract.GetSideChainHeight), new SInt32Value() { Value = chainId })).Value; Assert.True(height == 0); }
public async Task GetChainStatus_Review() { long lockedTokenAmount = 10; await InitializeCrossChainContract(); await ApproveBalance(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var tx1 = await GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), null, sideChainCreationRequest); await MineAsync(new List <Transaction> { tx1 }); var chainId = ChainHelpers.GetChainId(1); var status = SInt32Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress, nameof(CrossChainContract.GetChainStatus), new SInt32Value() { Value = chainId })).Value; Assert.Equal(1, status); }
public async Task <bool> StartIndexingRequest(int chainId, long targetHeight, ICrossChainDataProducer crossChainDataProducer) { var requestData = new RequestCrossChainBlockData { FromChainId = LocalChainId, NextHeight = targetHeight }; using (var serverStream = RequestIndexing(requestData)) { while (await serverStream.ResponseStream.MoveNext()) { var response = serverStream.ResponseStream.Current; // requestCrossChain failed or useless response if (!response.Success || !crossChainDataProducer.AddNewBlockInfo(response.BlockInfoResult)) { break; } crossChainDataProducer.Logger.LogTrace( $"Received response from chain {ChainHelpers.ConvertChainIdToBase58(response.BlockInfoResult.ChainId)} at height {response.Height}"); } } return(true); }
public async Task <List <SideChainBlockData> > GetSideChainBlockDataAsync(Hash currentBlockHash, long currentBlockHeight) { var sideChainBlockData = new List <SideChainBlockData>(); var dict = await _crossChainContractReader.GetSideChainIdAndHeightAsync(currentBlockHash, currentBlockHeight); foreach (var idHeight in dict) { var i = 0; var targetHeight = idHeight.Value + 1; while (i < CrossChainConstants.MaximalCountForIndexingSideChainBlock) { var blockInfo = _crossChainDataConsumer.TryTake <SideChainBlockData>(idHeight.Key, targetHeight, true); if (blockInfo == null) { // no more available parent chain block info break; } sideChainBlockData.Add(blockInfo); Logger.LogTrace($"Got height {blockInfo.Height} of side chain {ChainHelpers.ConvertChainIdToBase58(idHeight.Key)}"); targetHeight++; i++; } } Logger.LogTrace($"Side chain block data count {sideChainBlockData.Count}"); return(sideChainBlockData); }
public async Task RechargeForSideChain_ChainNoExist() { var parentChainId = 123; long lockedTokenAmount = 10; await InitializeCrossChainContract(parentChainId); await ApproveBalance(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.Empty); var requestTxResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest); var chainId = RequestChainCreationOutput.Parser.ParseFrom(requestTxResult.ReturnValue).ChainId; var otherChainId = ChainHelpers.GetChainId(5); var rechargeInput = new RechargeInput() { ChainId = otherChainId, Amount = 100_000L }; await ApproveBalance(100_000L); var transactionResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.Recharge), rechargeInput); transactionResult.Status.ShouldBe(TransactionResultStatus.Failed); transactionResult.Error.Contains("Side chain not found or not able to be recharged.").ShouldBeTrue(); }
public async Task Get_Block_By_BlockHash_Success() { var chain = await _blockchainService.GetChainAsync(); var transactions = new List <Transaction>(); for (int i = 0; i < 3; i++) { transactions.Add(await _osTestHelper.GenerateTransferTransaction()); } await _osTestHelper.BroadcastTransactions(transactions); var block = await _osTestHelper.MinedOneBlock(); var response = await GetResponseAsObjectAsync <BlockDto>( $"/api/blockChain/block?blockHash={block.GetHash().ToHex()}&includeTransactions=true"); response.BlockHash.ShouldBe(block.GetHash().ToHex()); response.Header.PreviousBlockHash.ShouldBe(block.Header.PreviousBlockHash.ToHex()); response.Header.MerkleTreeRootOfTransactions.ShouldBe(block.Header.MerkleTreeRootOfTransactions.ToHex()); response.Header.MerkleTreeRootOfWorldState.ShouldBe(block.Header.MerkleTreeRootOfWorldState.ToHex()); response.Header.Height.ShouldBe(block.Height); response.Header.Time.ShouldBe(block.Header.Time.ToDateTime()); response.Header.ChainId.ShouldBe(ChainHelpers.ConvertChainIdToBase58(chain.Id)); response.Header.Bloom.ShouldBe(block.Header.Bloom.ToByteArray().ToHex()); response.Body.TransactionsCount.ShouldBe(3); var responseTransactions = response.Body.Transactions; responseTransactions.Count.ShouldBe(3); }
// public static List<string> ToPubKeyStrings(this List<ECKeyPair> keyPairs) // { // List<string> pubKeyStrings = new List<string>(keyPairs.Count); // // foreach (var key in keyPairs) // pubKeyStrings.Add(key.PublicKey.ToHex()); // // return pubKeyStrings; // } /// <summary> /// Get random chain Id /// </summary> /// <returns></returns> public static int GetRandomChainId() { var random = new Random(); var chainId = ChainHelpers.GetChainId(random.Next(195112, 11316496)); return(chainId); }
public async Task Withdraw_ChainCreation_ChainNotExist() { await InitializeCrossChainContract(); long lockedTokenAmount = 10; await ApproveBalance(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var tx = await GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), null, sideChainCreationRequest); await MineAsync(new List <Transaction> { tx }); var notExistChainId = ChainHelpers.GetChainId(5); var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.WithdrawRequest), new SInt32Value() { Value = notExistChainId }); var status = txResult.Status; Assert.True(status == TransactionResultStatus.Failed); }
public override void ConfigureServices(ServiceConfigurationContext context) { base.ConfigureServices(context); Configure <CrossChainConfigOption>(option => { option.ParentChainId = ChainHelpers.ConvertBase58ToChainId("AELF"); }); var services = context.Services; services.AddTransient(o => { var mockService = new Mock <IBlockchainService>(); mockService.Setup(m => m.GetChainAsync()) .Returns(Task.FromResult(new Chain { LastIrreversibleBlockHeight = 10 })); mockService.Setup(m => m.GetBlockHashByHeightAsync(It.IsAny <Chain>(), It.IsAny <long>(), It.IsAny <Hash>())) .Returns(Task.FromResult(Hash.Generate())); mockService.Setup(m => m.GetBlockByHashAsync(It.IsAny <Hash>())) .Returns(Task.FromResult(new Block { Height = 10, Header = new BlockHeader { ChainId = 0, BlockExtraDatas = { ByteString.CopyFrom(Hash.Generate().ToByteArray()), ByteString.CopyFrom(Hash.Generate().ToByteArray()) } } })); return(mockService.Object); }); services.AddTransient(o => { var mockService = new Mock <ICrossChainExtraDataExtractor>(); mockService.Setup(m => m.ExtractTransactionStatusMerkleTreeRoot(It.IsAny <BlockHeader>())) .Returns(Hash.Generate); return(mockService.Object); }); services.AddTransient(o => { var mockCrossChainDataProvider = new Mock <ICrossChainDataProvider>(); mockCrossChainDataProvider .Setup(c => c.GetChainInitializationContextAsync(It.IsAny <int>(), It.IsAny <Hash>(), It.IsAny <long>())).Returns(Task.FromResult(new ChainInitializationContext { ParentChainHeightOfCreation = 1, })); return(mockCrossChainDataProvider.Object); }); services.AddSingleton <CrossChainRpc.CrossChainRpcBase, CrossChainGrpcServerBase>(); }
public long GetNeededChainHeightForCache(int chainId) { var blockInfoCache = _multiChainBlockInfoCacheProvider.GetBlockInfoCache(chainId); if (blockInfoCache == null) { throw new ChainCacheNotFoundException($"Chain {ChainHelpers.ConvertChainIdToBase58(chainId)} cache not found."); } return(blockInfoCache.TargetChainHeight()); }
/// <summary> /// Get information about a given block by block hash. Otionally with the list of its transactions. /// </summary> /// <param name="blockHash">block hash</param> /// <param name="includeTransactions">include transactions or not</param> /// <returns></returns> public async Task <BlockDto> GetBlock(string blockHash, bool includeTransactions = false) { Hash realBlockHash; try { realBlockHash = Hash.LoadHex(blockHash); } catch { throw new UserFriendlyException(Error.Message[Error.InvalidBlockHash], Error.InvalidBlockHash.ToString()); } var block = await GetBlock(realBlockHash); if (block == null) { throw new UserFriendlyException(Error.Message[Error.NotFound], Error.NotFound.ToString()); } var blockDto = new BlockDto { BlockHash = block.GetHash().ToHex(), Header = new BlockHeaderDto { PreviousBlockHash = block.Header.PreviousBlockHash.ToHex(), MerkleTreeRootOfTransactions = block.Header.MerkleTreeRootOfTransactions.ToHex(), MerkleTreeRootOfWorldState = block.Header.MerkleTreeRootOfWorldState.ToHex(), Extra = block.Header.BlockExtraDatas.ToString(), Height = block.Header.Height, Time = block.Header.Time.ToDateTime(), ChainId = ChainHelpers.ConvertChainIdToBase58(block.Header.ChainId), Bloom = block.Header.Bloom.ToByteArray().ToHex() }, Body = new BlockBodyDto() { TransactionsCount = block.Body.TransactionsCount, Transactions = new List <string>() } }; if (includeTransactions) { var transactions = block.Body.Transactions; var txs = new List <string>(); foreach (var txHash in transactions) { txs.Add(txHash.ToHex()); } blockDto.Body.Transactions = txs; } return(blockDto); }
public Task <JObject> GetChainInformation() { var map = SmartContractAddressService.GetSystemContractNameToAddressMapping(); var basicContractZero = SmartContractAddressService.GetZeroSmartContractAddress(); var response = new JObject { ["GenesisContractAddress"] = basicContractZero?.GetFormatted(), ["ChainId"] = ChainHelpers.ConvertChainIdToBase58(BlockchainService.GetChainId()) }; return(Task.FromResult(response)); }
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); }
public override void ConfigureServices(ServiceConfigurationContext context) { var s = context.Services; s.TryAddSingleton <ISmartContractAddressNameProvider, ConsensusSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, CrossChainSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, DividendSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, ElectionSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, ParliamentAuthContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, ProfitSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, ResourceSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, ResourceFeeReceiverSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, TokenConverterSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, TokenSmartContractAddressNameProvider>(); s.TryAddSingleton <ISmartContractAddressNameProvider, VoteSmartContractAddressNameProvider>(); var configuration = context.Services.GetConfiguration(); Configure <TokenInitialOptions>(configuration.GetSection("TokenInitial")); Configure <ChainOptions>(option => { option.ChainId = ChainHelpers.ConvertBase58ToChainId(context.Services.GetConfiguration()["ChainId"]); }); Configure <HostSmartContractBridgeContextOptions>(options => { options.ContextVariables[ContextVariableDictionary.NativeSymbolName] = context.Services .GetConfiguration().GetValue("TokenInitial:Symbol", "ELF"); }); Configure <DPoSOptions>(option => { configuration.GetSection("Consensus").Bind(option); if (option.InitialMiners == null || option.InitialMiners.Count == 0 || string.IsNullOrWhiteSpace(option.InitialMiners[0])) { AsyncHelper.RunSync(async() => { var accountService = context.Services.GetRequiredServiceLazy <IAccountService>().Value; var publicKey = (await accountService.GetPublicKeyAsync()).ToHex(); option.InitialMiners = new List <string> { publicKey }; }); } }); }
protected async Task InitializeCrossChainContract(int parentChainId = 0) { var crossChainInitializationTransaction = await Tester.GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.Initialize), new InitializeInput { ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name, TokenContractSystemName = TokenSmartContractAddressNameProvider.Name, ParentChainId = parentChainId == 0 ? ChainHelpers.ConvertBase58ToChainId("AELF") : parentChainId, ParliamentContractSystemName = ParliamentAuthContractAddressNameProvider.Name }); await Tester.MineAsync(new List <Transaction> { crossChainInitializationTransaction }); }
public void RequestCrossChainIndexing() { //Logger.LogTrace("Request cross chain indexing .."); var chainIds = _crossChainMemoryCacheService.GetCachedChainIds(); foreach (var chainId in chainIds) { if (!_grpcCrossChainClients.TryGetValue(chainId, out var client)) { continue; } Logger.LogTrace($"Request chain {ChainHelpers.ConvertChainIdToBase58(chainId)}"); var targetHeight = _crossChainMemoryCacheService.GetNeededChainHeightForCache(chainId); var task = TryRequest(client, c => c.StartIndexingRequest(chainId, targetHeight, _crossChainDataProducer)); } }
/// <summary> /// Given a block, will generate the next, only the height and /// the previous will not be random. /// </summary> /// <param name="previous">The block to build upon on.</param> /// <returns>The new block</returns> public static Block BuildNext(Block previous, string producer = null) { Assert.NotNull(previous); return(new Block { Header = new BlockHeader { Height = previous.Header.Height + 1, MerkleTreeRootOfTransactions = Hash.Generate(), ChainId = ChainHelpers.GetChainId(123), PreviousBlockHash = previous.GetHash(), MerkleTreeRootOfWorldState = Hash.Generate(), Signature = producer == null ? ByteString.Empty : ByteString.CopyFromUtf8(producer) } }); }
protected async Task <int> InitAndCreateSideChain(int parentChainId = 0, long lockedTokenAmount = 10) { await InitializeCrossChainContract(parentChainId); await ApproveBalance(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var requestTxResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest); await ApproveWithMiners(RequestChainCreationOutput.Parser.ParseFrom(requestTxResult.ReturnValue).ProposalId); var chainId = ChainHelpers.GetChainId(1); return(chainId); }
public async Task GrpcServeNewChainReceivedEventTest() { var receivedEventData = new GrpcServeNewChainReceivedEvent { LocalChainId = _chainOptions.ChainId, CrossChainCommunicationContextDto = new GrpcCrossChainCommunicationContext { RemoteChainId = ChainHelpers.ConvertBase58ToChainId("ETH"), RemoteIsSideChain = false, TargetIp = _grpcCrossChainConfigOption.RemoteParentChainNodeIp, TargetPort = _grpcCrossChainConfigOption.RemoteParentChainNodePort, LocalChainId = _chainOptions.ChainId, LocalListeningPort = _grpcCrossChainConfigOption.LocalServerPort } }; await _grpcCrossChainClientNodePlugin.HandleEventAsync(receivedEventData); }
public async Task Get_SideChain_Height_ChainNotExist() { long lockedTokenAmount = 10; await InitializeCrossChainContract(); await ApproveBalance(lockedTokenAmount); var chainId = ChainHelpers.GetChainId(1); var height = await CallContractMethodAsync(CrossChainContractAddress, nameof(CrossChainContract.GetSideChainHeight), new SInt32Value() { Value = chainId }); Assert.Equal(ByteString.Empty, height); }
public async Task Request_SideChain_Disposal_NotFound() { await InitializeCrossChainContract(); var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainDisposal), new SInt32Value() { Value = ChainHelpers.GetChainId(5) }); var status = txResult.Status; Assert.True(status == TransactionResultStatus.Failed); Assert.True(txResult.Error.Contains("Side chain not found")); }
public override void ConfigureServices(ServiceConfigurationContext context) { Configure <ChainOptions>(o => { o.ChainId = ChainHelpers.ConvertBase58ToChainId("AELF"); }); var ecKeyPair = CryptoHelpers.GenerateKeyPair(); var nodeAccount = Address.FromPublicKey(ecKeyPair.PublicKey).GetFormatted(); var nodeAccountPassword = "******"; Configure <AccountOptions>(o => { o.NodeAccount = nodeAccount; o.NodeAccountPassword = nodeAccountPassword; }); Configure <DPoSOptions>(o => { var miners = new List <string>(); for (var i = 0; i < 3; i++) { miners.Add(CryptoHelpers.GenerateKeyPair().PublicKey.ToHex()); } o.InitialMiners = miners; o.MiningInterval = 4000; o.IsBootMiner = true; }); context.Services.AddTransient <IAccountService>(o => { var mockService = new Mock <IAccountService>(); mockService.Setup(a => a.SignAsync(It.IsAny <byte[]>())).Returns <byte[]>(data => Task.FromResult(CryptoHelpers.SignWithPrivateKey(ecKeyPair.PrivateKey, data))); mockService.Setup(a => a.VerifySignatureAsync(It.IsAny <byte[]>(), It.IsAny <byte[]>(), It.IsAny <byte[]>() )).Returns <byte[], byte[], byte[]>((signature, data, publicKey) => { var recoverResult = CryptoHelpers.RecoverPublicKey(signature, data, out var recoverPublicKey); return(Task.FromResult(recoverResult && publicKey.BytesEqual(recoverPublicKey))); }); mockService.Setup(a => a.GetPublicKeyAsync()).ReturnsAsync(ecKeyPair.PublicKey); return(mockService.Object); }); }
public void GetChainId_By_SerialNumber() { // Have tested all the conditions (195112UL ~ 11316496UL), To save time, just do some random test //var base58HashSet = new HashSet<string>(); //var intHashSet = new HashSet<int>(); // for (var i = ; i < 11316496UL; i++) for (var i = 0; i < 1000; i++) { var chainId = 2111; var base58String = ChainHelpers.ConvertChainIdToBase58(chainId); base58String.Length.ShouldBe(4); var newChainId = ChainHelpers.ConvertBase58ToChainId(base58String); newChainId.ShouldBe(chainId); // Uncomment this for go through all conditions // base58HashSet.Add(base58String).ShouldBe(true); // intHashSet.Add(newChainId).ShouldBe(true); } }
public async Task <JObject> GetBlockInfo(long blockHeight, bool includeTransactions = false) { var blockInfo = await this.GetBlockAtHeight(blockHeight); if (blockInfo == null) { throw new JsonRpcServiceException(Error.NotFound, Error.Message[Error.NotFound]); } // TODO: Create DTO Exntension for Block var response = new JObject { ["BlockHash"] = blockInfo.GetHash().ToHex(), ["Header"] = new JObject { ["PreviousBlockHash"] = blockInfo.Header.PreviousBlockHash.ToHex(), ["MerkleTreeRootOfTransactions"] = blockInfo.Header.MerkleTreeRootOfTransactions.ToHex(), ["MerkleTreeRootOfWorldState"] = blockInfo.Header.MerkleTreeRootOfWorldState.ToHex(), ["Extra"] = blockInfo.Header.BlockExtraDatas.ToString(), ["Height"] = blockInfo.Header.Height.ToString(), ["Time"] = blockInfo.Header.Time.ToDateTime(), ["ChainId"] = ChainHelpers.ConvertChainIdToBase58(blockInfo.Header.ChainId), ["Bloom"] = blockInfo.Header.Bloom.ToByteArray().ToHex() }, ["Body"] = new JObject { ["TransactionsCount"] = blockInfo.Body.TransactionsCount, } }; if (includeTransactions) { var transactions = blockInfo.Body.Transactions; var txs = new List <string>(); foreach (var txHash in transactions) { txs.Add(txHash.ToHex()); } response["Body"]["Transactions"] = JArray.FromObject(txs); } return(response); }
public override SideChainIdAndHeightDict GetSideChainIdAndHeight(Empty input) { var dict = new SideChainIdAndHeightDict(); var serialNumber = State.SideChainSerialNumber.Value; for (long i = 1; i <= serialNumber; i++) { int chainId = ChainHelpers.GetChainId(i); var sideChainInfo = State.SideChainInfos[chainId]; if (sideChainInfo.SideChainStatus != SideChainStatus.Active) { continue; } var height = State.CurrentSideChainHeight[chainId]; dict.IdHeightDict.Add(chainId, height); } return(dict); }
public async Task Dispose_SideChain() { long lockedTokenAmount = 10; await InitializeCrossChainContract(); await ApproveBalance(lockedTokenAmount); var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test")); var requestChainCreationResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest); await ApproveWithMiners(RequestChainCreationOutput.Parser.ParseFrom(requestChainCreationResult.ReturnValue).ProposalId); var chainId = ChainHelpers.GetChainId(1); var requestChainDisposalResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainDisposal), new SInt32Value() { Value = chainId }); await ApproveWithMiners(Hash.Parser.ParseFrom(requestChainDisposalResult.ReturnValue)); var chainStatus = SInt32Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress, nameof(CrossChainContract.GetChainStatus), new SInt32Value { Value = chainId })).Value; Assert.True(chainStatus == (int)SideChainStatus.Terminated); var status = SInt32Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress, nameof(CrossChainContract.GetChainStatus), new SInt32Value() { Value = chainId })).Value; Assert.Equal(4, status); }