internal async Task <long> GetParentChainHeight() { var result = await SideChainTester.CallContractMethodAsync(SideCrossChainContractAddress, nameof(CrossChainContractContainer.CrossChainContractStub .GetParentChainHeight), new Empty()); var height = SInt64Value.Parser.ParseFrom(result); return(height.Value); }
public async Task SetBlockchainAgeTest() { const long age = 100L; var starter = new ContractTester <DPoSContractTestAElfModule>(); var initialMiners = Enumerable.Range(0, 3).Select(_ => CryptoHelpers.GenerateKeyPair()) .ToList(); await starter.InitialChainAndTokenAsync(initialMiners); var initialMiner = starter.CreateNewContractTester(initialMiners[0]); await initialMiner.ExecuteConsensusContractMethodWithMiningAsync( nameof(ConsensusContract.SetBlockchainAge), new SInt64Value() { Value = age }); // Starter can set blockchain age. { var blockchainAge = SInt64Value.Parser.ParseFrom(await starter.CallContractMethodAsync( starter.GetConsensusContractAddress(), nameof(ConsensusContract.GetBlockchainAge), new Empty())).Value; blockchainAge.ShouldBe(age); } var user = starter.CreateNewContractTester(CryptoHelpers.GenerateKeyPair()); await user.SetBlockchainAgeAsync(age + 100); }
public async Task CallContract_Test() { var callerKeyPair = CryptoHelper.GenerateKeyPair(); var tester = new ContractTester <ContractTestAElfModule>(ChainId, callerKeyPair); await tester.InitialChainAsync(list => { list.AddGenesisSmartContract( ConsensusContractCode, ConsensusSmartContractAddressNameProvider.Name); list.AddGenesisSmartContract( TokenContractCode, TokenSmartContractAddressNameProvider.Name); }); var tokenContractAddress = tester.GetContractAddress(TokenSmartContractAddressNameProvider.Name); var bytes = await tester.CallContractMethodAsync(tokenContractAddress, nameof(TokenContractContainer.TokenContractStub.GetBalance), new GetBalanceInput { Symbol = "ELF", Owner = tester.GetCallOwnerAddress(), }); var balanceOutput = GetBalanceOutput.Parser.ParseFrom(bytes); Assert.Equal(0L, balanceOutput.Balance); }
internal async Task <AuthorityInfo> GetMethodFeeController <T>( ContractTester <T> tester, Address genesisContractAddress) where T : ContractTestAElfModule { var methodFeeControllerByteString = await tester.CallContractMethodAsync(genesisContractAddress, nameof(BasicContractZeroContainer.BasicContractZeroStub.GetMethodFeeController), new Empty()); return(AuthorityInfo.Parser.ParseFrom(methodFeeControllerByteString)); }
public static async Task <VotingRecord> GetVotingRecord( this ContractTester <DPoSContractTestAElfModule> contractTester, Hash txId) { var bytes = await contractTester.CallContractMethodAsync(contractTester.GetConsensusContractAddress(), nameof(ConsensusContract.GetVotingRecord), txId); return(VotingRecord.Parser.ParseFrom(bytes)); }
public static async Task <ValidationResult> ValidateConsensusAfterExecutionAsync( this ContractTester <DPoSSideChainTestAElfModule> tester, DPoSHeaderInformation information) { var bytes = await tester.CallContractMethodAsync(tester.GetConsensusContractAddress(), ConsensusConsts.ValidateConsensusAfterExecution, information); return(ValidationResult.Parser.ParseFrom(bytes)); }
public static async Task <long> GetLIBOffset(this ContractTester <DPoSContractTestAElfModule> miner) { return(SInt64Value.Parser.ParseFrom((await miner.CallContractMethodAsync( miner.GetConsensusContractAddress(), nameof(ConsensusContract.GetLIBOffset), new Empty() ))).Value); }
public static async Task <Candidates> GetCandidatesAsync( this ContractTester <DPoSContractTestAElfModule> contractTester) { var bytes = await contractTester.CallContractMethodAsync(contractTester.GetConsensusContractAddress(), nameof(ConsensusContract.GetCandidates), new Empty()); return(Candidates.Parser.ParseFrom(bytes)); }
public static async Task <DPoSHeaderInformation> GetInformationToUpdateConsensusAsync( this ContractTester <DPoSContractTestAElfModule> tester, DPoSTriggerInformation triggerInformation, DateTime dateTime) { var bytes = await tester.CallContractMethodAsync(tester.GetConsensusContractAddress(), ConsensusConsts.GetInformationToUpdateConsensus, triggerInformation, dateTime); return(DPoSHeaderInformation.Parser.ParseFrom(bytes)); }
protected async Task <Address> GetGenesisAddressAsync(ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract) { var organizationAddress = Address.Parser.ParseFrom(await tester.CallContractMethodAsync( parliamentContract, nameof(ParliamentContractContainer.ParliamentContractStub.GetDefaultOrganizationAddress), new Empty())); return(organizationAddress); }
public static async Task <LongList> CheckDividendsOfPreviousTerm( this ContractTester <DPoSContractTestAElfModule> contractTester) { var bytes = await contractTester.CallContractMethodAsync( contractTester.GetDividendsContractAddress(), nameof(DividendContract.CheckDividendsOfPreviousTerm), new Empty()); return(LongList.Parser.ParseFrom(bytes)); }
public static async Task <Tickets> GetTicketsInformationAsync( this ContractTester <DPoSContractTestAElfModule> contractTester) { var bytes = await contractTester.CallContractMethodAsync(contractTester.GetConsensusContractAddress(), nameof(ConsensusContract.GetTicketsInformation), new PublicKey() { Hex = contractTester.PublicKey }); return(Tickets.Parser.ParseFrom(bytes)); }
internal async Task <long> GetParentChainHeight( ContractTester <MultiTokenContractCrossChainTestAElfModule> tester, Address sideCrossChainContract) { var result = await tester.CallContractMethodAsync(sideCrossChainContract, nameof(CrossChainContractContainer.CrossChainContractStub .GetParentChainHeight), new Empty()); var height = Int64Value.Parser.ParseFrom(result); return(height.Value); }
internal async Task <long> GetSideChainHeight(int chainId) { var result = await MainChainTester.CallContractMethodAsync(CrossChainContractAddress, nameof(CrossChainContractContainer.CrossChainContractStub .GetSideChainHeight), new Int32Value { Value = chainId }); var height = Int64Value.Parser.ParseFrom(result); return(height.Value); }
public static async Task <long> GetBalanceAsync(this ContractTester <MultiTokenContractTestAElfModule> contractTester, Address targetAddress) { var balanceOutput = GetBalanceOutput.Parser.ParseFrom( await contractTester.CallContractMethodAsync(contractTester.GetTokenContractAddress(), nameof(TokenContract.GetBalance), new GetBalanceInput { Owner = targetAddress, Symbol = "ELF" })); return(balanceOutput.Balance); }
protected async Task ApproveBalanceAsync(long amount) { var callOwner = Address.FromPublicKey(MainChainTester.KeyPair.PublicKey); var approveResult = await MainChainTester.ExecuteContractWithMiningAsync(TokenContractAddress, nameof(TokenContractContainer.TokenContractStub.Approve), new ApproveInput { Spender = CrossChainContractAddress, Symbol = "ELF", Amount = amount }); approveResult.Status.ShouldBe(TransactionResultStatus.Mined); await MainChainTester.CallContractMethodAsync(TokenContractAddress, nameof(TokenContractContainer.TokenContractStub.GetAllowance), new GetAllowanceInput { Symbol = "ELF", Owner = callOwner, Spender = CrossChainContractAddress }); }
public static async Task <List <Transaction> > GenerateConsensusTransactionsAsync( this ContractTester <DPoSContractTestAElfModule> tester, DPoSTriggerInformation triggerInformation) { var bytes = await tester.CallContractMethodAsync(tester.GetConsensusContractAddress(), ConsensusConsts.GenerateConsensusTransactions, triggerInformation); var txs = TransactionList.Parser.ParseFrom(bytes).Transactions.ToList(); tester.SignTransaction(ref txs, tester.KeyPair); tester.SupplyTransactionParameters(ref txs); return(txs); }
public static async Task <ConsensusCommand> GetConsensusCommandAsync( this ContractTester <DPoSContractTestAElfModule> tester, Timestamp timestamp) { var commandInput = new CommandInput { PublicKey = ByteString.CopyFrom(tester.KeyPair.PublicKey), }; var bytes = await tester.CallContractMethodAsync( tester.GetConsensusContractAddress(), // Usually the second contract is consensus contract. ConsensusConsts.GetConsensusCommand, commandInput, timestamp.ToDateTime()); return(ConsensusCommand.Parser.ParseFrom(bytes)); }
public static async Task <ConsensusCommand> GetConsensusCommandAsync( this ContractTester <DPoSSideChainTestAElfModule> tester, Timestamp timestamp = null) { var triggerInformation = new DPoSTriggerInformation { PublicKey = ByteString.CopyFrom(tester.KeyPair.PublicKey), }; var bytes = await tester.CallContractMethodAsync( tester.GetConsensusContractAddress(), // Usually the second contract is consensus contract. ConsensusConsts.GetConsensusCommand, triggerInformation); return(ConsensusCommand.Parser.ParseFrom(bytes)); }
public static async Task <Tickets> GetPageableNotWithdrawnTicketsInfo( this ContractTester <DPoSContractTestAElfModule> contractTester, string publicKey, int startIndex, int length) { var bytes = await contractTester.CallContractMethodAsync(contractTester.GetConsensusContractAddress(), nameof(ConsensusContract.GetPageableNotWithdrawnTicketsInfo), new PageableTicketsInfoInput() { PublicKey = publicKey, Start = startIndex, Length = length }); return(Tickets.Parser.ParseFrom(bytes)); }
public static async Task <Block> GenerateConsensusTransactionsAndMineABlockAsync( this ContractTester <DPoSContractTestAElfModule> tester, DPoSTriggerInformation triggerInformation, params ContractTester <DPoSContractTestAElfModule>[] testersGonnaExecuteThisBlock) { var bytes = await tester.CallContractMethodAsync(tester.GetConsensusContractAddress(), ConsensusConsts.GenerateConsensusTransactions, triggerInformation); var txs = TransactionList.Parser.ParseFrom(bytes).Transactions.ToList(); tester.SignTransaction(ref txs, tester.KeyPair); tester.SupplyTransactionParameters(ref txs); var block = await tester.MineAsync(txs); foreach (var contractTester in testersGonnaExecuteThisBlock) { await contractTester.ExecuteBlock(block, txs); } return(block); }
public static async Task <ByteString> CallConsensusContractMethodAsync( this ContractTester <DPoSSideChainTestAElfModule> contractTester, string methodName, IMessage input) { return(await contractTester.CallContractMethodAsync(contractTester.GetConsensusContractAddress(), methodName, input)); }
public async Task Get_RoundInformation() { //query return null { var input = new SInt64Value { Value = 2 }; var roundInformation = await Starter.CallContractMethodAsync(Starter.GetConsensusContractAddress(), nameof(ConsensusContract.GetRoundInformation), input); var round = Round.Parser.ParseFrom(roundInformation); round.ShouldBe(new Round()); } //query with result { var input = new SInt64Value { Value = 1 }; var roundInformation = await Starter.CallContractMethodAsync(Starter.GetConsensusContractAddress(), nameof(ConsensusContract.GetRoundInformation), input); var round = Round.Parser.ParseFrom(roundInformation); round.ShouldNotBeNull(); round.RoundNumber.ShouldBe(1); round.RealTimeMinersInformation.Count.ShouldBe(3); } }
public async Task Withdraw_By_TransactionId() { const int lockTime = 100; const long pocketMoney = 10000L; var candidate = (await Starter.GenerateCandidatesAsync(1))[0]; var voters = await Starter.GenerateVotersAsync(2, pocketMoney); var txResult = await voters[0].Vote(candidate.PublicKey, Amount, lockTime); txResult.Status.ShouldBe(TransactionResultStatus.Mined); var blockAge = SInt64Value.Parser.ParseFrom(await Starter.CallContractMethodAsync( Starter.GetConsensusContractAddress(), nameof(ConsensusContract.GetBlockchainAge), new Empty())).Value; var ticketsOfCandidate = await candidate.GetTicketsInformationAsync(); ticketsOfCandidate.ObtainedTickets.ShouldBe(Amount); var ticketsOfVoter = await voters[0].GetTicketsInformationAsync(); ticketsOfVoter.VotedTickets.ShouldBe(Amount); //Change term await Miners.ChangeTermAsync(1); // UnlockAge > CurrentAge var txId = Hash.Parser.ParseFrom(txResult.ReturnValue); var withdrawResult1 = await voters[0] .ExecuteConsensusContractMethodWithMiningAsync( nameof(ConsensusContract.WithdrawByTransactionId), txId); withdrawResult1.Status.ShouldBe(TransactionResultStatus.Failed); withdrawResult1.Error.Contains(ContractErrorCode.Message[ContractErrorCode.InvalidOperation]) .ShouldBeTrue(); await Starter.SetBlockchainAgeAsync(blockAge + lockTime); //Withdraw by other voter var withdrawResult2 = await voters[1] .ExecuteConsensusContractMethodWithMiningAsync(nameof(ConsensusContract.WithdrawByTransactionId), txId); withdrawResult2.Status.ShouldBe(TransactionResultStatus.Failed); withdrawResult2.Error.Contains(ContractErrorCode.Message[ContractErrorCode.NoPermission]).ShouldBeTrue(); //Withdrawn var withdrawResult3 = await voters[0] .ExecuteConsensusContractMethodWithMiningAsync(nameof(ConsensusContract.WithdrawByTransactionId), txId); withdrawResult3.Status.ShouldBe(TransactionResultStatus.Mined); //Check withdrawal time and unlock age var votingRecord = await voters[0].GetVotingRecord(txResult.TransactionId); votingRecord.UnlockAge.ShouldBe(blockAge + lockTime); //Check candidate & voter tickets ticketsOfCandidate = await candidate.GetTicketsInformationAsync(); ticketsOfCandidate.ObtainedTickets.ShouldBe(0L); ticketsOfVoter = await voters[0].GetTicketsInformationAsync(); ticketsOfVoter.VotedTickets.ShouldBe(0L); //Check voter balance var balanceResult = await Starter.GetBalanceAsync(voters[0].GetCallOwnerAddress()); balanceResult.ShouldBe(10000L); //Has already withdrawn var withdrawResult4 = await voters[0] .ExecuteConsensusContractMethodWithMiningAsync(nameof(ConsensusContract.WithdrawByTransactionId), txId); withdrawResult4.Status.ShouldBe(TransactionResultStatus.Failed); withdrawResult4.Error.Contains(ContractErrorCode.Message[ContractErrorCode.InvalidOperation]) .ShouldBeTrue(); }