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 GetCandidateList_Success()
{
//no candidate
{
var candidates = await Starter.GetCandidatesListAsync();
candidates.Values.Count.ShouldBe(0);
}
//with candidate
{
var candidateInformation = TestUserHelper.GenerateNewUser();
await Starter.TransferTokenAsync(candidateInformation, DPoSContractConsts.LockTokenForElection);
var balance = await Starter.GetBalanceAsync(candidateInformation);
Assert.Equal(DPoSContractConsts.LockTokenForElection, balance);
// The candidate announce election.
var candidate = Starter.CreateNewContractTester(candidateInformation);
await candidate.AnnounceElectionAsync("AElfin");
//Assert
var candidatesList = await candidate.GetCandidatesListAsync();
candidatesList.Values.Count.ShouldBe(1);
}
}
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);
}
public async Task NextTerm_GetNewConsensusInformation_SameMiners()
{
const int minersCount = 3;
var starter = new ContractTester <DPoSContractTestAElfModule>();
var minersKeyPairs = Enumerable.Range(0, minersCount).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
await starter.InitialChainAndTokenAsync(minersKeyPairs, MiningInterval);
var miners = Enumerable.Range(0, minersCount)
.Select(i => starter.CreateNewContractTester(minersKeyPairs[i])).ToList();
// Produce several blocks.
await miners.ProduceNormalBlocks(minersCount);
// Terminate current round then produce several blocks with fake timestamp.
await miners.ChangeRoundAsync();
await miners.ProduceNormalBlocks(minersCount,
DateTime.UtcNow.AddMinutes(ConsensusDPoSConsts.DaysEachTerm + 1).ToTimestamp());
// Able to changer term.
{
var extraBlockMiner = miners.AnyOne();
var timestamp = DateTime.UtcNow.AddMinutes(ConsensusDPoSConsts.DaysEachTerm + 2);
var triggerInformation = GetTriggerInformationForNextTerm(extraBlockMiner.PublicKey);
var consensusInformation = await extraBlockMiner.GetInformationToUpdateConsensusAsync(triggerInformation, timestamp);
Assert.Equal(2L, consensusInformation.Round.TermNumber);
}
}
public async Task RunConsensusTest()
{
const int minersCount = 3;
const int miningInterval = 4000;
var starter = new ContractTester <DPoSContractTestAElfModule>();
var minersKeyPairs = Enumerable.Range(0, minersCount).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
await starter.InitialChainAndTokenAsync(minersKeyPairs, miningInterval, DateTime.UtcNow.ToTimestamp());
var miners = Enumerable.Range(0, minersCount)
.Select(i => starter.CreateNewContractTester(minersKeyPairs[i])).ToList();
await miners.RunConsensusAsync(1);
// Check current round information.
{
var round = await miners.AnyOne().GetCurrentRoundInformationAsync();
Assert.Equal(2L, round.RoundNumber);
}
await miners.RunConsensusAsync(2, true);
// Check current round information.
{
var round = await miners.AnyOne().GetCurrentRoundInformationAsync();
Assert.Equal(4L, round.RoundNumber);
Assert.Equal(2L, round.TermNumber);
}
}
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);
}
public LIBFindingTest()
{
// The starter initial chain and tokens.
Starter = new ContractTester <DPoSContractTestAElfModule>();
var minersKeyPairs = Enumerable.Range(0, MinersCount).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
AsyncHelper.RunSync(() => Starter.InitialChainAndTokenAsync(minersKeyPairs, MiningInterval));
Miners = Enumerable.Range(0, 17)
.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();
}
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
}));
}
/// <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);
}
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());
}
public async Task Announce_Election_Success()
{
// The starter transfer a specific amount of tokens to candidate for further testing.
var candidateInformation = TestUserHelper.GenerateNewUser();
await Starter.TransferTokenAsync(candidateInformation, DPoSContractConsts.LockTokenForElection);
var balance = await Starter.GetBalanceAsync(candidateInformation);
Assert.Equal(DPoSContractConsts.LockTokenForElection, balance);
// The candidate announce election.
var candidate = Starter.CreateNewContractTester(candidateInformation);
var result = await candidate.AnnounceElectionAsync("AElfin");
var candidatesList = await candidate.GetCandidatesListAsync();
// Check the candidates list.
Assert.Contains(candidate.KeyPair.PublicKey.ToHex(), candidatesList.Values.ToList());
}
public static async Task <List <ContractTester <DPoSContractTestAElfModule> > > GenerateCandidatesAsync(
this ContractTester <DPoSContractTestAElfModule> starter, int number)
{
var candidatesKeyPairs = new List <ECKeyPair>();
var candidates = new List <ContractTester <DPoSContractTestAElfModule> >();
var transferTxs = new List <Transaction>();
var announceElectionTxs = new List <Transaction>();
for (var i = 0; i < number; i++)
{
var candidateKeyPair = CryptoHelpers.GenerateKeyPair();
transferTxs.Add(await starter.GenerateTransactionAsync(starter.GetTokenContractAddress(),
nameof(TokenContract.Transfer), starter.KeyPair, new TransferInput
{
To = Address.FromPublicKey(candidateKeyPair.PublicKey),
Amount = DPoSContractConsts.LockTokenForElection,
Symbol = "ELF"
}));
announceElectionTxs.Add(await starter.GenerateTransactionAsync(starter.GetConsensusContractAddress(),
nameof(ConsensusContract.AnnounceElection), candidateKeyPair,
new Alias
{
Value = $"{candidateKeyPair.PublicKey.ToHex().Substring(0, DPoSContractConsts.AliasLimit)}"
}));
candidatesKeyPairs.Add(candidateKeyPair);
}
// Package Transfer txs.
await starter.MineAsync(transferTxs);
// Package AnnounceElection txs.
await starter.MineAsync(announceElectionTxs);
foreach (var candidatesKeyPair in candidatesKeyPairs)
{
candidates.Add(starter.CreateNewContractTester(candidatesKeyPair));
}
return(candidates);
}
public async Task NextTerm_GetConsensusCommand()
{
const int minersCount = 3;
var starter = new ContractTester <DPoSContractTestAElfModule>();
var minersKeyPairs = Enumerable.Range(0, minersCount).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
await starter.InitialChainAndTokenAsync(minersKeyPairs);
var miners = Enumerable.Range(0, minersCount)
.Select(i => starter.CreateNewContractTester(minersKeyPairs[i])).ToList();
// Produce several blocks.
await miners.ProduceNormalBlocks(minersCount);
// Unable to change term.
{
var extraBlockMiner = miners.AnyOne();
var timestamp = DateTime.UtcNow.AddMilliseconds(minersCount * MiningInterval + MiningInterval)
.ToTimestamp();
var command = await extraBlockMiner.GetConsensusCommandAsync(timestamp);
Assert.Equal(DPoSBehaviour.NextRound, DPoSHint.Parser.ParseFrom(command.Hint).Behaviour);
}
// Terminate current round then produce several blocks with fake timestamp.
await miners.ChangeRoundAsync();
await miners.ProduceNormalBlocks(minersCount,
DateTime.UtcNow.AddMinutes(ConsensusDPoSConsts.DaysEachTerm + 1).ToTimestamp());
// Able to changer term.
{
var extraBlockMiner = miners.AnyOne();
var timestamp = DateTime.UtcNow.AddMinutes(ConsensusDPoSConsts.DaysEachTerm + 2).ToTimestamp();
var command = await extraBlockMiner.GetConsensusCommandAsync(timestamp);
Assert.Equal(DPoSBehaviour.NextTerm, DPoSHint.Parser.ParseFrom(command.Hint).Behaviour);
}
}
public async Task CreateContractTester_Test()
{
var tester = new ContractTester <ContractTestAElfModule>();
await tester.InitialChainAsync();
var zeroContractAddress = tester.GetContractAddress(Hash.Empty);
var tx = await tester.GenerateTransactionAsync(zeroContractAddress,
"DeploySmartContract",
new ContractDeploymentInput()
{
Category = SmartContractTestConstants.TestRunnerCategory,
Code = ByteString.CopyFrom(TokenContractCode)
});
await tester.MineAsync(new List <Transaction> {
tx
});
var newTester = tester.CreateNewContractTester(CryptoHelper.GenerateKeyPair());
var chain = await newTester.GetChainAsync();
Assert.Equal(2L, chain.BestChainHeight);
}
public async Task NextTerm_GetNewConsensusInformation_NewMiners()
{
const int minersCount = 3;
var starter = new ContractTester <DPoSContractTestAElfModule>();
var minersKeyPairs = Enumerable.Range(0, minersCount).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
await starter.InitialChainAndTokenAsync(minersKeyPairs);
var initialMiners = Enumerable.Range(0, minersCount)
.Select(i => starter.CreateNewContractTester(minersKeyPairs[i])).ToList();
var voter = (await starter.GenerateVotersAsync()).AnyOne();
var candidates = await starter.GenerateCandidatesAsync(minersCount);
// Vote to candidates.
var voteTxs = new List <Transaction>();
foreach (var candidate in candidates)
{
voteTxs.Add(await voter.GenerateTransactionAsync(
starter.GetConsensusContractAddress(),
nameof(ConsensusContract.Vote),
new VoteInput
{
CandidatePublicKey = candidate.PublicKey,
Amount = 1,
LockTime = 100
}));
}
await initialMiners.MineAsync(voteTxs);
await initialMiners.RunConsensusAsync(1, true);
// Check term number.
{
var round = await starter.GetCurrentRoundInformationAsync();
Assert.Equal(2L, round.TermNumber);
}
// Current term number is 2. So only if the blockchain age is in range (`DaysEachTerm` * 2, `DaysEachTerm` * 3],
// can one miner change term to 3rd term.
await initialMiners.ProduceNormalBlocks(minersCount,
DateTime.UtcNow.AddMinutes(ConsensusDPoSConsts.DaysEachTerm * 2 + 1).ToTimestamp());
var extraBlockMiner = initialMiners.AnyOne();
var timestamp = DateTime.UtcNow.AddMinutes(ConsensusDPoSConsts.DaysEachTerm * 2 + 2);
var triggerInformation = GetTriggerInformationForNextTerm(extraBlockMiner.PublicKey);
var consensusInformation =
await extraBlockMiner.GetInformationToUpdateConsensusAsync(triggerInformation, timestamp);
// Term changed.
Assert.Equal(3L, consensusInformation.Round.TermNumber);
// Miners changed to candidates.
var miners = consensusInformation.Round.RealTimeMinersInformation.Keys.ToList().ToMiners();
Assert.Equal(candidates.Select(m => m.PublicKey).ToList().ToMiners().GetMinersHash(),
miners.GetMinersHash());
}
