public void MaximumPenalties()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
StateListLengths stateListLengths = testServiceProvider.GetService <IOptions <StateListLengths> >().Value;
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
int slashedCount = (state.Validators.Count / 3) + 1;
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
Epoch outEpoch = currentEpoch + new Epoch((ulong)stateListLengths.EpochsPerSlashingsVector / 2);
var slashedIndices = Enumerable.Range(0, slashedCount).ToList();
SlashValidators(testServiceProvider, state, slashedIndices, Enumerable.Repeat(outEpoch, slashedCount));
Gwei totalBalance = beaconStateAccessor.GetTotalActiveBalance(state);
Gwei totalPenalties = state.Slashings.Aggregate(Gwei.Zero, (accumulator, x) => accumulator + x);
(totalBalance / 3).ShouldBeLessThanOrEqualTo(totalPenalties);
// Act
RunProcessSlashings(testServiceProvider, state);
// Assert
foreach (int index in slashedIndices)
{
state.Balances[index].ShouldBe(Gwei.Zero, $"Incorrect balance {index}");
}
}
public void InvalidSignature()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
// move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit
ulong move = timeParameters.SlotsPerEpoch * (ulong)timeParameters.PersistentCommitteePeriod;
ulong newSlot = state.Slot + move;
state.SetSlot((Slot)newSlot);
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
ValidatorIndex validatorIndex = beaconStateAccessor.GetActiveValidatorIndices(state, currentEpoch)[0];
Validator validator = state.Validators[(int)(ulong)validatorIndex];
byte[] privateKey = TestKeys.PublicKeyToPrivateKey(validator.PublicKey, timeParameters);
VoluntaryExit voluntaryExit = TestVoluntaryExit.BuildVoluntaryExit(testServiceProvider, currentEpoch, validatorIndex);
SignedVoluntaryExit signedVoluntaryExit = new SignedVoluntaryExit(voluntaryExit, BlsSignature.Zero);
RunVoluntaryExitProcessing(testServiceProvider, state, signedVoluntaryExit, expectValid: false);
}
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);
}
// Act
RunProcessRegistryUpdates(testServiceProvider, state);
// Assert
Validator validator = state.Validators[index];
validator.ActivationEligibilityEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
validator.ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch);
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
bool isActive = beaconChainUtility.IsActiveValidator(validator, currentEpoch);
isActive.ShouldBeTrue();
}
public async Task <Gwei> GetLatestAttestingBalanceAsync(IStore store, Root root)
{
Checkpoint justifiedCheckpoint = store.JustifiedCheckpoint;
BeaconState state = (await store.GetCheckpointStateAsync(justifiedCheckpoint, true).ConfigureAwait(false)) !;
Epoch currentEpoch = _beaconStateAccessor.GetCurrentEpoch(state);
IList <ValidatorIndex> activeIndexes = _beaconStateAccessor.GetActiveValidatorIndices(state, currentEpoch);
SignedBeaconBlock rootBlock = await store.GetSignedBlockAsync(root).ConfigureAwait(false);
Slot rootSlot = rootBlock !.Message.Slot;
Gwei balance = Gwei.Zero;
foreach (ValidatorIndex index in activeIndexes)
{
LatestMessage?latestMessage = await store.GetLatestMessageAsync(index, false);
if (latestMessage != null)
{
Root ancestor = await store.GetAncestorAsync(latestMessage.Root, rootSlot);
if (ancestor == root)
{
Validator validator = state.Validators[(int)index];
balance += validator.EffectiveBalance;
}
}
}
return(balance);
}
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;
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
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 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);
}
private void MockDeposit(IServiceProvider testServiceProvider, BeaconState state, int index)
{
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
GweiValues gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value;
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
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();
}
private void SlashValidators(IServiceProvider testServiceProvider, BeaconState state, IEnumerable <int> indices, IEnumerable <Epoch> outEpochs)
{
StateListLengths stateListLengths = testServiceProvider.GetService <IOptions <StateListLengths> >().Value;
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
BeaconStateMutator beaconStateMutator = testServiceProvider.GetService <BeaconStateMutator>();
Gwei totalSlashedBalance = Gwei.Zero;
var items = indices.Zip(outEpochs, (index, outEpoch) => new { index, outEpoch });
foreach (var item in items)
{
Validator validator = state.Validators[item.index];
validator.SetSlashed();
beaconStateMutator.InitiateValidatorExit(state, new ValidatorIndex((ulong)item.index));
validator.SetWithdrawableEpoch(item.outEpoch);
totalSlashedBalance += validator.EffectiveBalance;
}
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
Epoch slashingsIndex = (Epoch)(currentEpoch % stateListLengths.EpochsPerSlashingsVector);
state.SetSlashings(slashingsIndex, totalSlashedBalance);
}
// Run ``process_attester_slashing``, yielding:
// - pre-state('pre')
// - attester_slashing('attester_slashing')
// - post-state('post').
//If ``valid == False``, run expecting ``AssertionError``
private void RunAttesterSlashingProcessing(IServiceProvider testServiceProvider, BeaconState state, AttesterSlashing attesterSlashing, bool expectValid)
{
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
StateListLengths stateListLengths = testServiceProvider.GetService <IOptions <StateListLengths> >().Value;
RewardsAndPenalties rewardsAndPenalties = testServiceProvider.GetService <IOptions <RewardsAndPenalties> >().Value;
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
BeaconStateTransition beaconStateTransition = testServiceProvider.GetService <BeaconStateTransition>();
if (!expectValid)
{
Should.Throw <Exception>(() =>
{
beaconStateTransition.ProcessAttesterSlashing(state, attesterSlashing);
});
return;
}
var slashedIndices = attesterSlashing.Attestation1.CustodyBit0Indices
.Union(attesterSlashing.Attestation1.CustodyBit1Indices)
.ToList();
ValidatorIndex proposerIndex = beaconStateAccessor.GetBeaconProposerIndex(state);
Gwei preProposerBalance = TestState.GetBalance(state, proposerIndex);
var preSlashings = slashedIndices.ToDictionary(x => x, x => TestState.GetBalance(state, x));
var preWithdrawableEpochs = slashedIndices.ToDictionary(x => x, x => state.Validators[(int)(ulong)x].WithdrawableEpoch);
Gwei totalProposerRewards = preSlashings.Values.Aggregate(Gwei.Zero, (sum, x) => sum + x / rewardsAndPenalties.WhistleblowerRewardQuotient);
// Process slashing
beaconStateTransition.ProcessAttesterSlashing(state, attesterSlashing);
foreach (ValidatorIndex slashedIndex in slashedIndices)
{
Console.WriteLine($"Checking index {slashedIndex}");
Epoch preWithdrawableEpoch = preWithdrawableEpochs[slashedIndex];
Validator slashedValidator = state.Validators[(int)(ulong)slashedIndex];
// Check Slashing
slashedValidator.IsSlashed.ShouldBeTrue();
slashedValidator.ExitEpoch.ShouldBeLessThan(chainConstants.FarFutureEpoch);
if (preWithdrawableEpoch < chainConstants.FarFutureEpoch)
{
ulong slashingsEpoch = beaconStateAccessor.GetCurrentEpoch(state) + stateListLengths.EpochsPerSlashingsVector;
Epoch expectedWithdrawableEpoch = Epoch.Max(preWithdrawableEpoch, (Epoch)slashingsEpoch);
slashedValidator.WithdrawableEpoch.ShouldBe(expectedWithdrawableEpoch);
}
else
{
slashedValidator.WithdrawableEpoch.ShouldBeLessThan(chainConstants.FarFutureEpoch);
}
Gwei preSlashing = preSlashings[slashedIndex];
Gwei slashedBalance = TestState.GetBalance(state, slashedIndex);
slashedBalance.ShouldBeLessThan(preSlashing);
}
if (!slashedIndices.Contains(proposerIndex))
{
// gained whistleblower reward
Gwei expectedProposerBalance = preProposerBalance + totalProposerRewards;
Gwei proposerBalance = TestState.GetBalance(state, proposerIndex);
proposerBalance.ShouldBe(expectedProposerBalance);
}
else
{
// gained rewards for all slashings, which may include others. And only lost that of themselves.
Gwei expectedProposerBalance = preProposerBalance + totalProposerRewards
- (preSlashings[proposerIndex] / rewardsAndPenalties.MinimumSlashingPenaltyQuotient);
Gwei proposerBalance = TestState.GetBalance(state, proposerIndex);
proposerBalance.ShouldBe(expectedProposerBalance);
}
}
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;
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
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);
}
}
private static AttestationData BuildAttestationData(IServiceProvider testServiceProvider, BeaconState state, Slot slot, CommitteeIndex index)
{
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
if (state.Slot > slot)
{
throw new ArgumentOutOfRangeException(nameof(slot), slot, $"Slot cannot be greater than state slot {state.Slot}.");
}
Root blockRoot;
if (slot == state.Slot)
{
BeaconBlock nextBlock = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero);
blockRoot = nextBlock.ParentRoot;
}
else
{
blockRoot = beaconStateAccessor.GetBlockRootAtSlot(state, slot);
}
Root epochBoundaryRoot;
Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state);
Slot currentEpochStartSlot = beaconChainUtility.ComputeStartSlotOfEpoch(currentEpoch);
if (slot < currentEpochStartSlot)
{
Epoch previousEpoch = beaconStateAccessor.GetPreviousEpoch(state);
epochBoundaryRoot = beaconStateAccessor.GetBlockRoot(state, previousEpoch);
}
else if (slot == currentEpochStartSlot)
{
epochBoundaryRoot = blockRoot;
}
else
{
epochBoundaryRoot = beaconStateAccessor.GetBlockRoot(state, currentEpoch);
}
Epoch sourceEpoch;
Root sourceRoot;
if (slot < currentEpochStartSlot)
{
sourceEpoch = state.PreviousJustifiedCheckpoint.Epoch;
sourceRoot = state.PreviousJustifiedCheckpoint.Root;
}
else
{
sourceEpoch = state.CurrentJustifiedCheckpoint.Epoch;
sourceRoot = state.CurrentJustifiedCheckpoint.Root;
}
//Crosslink parentCrosslink;
//if (epochOfSlot == currentEpoch)
//{
// parentCrosslink = state.CurrentCrosslinks[(int)(ulong)shard];
//}
//else
//{
// throw new NotImplementedException();
//}
Epoch slotEpoch = beaconChainUtility.ComputeEpochAtSlot(slot);
AttestationData attestationData = new AttestationData(
slot,
index,
blockRoot,
new Checkpoint(sourceEpoch, sourceRoot),
new Checkpoint(slotEpoch, epochBoundaryRoot));
return(attestationData);
}