/// <summary>
/// Generate encrypted messages and put them to round information.
/// </summary>
/// <returns></returns>
private async Task <Dictionary <string, AElfConsensusTriggerInformation> > GenerateEncryptedMessagesAsync()
{
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.FromString("randomHashes")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
InValue = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
foreach (var minerInRound in firstRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order))
{
var currentKeyPair = InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var tester = GetAEDPoSContractStub(currentKeyPair);
var headerInformation = new AElfConsensusHeaderInformation();
headerInformation.MergeFrom(
(await AEDPoSContractStub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).Value);
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await tester.UpdateValue.SendAsync(toUpdate);
}
return(triggers);
}
private async Task RunMiningProcess(int roundsCount)
{
for (var count = 0; count < roundsCount; count++)
{
var currentRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.FromString($"random{count}")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(
i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
// Exactly one round except extra block time slot.
foreach (var minerInRound in currentRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order))
{
var currentKeyPair =
InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var tester = GetAEDPoSContractStub(currentKeyPair);
var headerInformation =
(await tester.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).ToConsensusHeaderInformation();
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await tester.UpdateValue.SendAsync(toUpdate);
for (var i = 0; i < 8; i++)
{
await tester.UpdateTinyBlockInformation.SendAsync(new TinyBlockInput
{
ActualMiningTime = TimestampHelper.GetUtcNow(),
RoundId = currentRound.RoundId
});
}
}
currentRound.GenerateNextRoundInformation(TimestampHelper.GetUtcNow(), BlockchainStartTimestamp,
out var nextRound);
await AEDPoSContractStub.NextRound.SendAsync(nextRound);
for (var i = 0; i < 8; i++)
{
await AEDPoSContractStub.UpdateTinyBlockInformation.SendAsync(new TinyBlockInput
{
ActualMiningTime = TimestampHelper.GetUtcNow(),
RoundId = currentRound.RoundId
});
}
}
}
public async Task ConsensusContract_GetPreviousMinerList()
{
await ElectionContract_GetVictories_ValidCandidatesEnough_Test();
await ProduceBlocks(BootMinerKeyPair, 1, true);
var previousMiners = await AEDPoSContractStub.GetPreviousMinerList.CallAsync(new Empty());
var previousMinersPubkey = previousMiners.Pubkeys.Select(o => o.ToHex()).OrderBy(o => o).ToList();
var initialMinersPubkey = InitialCoreDataCenterKeyPairs.Select(o => o.PublicKey.ToHex()).OrderBy(o => o).ToList();
previousMinersPubkey.ShouldBe(initialMinersPubkey);
}
public async Task UpdateCoefficient_NotChange_Test()
{
//invalid setting
var tokenContractImplStub = GetTokenContractImplTester(InitialCoreDataCenterKeyPairs.Last());
var txResult =
await tokenContractImplStub.UpdateCoefficientsForContract.SendAsync(new UpdateCoefficientsInput());
txResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
txResult = await tokenContractImplStub.UpdateCoefficientsForSender.SendAsync(new UpdateCoefficientsInput());
txResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
}
protected async Task InitializeElection()
{
var minerList = InitialCoreDataCenterKeyPairs.Select(o => o.PublicKey.ToHex()).ToArray();
var result = await ElectionContractStub.InitialElectionContract.SendAsync(new InitialElectionContractInput
{
MaximumLockTime = 1080 * 86400,
MinimumLockTime = 90 * 86400,
TimeEachTerm = EconomicContractsTestConstants.TimeEachTerm,
MinerList = { minerList },
MinerIncreaseInterval = EconomicContractsTestConstants.MinerIncreaseInterval
});
CheckResult(result.TransactionResult);
}
public async Task ElectionContract_GetVictories_NoCandidate_Test()
{
// To get previous round information.
await NextRound(BootMinerKeyPair);
var victories = (await ElectionContractStub.GetVictories.CallAsync(new Empty())).Value
.Select(p => p.ToHex()).ToList();
// Same as initial miners.
victories.Count.ShouldBe(EconomicContractsTestConstants.InitialCoreDataCenterCount);
foreach (var initialMiner in InitialCoreDataCenterKeyPairs.Select(kp => kp.PublicKey.ToHex()))
{
victories.ShouldContain(initialMiner);
}
}
GenerateConsensusInitializationCallList()
{
var consensusContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
consensusContractCallList.Add(nameof(AEDPoSContractStub.InitialAElfConsensusContract), new InitialAElfConsensusContractInput
{
PeriodSeconds = 604800L,
MinerIncreaseInterval = 31536000
});
consensusContractCallList.Add(nameof(AEDPoSContractStub.FirstRound), new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
}.GenerateFirstRoundOfNewTerm(4000, TimestampHelper.GetUtcNow()));
return(consensusContractCallList);
}
public async Task DecryptMessage_Test()
{
var previousTriggers = await GenerateEncryptedMessagesAsync();
await BootMinerChangeRoundAsync();
var currentRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.FromString("randomHashes")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
RandomHash = randomHashes[i],
PreviousRandomHash = previousTriggers[InitialCoreDataCenterKeyPairs[i].PublicKey.ToHex()].RandomHash
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
// Just `MinimumCount + 1` miners produce blocks.
foreach (var minerInRound in currentRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order)
.Take(MinimumCount + 1))
{
var currentKeyPair = InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var tester = GetAEDPoSContractStub(currentKeyPair);
var headerInformation = new AElfConsensusHeaderInformation();
headerInformation.MergeFrom(
(await AEDPoSContractStub.GetInformationToUpdateConsensus.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).Value);
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await tester.UpdateValue.SendAsync(toUpdate);
}
// Won't pass because currently we postpone the revealing of in values to extra block time slot.
// But in values all filled.
// var secondRound = await BootMiner.GetCurrentRoundInformation.CallAsync(new Empty());
// secondRound.RealTimeMinersInformation.Values.Count(v => v.PreviousInValue != null)
// .ShouldBe(AEDPoSContractTestConstants.InitialMinersCount);
}
public void OffChain_DecryptMessage_Test()
{
var message = Hash.FromString("message").ToByteArray();
var secrets =
SecretSharingHelper.EncodeSecret(message, MinimumCount, EconomicContractsTestConstants.InitialCoreDataCenterCount);
var encryptedValues = new Dictionary <string, byte[]>();
var decryptedValues = new Dictionary <string, byte[]>();
var ownerKeyPair = InitialCoreDataCenterKeyPairs[0];
var othersKeyPairs = InitialCoreDataCenterKeyPairs.Skip(1).ToList();
var decryptResult = new byte[0];
var initial = 0;
foreach (var keyPair in othersKeyPairs)
{
var encryptedMessage = CryptoHelper.EncryptMessage(ownerKeyPair.PrivateKey, keyPair.PublicKey,
secrets[initial++]);
encryptedValues.Add(keyPair.PublicKey.ToHex(), encryptedMessage);
}
// Check encrypted values.
encryptedValues.Count.ShouldBe(EconomicContractsTestConstants.InitialCoreDataCenterCount - 1);
// Others try to recover.
foreach (var keyPair in othersKeyPairs)
{
var cipherMessage = encryptedValues[keyPair.PublicKey.ToHex()];
var decryptMessage =
CryptoHelper.DecryptMessage(ownerKeyPair.PublicKey, keyPair.PrivateKey, cipherMessage);
decryptedValues.Add(keyPair.PublicKey.ToHex(), decryptMessage);
if (decryptedValues.Count >= MinimumCount)
{
decryptResult = SecretSharingHelper.DecodeSecret(
decryptedValues.Values.ToList(),
Enumerable.Range(1, MinimumCount).ToList(), MinimumCount);
break;
}
}
decryptResult.ShouldBe(message);
}
private async Task InitializeAElfConsensus()
{
{
await AEDPoSContractStub.InitialAElfConsensusContract.SendAsync(
new InitialAElfConsensusContractInput
{
PeriodSeconds = 604800L,
MinerIncreaseInterval = 31536000
});
}
{
await AEDPoSContractStub.FirstRound.SendAsync(
GenerateFirstRoundOfNewTerm(
new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
},
4000, TimestampHelper.GetUtcNow()));
}
}
protected async Task InitializeAElfConsensus()
{
{
var result = await AEDPoSContractStub.InitialAElfConsensusContract.SendAsync(
new InitialAElfConsensusContractInput
{
TimeEachTerm = 604800L,
MinerIncreaseInterval = 31536000
});
CheckResult(result.TransactionResult);
}
{
var result = await AEDPoSContractStub.FirstRound.SendAsync(
new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
}.GenerateFirstRoundOfNewTerm(4000, TimestampHelper.GetUtcNow()));
CheckResult(result.TransactionResult);
}
}
internal async Task InitializeAElfConsensus()
{
{
var result = await AEDPoSContractStub.InitialAElfConsensusContract.SendAsync(
new InitialAElfConsensusContractInput
{
TimeEachTerm = 604800L,
MinerIncreaseInterval = BingoGameContractTestConstants.MinerIncreaseInterval
});
CheckResult(result.TransactionResult);
}
{
var result = await AEDPoSContractStub.FirstRound.SendAsync(
new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
}.GenerateFirstRoundOfNewTerm(BingoGameContractTestConstants.MiningInterval,
StartTimestamp.ToDateTime()));
CheckResult(result.TransactionResult);
}
}
public async Task AEDPoSContract_ChangeMinersCount_Test()
{
const int termIntervalMin = 31536000 / 60;
var maxCount = ValidationDataCenterKeyPairs.Count;
await InitializeCandidates(maxCount);
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.FromString("randomHashes")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
InValue = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
var voter = GetElectionContractTester(VoterKeyPairs[0]);
foreach (var candidateKeyPair in ValidationDataCenterKeyPairs)
{
var voteResult = await voter.Vote.SendAsync(new VoteMinerInput
{
CandidatePubkey = candidateKeyPair.PublicKey.ToHex(),
Amount = 10 + new Random().Next(1, 10),
EndTimestamp = TimestampHelper.GetUtcNow().AddDays(100)
});
voteResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
}
foreach (var minerInRound in firstRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order))
{
var currentKeyPair = InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var tester = GetAEDPoSContractStub(currentKeyPair);
var headerInformation =
(await AEDPoSContractStub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).ToConsensusHeaderInformation();
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await tester.UpdateValue.SendAsync(toUpdate);
}
var changeTermTime = BlockchainStartTimestamp.ToDateTime();
BlockTimeProvider.SetBlockTime(changeTermTime.ToTimestamp());
var nextTermInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.NextRound,
Pubkey = ByteString.CopyFrom(BootMinerKeyPair.PublicKey)
}.ToBytesValue())).ToConsensusHeaderInformation();
await AEDPoSContractStub.NextRound.SendAsync(nextTermInformation.Round);
changeTermTime = BlockchainStartTimestamp.ToDateTime().AddMinutes(termIntervalMin).AddSeconds(10);
BlockTimeProvider.SetBlockTime(changeTermTime.ToTimestamp());
nextTermInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.NextTerm,
Pubkey = ByteString.CopyFrom(BootMinerKeyPair.PublicKey)
}.ToBytesValue())).ToConsensusHeaderInformation();
var transactionResult = await AEDPoSContractStub.NextTerm.SendAsync(nextTermInformation.Round);
transactionResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
var newMinerStub = GetAEDPoSContractStub(ValidationDataCenterKeyPairs[0]);
var termCount = 0;
var minerCount = 0;
while (minerCount < maxCount)
{
var currentRound = await newMinerStub.GetCurrentRoundInformation.CallAsync(new Empty());
var firstPubKey = currentRound.RealTimeMinersInformation.Keys.First();
newMinerStub = GetAEDPoSContractStub(ValidationDataCenterKeyPairs.First(o => o.PublicKey.ToHex() == firstPubKey));
minerCount = currentRound.RealTimeMinersInformation.Count;
Assert.Equal(AEDPoSContractTestConstants.SupposedMinersCount.Add(termCount.Mul(2)), minerCount);
changeTermTime = BlockchainStartTimestamp.ToDateTime()
.AddMinutes((termCount + 2).Mul(termIntervalMin)).AddSeconds(10);
BlockTimeProvider.SetBlockTime(changeTermTime.ToTimestamp());
var nextRoundInformation = (await newMinerStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.NextTerm,
Pubkey = currentRound.RealTimeMinersInformation.ElementAt(0).Value.Pubkey.ToByteString()
}.ToBytesValue())).ToConsensusHeaderInformation();
await newMinerStub.NextTerm.SendAsync(nextRoundInformation.Round);
termCount++;
}
}
internal async Task <Hash> AEDPoSContract_GetRandomNumber_Test()
{
var order = await AEDPoSContract_RequestRandomNumber_Test();
var currentRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(i => Hash.FromString($"random{i}")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
// Exactly one round except extra block time slot.
foreach (var minerInRound in currentRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order))
{
var currentKeyPair =
InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var stub = GetAEDPoSContractStub(currentKeyPair);
var headerInformation =
(await stub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).ToConsensusHeaderInformation();
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await stub.UpdateValue.SendAsync(toUpdate);
{
var chain = await BlockchainService.GetChainAsync();
if (chain.BestChainHeight < order.BlockHeight)
{
// Not enough.
var transactionResult = (await AEDPoSContractStub.GetRandomNumber.SendAsync(order.TokenHash))
.TransactionResult;
transactionResult.Error.ShouldContain("Still preparing random number.");
}
}
for (var i = 0; i < 7; i++)
{
await stub.UpdateTinyBlockInformation.SendAsync(new TinyBlockInput
{
ActualMiningTime = TimestampHelper.GetUtcNow(),
RoundId = currentRound.RoundId
});
}
}
// Now it's enough.
{
var randomNumber = (await AEDPoSContractStub.GetRandomNumber.SendAsync(order.TokenHash)).Output;
randomNumber.Value.ShouldNotBeEmpty();
}
return(order.TokenHash);
}
public async Task Candidates_NotEnough_Test()
{
//await ElectionContractStub.RegisterElectionVotingEvent.SendAsync(new Empty());
//await InitializeVoters();
await InitializeCandidates(EconomicContractsTestConstants.InitialCoreDataCenterCount);
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.FromString("hash3")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
InValue = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
var voter = GetElectionContractTester(VoterKeyPairs[0]);
foreach (var candidateKeyPair in ValidationDataCenterKeyPairs.Take(EconomicContractsTestConstants
.InitialCoreDataCenterCount))
{
await voter.Vote.SendAsync(new VoteMinerInput
{
CandidatePubkey = candidateKeyPair.PublicKey.ToHex(),
Amount = 100 + new Random().Next(1, 200),
EndTimestamp = TimestampHelper.GetUtcNow().AddDays(100)
});
}
foreach (var minerInRound in firstRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order))
{
var currentKeyPair =
InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var tester = GetAEDPoSContractStub(currentKeyPair);
var headerInformation =
(await AEDPoSContractStub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).ToConsensusHeaderInformation();
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await tester.UpdateValue.SendAsync(toUpdate);
}
var changeTermTime = BlockchainStartTimestamp.ToDateTime()
.AddMinutes(AEDPoSContractTestConstants.TimeEachTerm + 1);
BlockTimeProvider.SetBlockTime(changeTermTime.ToTimestamp());
var nextTermInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.NextTerm,
Pubkey = ByteString.CopyFrom(BootMinerKeyPair.PublicKey)
}.ToBytesValue())).ToConsensusHeaderInformation();
await AEDPoSContractStub.NextTerm.SendAsync(nextTermInformation.Round);
// First candidate cheat others with in value.
var oneCandidate = GetAEDPoSContractStub(ValidationDataCenterKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractStub(ValidationDataCenterKeyPairs[1]);
var randomHash = Hash.FromString("hash5");
var informationOfSecondRound = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.UpdateValue,
PreviousInValue = Hash.Empty,
InValue = randomHash,
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey)
}.ToBytesValue())).ToConsensusHeaderInformation();
var updateResult = await oneCandidate.UpdateValue.SendAsync(
informationOfSecondRound.Round.ExtractInformationToUpdateConsensus(ValidationDataCenterKeyPairs[0]
.PublicKey.ToHex()));
var thirdRoundStartTime = changeTermTime.AddMinutes(AEDPoSContractTestConstants.TimeEachTerm + 2);
BlockTimeProvider.SetBlockTime(thirdRoundStartTime.ToTimestamp());
var thirdRound = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.NextRound,
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey)
}.ToBytesValue())).ToConsensusHeaderInformation().Round;
await oneCandidate.NextRound.SendAsync(thirdRound);
var cheatInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(
new AElfConsensusTriggerInformation
{
Behaviour = AElfConsensusBehaviour.UpdateValue,
PreviousInValue = Hash.FromMessage(randomHash), // Not same as before.
InValue = Hash.FromString("InValue"), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey)
}.ToBytesValue())).ToConsensusHeaderInformation();
await oneCandidate.UpdateValue.SendAsync(
cheatInformation.Round.ExtractInformationToUpdateConsensus(ValidationDataCenterKeyPairs[0].PublicKey
.ToHex()));
}
