public void ActivationQueueSorting()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
int mockActivations = 10;
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
for (int index = 0; index < mockActivations; index++)
{
MockDeposit(testServiceProvider, state, index);
state.Validators[index].SetEligible(currentEpoch + Epoch.One);
}
// eligibility must be finalized
state.SetFinalizedCheckpoint(new Checkpoint(currentEpoch + new Epoch(2), Root.Zero));
// give the last priority over the others
state.Validators[mockActivations - 1].SetEligible(currentEpoch);
// make sure we are hitting the churn
int churnLimit = (int)beaconStateAccessor.GetValidatorChurnLimit(state);
mockActivations.ShouldBeGreaterThan(churnLimit);
// Act
RunProcessRegistryUpdates(testServiceProvider, state);
// Assert
//# the first got in as second
state.Validators[0].ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
//# the prioritized got in as first
state.Validators[mockActivations - 1].ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
//# the second last is at the end of the queue, and did not make the churn,
//# hence is not assigned an activation_epoch yet.
state.Validators[mockActivations - 2].ActivationEpoch.ShouldBe(chainConstants.FarFutureEpoch);
//# the one at churn_limit - 1 did not make it, it was out-prioritized
state.Validators[churnLimit - 1].ActivationEpoch.ShouldBe(chainConstants.FarFutureEpoch);
//# but the the one in front of the above did
state.Validators[churnLimit - 2].ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
}
public void BasicActivation()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
int index = 0;
MockDeposit(testServiceProvider, state, index);
for (ulong count = (ulong)0; count < (ulong)timeParameters.MaximumSeedLookahead + 1; count++)
{
TestState.NextEpoch(testServiceProvider, state);
}
// eligibility must be finalized
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
state.SetFinalizedCheckpoint(new Checkpoint(currentEpoch + new Epoch(2), Root.Zero));
// Act
RunProcessRegistryUpdates(testServiceProvider, state);
// Assert
Validator validator = state.Validators[index];
validator.ActivationEligibilityEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
validator.ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
bool isActive = beaconChainUtility.IsActiveValidator(validator, currentEpoch + timeParameters.MaximumSeedLookahead + Epoch.One);
isActive.ShouldBeTrue();
}
public void ProcessJustificationAndFinalization(BeaconState state)
{
_logger.LogInformation(Event.ProcessJustificationAndFinalization, "Process epoch justification and finalization state {BeaconState}", state);
var currentEpoch = _beaconStateAccessor.GetCurrentEpoch(state);
if (currentEpoch <= _initialValueOptions.CurrentValue.GenesisEpoch + new Epoch(1))
{
return;
//throw new ArgumentOutOfRangeException(nameof(state), currentEpoch, "Current epoch of state must be more than one away from genesis epoch.");
}
var previousEpoch = _beaconStateAccessor.GetPreviousEpoch(state);
var oldPreviousJustifiedCheckpoint = state.PreviousJustifiedCheckpoint;
var oldCurrentJustifiedCheckpoint = state.CurrentJustifiedCheckpoint;
// Process justifications
state.SetPreviousJustifiedCheckpoint(state.CurrentJustifiedCheckpoint);
state.JustificationBitsShift();
// Previous Epoch
var matchingTargetAttestationsPreviousEpoch = GetMatchingTargetAttestations(state, previousEpoch);
var attestingBalancePreviousEpoch = GetAttestingBalance(state, matchingTargetAttestationsPreviousEpoch);
var totalActiveBalance = _beaconStateAccessor.GetTotalActiveBalance(state);
if (attestingBalancePreviousEpoch * 3 >= totalActiveBalance * 2)
{
var blockRoot = _beaconStateAccessor.GetBlockRoot(state, previousEpoch);
var checkpoint = new Checkpoint(previousEpoch, blockRoot);
state.SetCurrentJustifiedCheckpoint(checkpoint);
state.JustificationBits.Set(1, true);
}
// Current Epoch
var matchingTargetAttestationsCurrentEpoch = GetMatchingTargetAttestations(state, currentEpoch);
var attestingBalanceCurrentEpoch = GetAttestingBalance(state, matchingTargetAttestationsCurrentEpoch);
if (attestingBalanceCurrentEpoch * 3 >= totalActiveBalance * 2)
{
var blockRoot = _beaconStateAccessor.GetBlockRoot(state, currentEpoch);
var checkpoint = new Checkpoint(currentEpoch, blockRoot);
state.SetCurrentJustifiedCheckpoint(checkpoint);
state.JustificationBits.Set(0, true);
}
// Process finalizations
var bits = state.JustificationBits;
// The 2nd/3rd/4th most recent epochs are justified, the 2nd using the 4th as source
if ((oldPreviousJustifiedCheckpoint.Epoch + new Epoch(3) == currentEpoch) &&
bits.Cast <bool>().Skip(1).Take(3).All(x => x))
{
state.SetFinalizedCheckpoint(oldPreviousJustifiedCheckpoint);
}
// The 2nd/3rd most recent epochs are justified, the 2nd using the 3rd as source
if ((oldPreviousJustifiedCheckpoint.Epoch + new Epoch(2) == currentEpoch) &&
bits.Cast <bool>().Skip(1).Take(2).All(x => x))
{
state.SetFinalizedCheckpoint(oldPreviousJustifiedCheckpoint);
}
// The 1st/2nd/3rd most recent epochs are justified, the 1st using the 3rd as source
if ((oldCurrentJustifiedCheckpoint.Epoch + new Epoch(2) == currentEpoch) &&
bits.Cast <bool>().Take(3).All(x => x))
{
state.SetFinalizedCheckpoint(oldCurrentJustifiedCheckpoint);
}
// The 1st/2nd most recent epochs are justified, the 1st using the 2nd as source
if ((oldCurrentJustifiedCheckpoint.Epoch + new Epoch(1) == currentEpoch) &&
bits.Cast <bool>().Take(2).All(x => x))
{
state.SetFinalizedCheckpoint(oldCurrentJustifiedCheckpoint);
}
}