Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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);
            }
        }
Ejemplo n.º 4
0
        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);
        }
 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);
            }
        }