/// <summary>
/// Return the sequence of active validator indices at ``epoch``.
/// </summary>
public IList <ValidatorIndex> GetActiveValidatorIndices(BeaconState state, Epoch epoch)
{
return(state.Validators
.Select((validator, index) => new { validator, index })
.Where(x => _beaconChainUtility.IsActiveValidator(x.validator, epoch))
.Select(x => (ValidatorIndex)(ulong)x.index)
.ToList());
}
public void Ejection()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
GweiValues gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value;
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
IBeaconChainUtility beaconChainUtility = testServiceProvider.GetService <IBeaconChainUtility>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
int index = 0;
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
Validator validator = state.Validators[index];
bool isActive = beaconChainUtility.IsActiveValidator(validator, currentEpoch);
isActive.ShouldBeTrue();
validator.ExitEpoch.ShouldBe(chainConstants.FarFutureEpoch);
// Mock an ejection
state.Validators[index].SetEffectiveBalance(gweiValues.EjectionBalance);
for (ulong count = (ulong)0; count < (ulong)timeParameters.MaximumSeedLookahead + 1; count++)
{
TestState.NextEpoch(testServiceProvider, state);
}
// Act
RunProcessRegistryUpdates(testServiceProvider, state);
// Assert
Epoch epochAfter = beaconStateAccessor.GetCurrentEpoch(state);
Validator validatorAfter = state.Validators[index];
bool isActiveAfter = beaconChainUtility.IsActiveValidator(validatorAfter, epochAfter);
isActiveAfter.ShouldBeFalse();
validatorAfter.ExitEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
}
public bool CheckIfValidatorActive(BeaconState state, ValidatorIndex validatorIndex)
{
if ((int)validatorIndex >= state.Validators.Count)
{
return(false);
}
Validator validator = state.Validators[(int)validatorIndex];
Epoch currentEpoch = _beaconStateAccessor.GetCurrentEpoch(state);
bool isActive = _beaconChainUtility.IsActiveValidator(validator, currentEpoch);
return(isActive);
}
private void MockDeposit(IServiceProvider testServiceProvider, BeaconState state, int index)
{
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
GweiValues gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value;
IBeaconChainUtility beaconChainUtility = testServiceProvider.GetService <IBeaconChainUtility>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
Validator validator = state.Validators[index];
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
bool isActive = beaconChainUtility.IsActiveValidator(validator, currentEpoch);
isActive.ShouldBeTrue();
validator.SetEligible(chainConstants.FarFutureEpoch);
validator.SetActive(chainConstants.FarFutureEpoch);
validator.SetEffectiveBalance(gweiValues.MaximumEffectiveBalance);
bool isActiveAfter = beaconChainUtility.IsActiveValidator(validator, currentEpoch);
isActiveAfter.ShouldBeFalse();
}
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;
IBeaconChainUtility beaconChainUtility = testServiceProvider.GetService <IBeaconChainUtility>();
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 EffectiveBalanceHysteresis()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
//# Prepare state up to the final-updates.
//# Then overwrite the balances, we only want to focus to be on the hysteresis based changes.
TestProcessUtility.RunEpochProcessingTo(testServiceProvider, state, TestProcessStep.ProcessFinalUpdates);
GweiValues gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value;
IBeaconChainUtility beaconChainUtility = testServiceProvider.GetService <IBeaconChainUtility>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
BeaconStateTransition beaconStateTransition = testServiceProvider.GetService <BeaconStateTransition>();
// Set some edge cases for balances
Gwei maximum = gweiValues.MaximumEffectiveBalance;
Gwei minimum = gweiValues.EjectionBalance;
Gwei increment = gweiValues.EffectiveBalanceIncrement;
Gwei halfIncrement = increment / 2;
EffectiveBalanceCase[] testCases = new[] {
new EffectiveBalanceCase(maximum, maximum, maximum, "as-is"),
new EffectiveBalanceCase(maximum, (Gwei)(maximum - 1), maximum - increment, "round down, step lower"),
new EffectiveBalanceCase(maximum, (Gwei)(maximum + 1), maximum, "round down"),
new EffectiveBalanceCase(maximum, (Gwei)(maximum - increment), maximum - increment, "exactly 1 step lower"),
new EffectiveBalanceCase(maximum, (Gwei)(maximum - increment - 1), maximum - (increment * 2), "just 1 over 1 step lower"),
new EffectiveBalanceCase(maximum, (Gwei)(maximum - increment + 1), maximum - increment, "close to 1 step lower"),
new EffectiveBalanceCase(minimum, (Gwei)(minimum + (halfIncrement * 3)), minimum, "bigger balance, but not high enough"),
new EffectiveBalanceCase(minimum, (Gwei)(minimum + (halfIncrement * 3) + 1), minimum + increment, "bigger balance, high enough, but small step"),
new EffectiveBalanceCase(minimum, (Gwei)(minimum + (halfIncrement * 4) - 1), minimum + increment, "bigger balance, high enough, close to double step"),
new EffectiveBalanceCase(minimum, (Gwei)(minimum + (halfIncrement * 4)), minimum + (increment * 2), "exact two step balance increment"),
new EffectiveBalanceCase(minimum, (Gwei)(minimum + (halfIncrement * 4) + 1), minimum + (increment * 2), "over two steps, round down"),
};
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
for (int index = 0; index < testCases.Length; index++)
{
Validator validator = state.Validators[index];
bool isActive = beaconChainUtility.IsActiveValidator(validator, currentEpoch);
isActive.ShouldBeTrue();
EffectiveBalanceCase testCase = testCases[index];
validator.SetEffectiveBalance(testCase.PreEffective);
ValidatorIndex validatorIndex = new ValidatorIndex((ulong)index);
state.SetBalance(validatorIndex, testCase.Balance);
}
// Act
beaconStateTransition.ProcessFinalUpdates(state);
// Assert
for (int index = 0; index < testCases.Length; index++)
{
EffectiveBalanceCase testCase = testCases[index];
Validator validator = state.Validators[index];
validator.EffectiveBalance.ShouldBe(testCase.PostEffective, testCase.Name);
}
}