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); }
public async Task InitialChainTest() { var tester = new ContractTester <ContractTestAElfModule>(); await tester.InitialChainAsync(); var chain = await tester.GetChainAsync(); var longestChainHeight = chain.LongestChainHeight; Assert.Equal(1, longestChainHeight); }
public static async Task <TransactionResult> TransferTokenAsync( this ContractTester <DPoSContractTestAElfModule> contractTester, Address receiverAddress, long amount) { return(await contractTester.ExecuteTokenContractMethodWithMiningAsync(nameof(TokenContract.Transfer), new TransferInput { To = receiverAddress, Amount = amount, Symbol = "ELF", })); }
public static async Task <TransactionResult> Vote(this ContractTester <DPoSContractTestAElfModule> voter, string publicKey, long amount, int lockTime) { return(await voter.ExecuteConsensusContractMethodWithMiningAsync(nameof(ConsensusContract.Vote), new VoteInput() { CandidatePublicKey = publicKey, Amount = amount, LockTime = lockTime })); }
internal async Task <TransactionResult> ApproveWithKeyPairAsync( ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, Hash proposalId, ECKeyPair ecKeyPair) { var testerWithMiner = tester.CreateNewContractTester(ecKeyPair); return(await testerWithMiner.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Approve), new ApproveInput { ProposalId = proposalId })); }
public ParliamentContractPrivilegeTestBase() { var mainChainId = ChainHelper.ConvertBase58ToChainId("AELF"); var chainId = ChainHelper.GetChainId(1); Tester = new ContractTester<ParliamentContractPrivilegeTestAElfModule>(chainId,SampleECKeyPairs.KeyPairs[1]); AsyncHelper.RunSync(() => Tester.InitialChainAsyncWithAuthAsync(Tester.GetSideChainSystemContract( Tester.GetCallOwnerAddress(), mainChainId,"STA",out TotalSupply,Tester.GetCallOwnerAddress()))); ParliamentAddress = Tester.GetContractAddress(ParliamentSmartContractAddressNameProvider.Name); TokenContractAddress = Tester.GetContractAddress(TokenSmartContractAddressNameProvider.Name); }
public ElectionTest() { // The starter initial chain and tokens. Starter = new ContractTester <DPoSContractTestAElfModule>(); var minersKeyPairs = Enumerable.Range(0, MinersCount - 1).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList(); minersKeyPairs.Add(Starter.KeyPair); AsyncHelper.RunSync(() => Starter.InitialChainAndTokenAsync(minersKeyPairs)); Miners = Enumerable.Range(0, MinersCount) .Select(i => Starter.CreateNewContractTester(minersKeyPairs[i])).ToList(); }
public ViewTest() { // The starter initial chain and tokens. Starter = new ContractTester <DPoSContractTestAElfModule>(); MinersKeyPairs = Enumerable.Range(0, MinersCount - 1).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList(); // Enable Start to use SetBlockchainAge method. MinersKeyPairs.Add(Starter.KeyPair); AsyncHelper.RunSync(() => Starter.InitialChainAndTokenAsync(MinersKeyPairs)); MinerList = Enumerable.Range(0, MinersCount) .Select(i => Starter.CreateNewContractTester(MinersKeyPairs[i])).ToList(); }
public MultiTokenContractCrossChainTestBase() { MainChainId = ChainHelper.ConvertBase58ToChainId("AELF"); MainChainTester = new ContractTester <MultiTokenContractCrossChainTestAElfModule>(MainChainId, SampleECKeyPairs.KeyPairs[1]); AsyncHelper.RunSync(() => MainChainTester.InitialChainAsyncWithAuthAsync(MainChainTester.GetDefaultContractTypes(MainChainTester.GetCallOwnerAddress(), out TotalSupply, out _, out BalanceOfStarter))); BasicContractZeroAddress = MainChainTester.GetZeroContractAddress(); CrossChainContractAddress = MainChainTester.GetContractAddress(CrossChainSmartContractAddressNameProvider.Name); TokenContractAddress = MainChainTester.GetContractAddress(TokenSmartContractAddressNameProvider.Name); ParliamentAddress = MainChainTester.GetContractAddress(ParliamentAuthSmartContractAddressNameProvider.Name); }
public static async Task InitialChainAndTokenAsync(this ContractTester <FeeReceiverContractTestAElfModule> starter) { var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList(); tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.Create), new CreateInput { Symbol = "ELF", Decimals = 2, IsBurnable = true, TokenName = "elf token", TotalSupply = 1000_0000L, Issuer = starter.GetCallOwnerAddress() });
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); }
internal async Task <Address> DeployAsync(ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, ContractDeploymentInput contractDeploymentInput) { var proposingTxResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress, nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput); var proposalCreatedEvent = proposingTxResult.Logs.FirstOrDefault(l => l.Name.Contains(nameof(ProposalCreated))); if (proposalCreatedEvent == null) { return(null); } var proposalId = ProposalCreated.Parser .ParseFrom(proposalCreatedEvent.NonIndexed) .ProposalId; var proposedContractInputHash = ContractProposed.Parser .ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed) .ProposedContractInputHash; await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId); // release contract code and trigger code check proposal var releaseApprovedContractTxResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress, nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput { ProposalId = proposalId, ProposedContractInputHash = proposedContractInputHash }); var codeCheckProposalId = ProposalCreated.Parser .ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))) .NonIndexed).ProposalId; await ApproveWithMinersAsync(Tester, ParliamentAddress, codeCheckProposalId); // release code check proposal and deployment completes var deploymentResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress, nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract), new ReleaseContractInput { ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId }); var deploymentEvent = deploymentResult.Logs.FirstOrDefault(l => l.Name.Contains(nameof(ContractDeployed))); var address = deploymentEvent != null ? ContractDeployed.Parser.ParseFrom(deploymentEvent.NonIndexed).Address : null; return(address); }
protected async Task <Address> CreateOrganizationAsync(ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract) { var createOrganizationInput = new CreateOrganizationInput { ReleaseThreshold = 20000 / tester.InitialMinerList.Count }; var transactionResult = await tester.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.CreateOrganization), createOrganizationInput); return(Address.Parser.ParseFrom(transactionResult.ReturnValue)); }
public static async Task InitialChainAndTokenAsync(this ContractTester <ResourceContractTestAElfModule> starter) { var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList(); tokenContractCallList.Add(nameof(TokenContract.CreateNativeToken), new CreateNativeTokenInput { Symbol = "ELF", Decimals = 2, IsBurnable = true, TokenName = "elf token", TotalSupply = 1000_0000L, Issuer = starter.GetCallOwnerAddress(), LockWhiteSystemContractNameList = { ConsensusSmartContractAddressNameProvider.Name } });
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 <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 <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 <TransactionResult> AnnounceElectionAsync( this ContractTester <DPoSContractTestAElfModule> candidate, string alias = null) { if (alias == null) { alias = candidate.KeyPair.PublicKey.ToHex().Substring(0, DPoSContractConsts.AliasLimit); } return(await candidate.ExecuteContractWithMiningAsync(candidate.GetConsensusContractAddress(), nameof(ConsensusContract.AnnounceElection), new Alias() { Value = alias })); }
/// <summary> /// Default pocket money is 10000L. /// </summary> /// <param name="starter"></param> /// <param name="number"></param> /// <param name="pocketMoney"></param> /// <returns></returns> public static async Task <List <ContractTester <DPoSContractTestAElfModule> > > GenerateVotersAsync( this ContractTester <DPoSContractTestAElfModule> starter, int number = 1, long pocketMoney = 10000L) { var voters = new List <ContractTester <DPoSContractTestAElfModule> >(); for (var i = 0; i < number; i++) { var voter = starter.CreateNewContractTester(CryptoHelpers.GenerateKeyPair()); await starter.TransferTokenAsync(voter.GetCallOwnerAddress(), pocketMoney); voters.Add(voter); } return(voters); }
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 void InitialTesters() { for (var i = 0; i < MinersCount; i++) { var keyPair = CryptoHelpers.GenerateKeyPair(); MinersKeyPairs.Add(keyPair); var tester = new ContractTester <DPoSSideChainTestAElfModule>(ChainId, keyPair); AsyncHelper.RunSync( () => tester.InitialSideChainAsync()); Testers.Add(tester); } DPoSSideChainContractAddress = Testers[0].GetConsensusContractAddress(); }
public static async Task <TransactionResult> Unlock(this ContractTester <MultiTokenContractTestAElfModule> contractTester, long amount, Hash lockId) { return(await contractTester.ExecuteContractWithMiningAsync(contractTester.GetTokenContractAddress(), nameof(TokenContract.Unlock), new UnlockInput { From = contractTester.GetCallOwnerAddress(), To = contractTester.GetConsensusContractAddress(), Amount = amount, Symbol = "ELF", LockId = lockId, Usage = "Testing." })); }
protected async Task ApproveWithMinersAsync( ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, Hash proposalId) { var tester0 = tester.CreateNewContractTester(Tester.InitialMinerList[0]); await tester0.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentContractContainer.ParliamentContractStub.Approve), proposalId); var tester1 = tester.CreateNewContractTester(Tester.InitialMinerList[1]); await tester1.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentContractContainer.ParliamentContractStub.Approve), proposalId); var tester2 = tester.CreateNewContractTester(Tester.InitialMinerList[2]); await tester2.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentContractContainer.ParliamentContractStub.Approve), proposalId); }
protected void StartSideChain(int chainId, long height) { SideChainTester = new ContractTester <MultiTokenContractCrossChainTestAElfModule>(chainId, SampleECKeyPairs.KeyPairs[0]); AsyncHelper.RunSync(() => SideChainTester.InitialCustomizedChainAsync(chainId, configureSmartContract: SideChainTester.GetSideChainSystemContract( SideChainTester.GetCallOwnerAddress(), MainChainId, out TotalSupply, SideChainTester.GetCallOwnerAddress(), height))); SideBasicContractZeroAddress = SideChainTester.GetZeroContractAddress(); SideCrossChainContractAddress = SideChainTester.GetContractAddress(CrossChainSmartContractAddressNameProvider.Name); SideTokenContractAddress = SideChainTester.GetContractAddress(TokenSmartContractAddressNameProvider.Name); SideParliamentAddress = SideChainTester.GetContractAddress(ParliamentAuthSmartContractAddressNameProvider.Name); SideConsensusAddress = SideChainTester.GetContractAddress(ConsensusSmartContractAddressNameProvider.Name); }
public LockTest() { Starter = new ContractTester <MultiTokenContractTestAElfModule>(); var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList(); tokenContractCallList.Add(nameof(TokenContract.CreateNativeToken), new CreateNativeTokenInput { Symbol = "ELF", Decimals = 2, IsBurnable = true, TokenName = "elf token", Issuer = Starter.GetCallOwnerAddress(), TotalSupply = DPoSContractConsts.LockTokenForElection * 100, LockWhiteSystemContractNameList = { ConsensusSmartContractAddressNameProvider.Name } }); tokenContractCallList.Add(nameof(TokenContract.IssueNativeToken), new IssueNativeTokenInput { Symbol = "ELF", Amount = DPoSContractConsts.LockTokenForElection * 20, ToSystemContractName = DividendSmartContractAddressNameProvider.Name, Memo = "Issue ", }); // For testing. tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput { Symbol = "ELF", Amount = DPoSContractConsts.LockTokenForElection * 80, To = Starter.GetCallOwnerAddress(), Memo = "Set dividends.", }); AsyncHelper.RunSync(() => Starter.InitialChainAsync(list => { list.AddGenesisSmartContract <DividendContract>(DividendSmartContractAddressNameProvider.Name); //test extension AddGenesisSmartContract<T>(this List<GenesisSmartContractDto> genesisSmartContracts, Hash name, Action<SystemTransactionMethodCallList> action) void Action(SystemContractDeploymentInput.Types.SystemTransactionMethodCallList x) { x.Value.Add(tokenContractCallList.Value); } list.AddGenesisSmartContract <TokenContract>(TokenSmartContractAddressNameProvider.Name, Action); })); }
protected async Task <TransactionResult> ApproveWithMinersAsync( ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, Hash proposalId) { var tester0 = tester.CreateNewContractTester(Tester.InitialMinerList[0]); await tester0.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Approve), new ApproveInput { ProposalId = proposalId }); var tester1 = tester.CreateNewContractTester(Tester.InitialMinerList[1]); var txResult2 = await tester1.ExecuteContractWithMiningAsync(parliamentContract, nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Approve), new ApproveInput { ProposalId = proposalId }); return(txResult2); }
protected async Task <Hash> CreateProposalAsync(ContractTester <ConfigurationContractTestAElfModule> tester, Address contractAddress, Address organizationAddress, string methodName, IMessage input) { var configContract = tester.GetContractAddress(Hash.FromString("AElf.ContractNames.Configuration")); var proposal = await tester.ExecuteContractWithMiningAsync(contractAddress, nameof(AuthorizationContractContainer.AuthorizationContractStub.CreateProposal), new CreateProposalInput { ContractMethodName = methodName, ExpiredTime = DateTime.UtcNow.AddDays(1).ToTimestamp(), Params = input.ToByteString(), ToAddress = configContract, OrganizationAddress = organizationAddress }); var proposalId = Hash.Parser.ParseFrom(proposal.ReturnValue); return(proposalId); }
protected void StartSideChain() { var chainId = ChainHelper.ConvertBase58ToChainId("Side"); var mainChainId = Tester.GetChainAsync().Result.Id; SideChainTester = new ContractTester <BasicContractZeroTestAElfModule>(chainId, CreatorKeyPair); AsyncHelper.RunSync(() => SideChainTester.InitialCustomizedChainAsync(chainId, configureSmartContract: SideChainTester.GetSideChainSystemContract( SideChainTester.GetCallOwnerAddress(), mainChainId, "STA", out TotalSupply, SideChainTester.GetCallOwnerAddress()))); SideBasicContractZeroAddress = SideChainTester.GetZeroContractAddress(); SideTokenContractAddress = SideChainTester.GetContractAddress(TokenSmartContractAddressNameProvider.Name); SideParliamentAddress = SideChainTester.GetContractAddress(ParliamentSmartContractAddressNameProvider.Name); SideChainMinerTester = SideChainTester.CreateNewContractTester(SideChainTester.InitialMinerList.First()); }
protected async Task <Hash> CreateProposalAsync(ContractTester <BasicContractZeroTestAElfModule> tester, Address contractAddress, Address organizationAddress, string methodName, IMessage input) { var basicContract = tester.GetZeroContractAddress(); // var organizationAddress = await GetGenesisAddressAsync(tester, parliamentContractAddress); var proposal = await tester.ExecuteContractWithMiningAsync(contractAddress, nameof(AuthorizationContractContainer.AuthorizationContractStub.CreateProposal), new CreateProposalInput { ContractMethodName = methodName, ExpiredTime = DateTime.UtcNow.AddDays(1).ToTimestamp(), Params = input.ToByteString(), ToAddress = basicContract, OrganizationAddress = organizationAddress }); var proposalId = Hash.Parser.ParseFrom(proposal.ReturnValue); return(proposalId); }
public void InitialTesters(Timestamp blockchainStartTime) { for (var i = 0; i < MinersCount; i++) { var keyPair = CryptoHelpers.GenerateKeyPair(); MinersKeyPairs.Add(keyPair); } foreach (var minersKeyPair in MinersKeyPairs) { var tester = new ContractTester <DPoSContractTestAElfModule>(ChainId, minersKeyPair); AsyncHelper.RunSync(() => tester.InitialCustomizedChainAsync(MinersKeyPairs.Select(m => m.PublicKey.ToHex()).ToList(), 4000, blockchainStartTime)); Testers.Add(tester); } AsyncHelper.RunSync(() => Testers.RunConsensusAsync(2)); ConsensusContractAddress = Testers[0].GetConsensusContractAddress(); }