public async Task ShorterChainButHeavierWeight()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true);
BeaconState state = TestState.PrepareTestState(testServiceProvider);
MiscellaneousParameters miscellaneousParameters = testServiceProvider.GetService <IOptions <MiscellaneousParameters> >().Value;
MaxOperationsPerBlock maxOperationsPerBlock = testServiceProvider.GetService <IOptions <MaxOperationsPerBlock> >().Value;
// Initialization
ForkChoice forkChoice = testServiceProvider.GetService <ForkChoice>();
IStore store = forkChoice.GetGenesisStore(state);
BeaconState genesisState = BeaconState.Clone(state);
// build longer tree
Hash32 longRoot = default;
BeaconState longState = BeaconState.Clone(genesisState);
for (int i = 0; i < 3; i++)
{
BeaconBlock longBlock = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, longState, signed: true);
TestState.StateTransitionAndSignBlock(testServiceProvider, longState, longBlock);
AddBlockToStore(testServiceProvider, store, longBlock);
if (i == 2)
{
longRoot = longBlock.SigningRoot(miscellaneousParameters, maxOperationsPerBlock);
}
}
// build short tree
BeaconState shortState = BeaconState.Clone(genesisState);
BeaconBlock shortBlock = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, shortState, signed: true);
shortBlock.Body.SetGraffiti(new Bytes32(Enumerable.Repeat((byte)0x42, 32).ToArray()));
TestBlock.SignBlock(testServiceProvider, shortState, shortBlock, ValidatorIndex.None);
TestState.StateTransitionAndSignBlock(testServiceProvider, shortState, shortBlock);
AddBlockToStore(testServiceProvider, store, shortBlock);
Attestation shortAttestation = TestAttestation.GetValidAttestation(testServiceProvider, shortState, shortBlock.Slot, CommitteeIndex.None, signed: true);
AddAttestationToStore(testServiceProvider, store, shortAttestation);
// Act
Hash32 headRoot = await forkChoice.GetHeadAsync(store);
// Assert
Hash32 expectedRoot = shortBlock.SigningRoot(miscellaneousParameters, maxOperationsPerBlock);
headRoot.ShouldBe(expectedRoot);
headRoot.ShouldNotBe(longRoot);
}
public void GenesisEpochFullAttestationsNoRewards()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
BeaconState state = TestState.PrepareTestState(testServiceProvider);
InitialValues initialValues = testServiceProvider.GetService <IOptions <InitialValues> >().Value;
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
var attestations = new List <Attestation>();
for (Slot slot = Slot.Zero; slot < timeParameters.SlotsPerEpoch - new Slot(1); slot += new Slot(1))
{
// create an attestation for each slot
if (slot < timeParameters.SlotsPerEpoch)
{
Attestation attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, slot, CommitteeIndex.None, signed: true);
attestations.Add(attestation);
}
// fill each created slot in state after inclusion delay
if (slot >= timeParameters.MinimumAttestationInclusionDelay)
{
Slot index = slot - timeParameters.MinimumAttestationInclusionDelay;
Attestation includeAttestation = attestations[(int)(ulong)index];
TestAttestation.AddAttestationsToState(testServiceProvider, state, new[] { includeAttestation }, state.Slot);
}
TestState.NextSlot(testServiceProvider, state);
}
// ensure has not cross the epoch boundary
Epoch stateEpoch = beaconChainUtility.ComputeEpochAtSlot(state.Slot);
stateEpoch.ShouldBe(initialValues.GenesisEpoch);
BeaconState preState = BeaconState.Clone(state);
// Act
RunProcessRewardsAndPenalties(testServiceProvider, state);
// Assert
for (int index = 0; index < preState.Validators.Count; index++)
{
state.Balances[index].ShouldBe(preState.Balances[index], $"Balance {index}");
}
}
public void SuccessAttestation()
{
// Arrange
var testServiceProvider = TestSystem.BuildTestServiceProvider();
var state = TestState.PrepareTestState(testServiceProvider);
var attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, Slot.None, CommitteeIndex.None, signed: true);
var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
var slot = state.Slot + timeParameters.MinimumAttestationInclusionDelay;
state.SetSlot(slot);
RunAttestationProcessing(testServiceProvider, state, attestation, expectValid: true);
}
private static IList <Attestation> PrepareStateWithFullAttestations(IServiceProvider testServiceProvider, BeaconState state)
{
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
InitialValues initialValues = testServiceProvider.GetService <IOptions <InitialValues> >().Value;
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
var attestations = new List <Attestation>();
ulong maxSlot = timeParameters.SlotsPerEpoch + timeParameters.MinimumAttestationInclusionDelay;
for (Slot slot = Slot.Zero; slot < maxSlot; slot += new Slot(1))
{
// create an attestation for each slot in epoch
if (slot < timeParameters.SlotsPerEpoch)
{
Attestation attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, Slot.None, CommitteeIndex.None, signed: true);
attestations.Add(attestation);
}
// fill each created slot in state after inclusion delay
if (slot >= timeParameters.MinimumAttestationInclusionDelay)
{
Slot index = slot - timeParameters.MinimumAttestationInclusionDelay;
Attestation includeAttestation = attestations[(int)(ulong)index];
TestAttestation.AddAttestationsToState(testServiceProvider, state, new[] { includeAttestation }, state.Slot);
}
TestState.NextSlot(testServiceProvider, state);
}
Epoch stateEpoch = beaconChainUtility.ComputeEpochAtSlot(state.Slot);
stateEpoch.ShouldBe(initialValues.GenesisEpoch + Epoch.One);
state.PreviousEpochAttestations.Count.ShouldBe((int)timeParameters.SlotsPerEpoch);
return(attestations);
}
public async Task OnAttestationPastEpoch()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true);
BeaconState state = TestState.PrepareTestState(testServiceProvider);
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
InitialValues initialValues = testServiceProvider.GetService <IOptions <InitialValues> >().Value;
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>();
// Initialization
IStore store = testServiceProvider.GetService <IStore>();
await forkChoice.InitializeForkChoiceStoreAsync(store, state);
// move time forward 2 epochs
ulong time = store.Time + 2 * timeParameters.SecondsPerSlot * (ulong)timeParameters.SlotsPerEpoch;
await forkChoice.OnTickAsync(store, time);
// create and store block from 3 epochs ago
BeaconBlock block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero);
SignedBeaconBlock signedBlock = TestState.StateTransitionAndSignBlock(testServiceProvider, state, block);
await forkChoice.OnBlockAsync(store, signedBlock);
// create attestation for past block
Attestation attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, state.Slot, CommitteeIndex.None, signed: true);
attestation.Data.Target.Epoch.ShouldBe(chainConstants.GenesisEpoch);
IBeaconChainUtility beaconChainUtility = testServiceProvider.GetService <IBeaconChainUtility>();
Slot currentSlot = ((ForkChoice)forkChoice).GetCurrentSlot(store);
Epoch currentEpoch = beaconChainUtility.ComputeEpochAtSlot(currentSlot);
currentEpoch.ShouldBe((Epoch)(chainConstants.GenesisEpoch + 2UL));
await RunOnAttestation(testServiceProvider, state, store, attestation, expectValid : false);
}
public void OnAttestationPastEpoch()
{
// Arrange
var testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true);
var state = TestState.PrepareTestState(testServiceProvider);
var initialValues = testServiceProvider.GetService <IOptions <InitialValues> >().Value;
var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
var forkChoice = testServiceProvider.GetService <ForkChoice>();
// Initialization
var store = forkChoice.GetGenesisStore(state);
// move time forward 2 epochs
var time = store.Time + 2 * timeParameters.SecondsPerSlot * (ulong)timeParameters.SlotsPerEpoch;
forkChoice.OnTick(store, time);
// create and store block from 3 epochs ago
var block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true);
TestState.StateTransitionAndSignBlock(testServiceProvider, state, block);
forkChoice.OnBlock(store, block);
// create attestation for past block
var attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, state.Slot, CommitteeIndex.None, signed: true);
attestation.Data.Target.Epoch.ShouldBe(initialValues.GenesisEpoch);
var beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
var currentSlot = forkChoice.GetCurrentSlot(store);
var currentEpoch = beaconChainUtility.ComputeEpochAtSlot(currentSlot);
currentEpoch.ShouldBe(initialValues.GenesisEpoch + new Epoch(2));
RunOnAttestation(testServiceProvider, state, store, attestation, expectValid: false);
}
