/// <summary> /// Processes to the next epoch transition, up to and including the sub-transition named ``process_name`` /// - pre-state('pre'), state before calling ``process_name`` /// - post-state('post'), state after calling ``process_name`` /// </summary> public static void RunEpochProcessingWith(IServiceProvider testServiceProvider, BeaconState state, TestProcessStep step) { RunEpochProcessingTo(testServiceProvider, state, step); BeaconStateTransition beaconStateTransition = testServiceProvider.GetService <BeaconStateTransition>(); if (step == TestProcessStep.ProcessJustificationAndFinalization) { beaconStateTransition.ProcessJustificationAndFinalization(state); return; } if (step == TestProcessStep.ProcessRewardsAndPenalties) { beaconStateTransition.ProcessRewardsAndPenalties(state); return; } if (step == TestProcessStep.ProcessRegistryUpdates) { beaconStateTransition.ProcessRegistryUpdates(state); return; } if (step == TestProcessStep.ProcessSlashings) { beaconStateTransition.ProcessSlashings(state); return; } if (step == TestProcessStep.ProcessFinalUpdates) { beaconStateTransition.ProcessFinalUpdates(state); return; } throw new NotImplementedException(); }
/// <summary> /// Processes to the next epoch transition, up to, but not including, the sub-transition named ``process_name`` /// </summary> public static void RunEpochProcessingTo(IServiceProvider testServiceProvider, BeaconState state, TestProcessStep step) { TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; BeaconStateTransition beaconStateTransition = testServiceProvider.GetService <BeaconStateTransition>(); Slot slot = (Slot)(state.Slot + (timeParameters.SlotsPerEpoch - state.Slot % timeParameters.SlotsPerEpoch) - 1UL); // transition state to slot before epoch state transition beaconStateTransition.ProcessSlots(state, slot); // start transitioning, do one slot update before the epoch itself. beaconStateTransition.ProcessSlot(state); // process components of epoch transition before final-updates if (step == TestProcessStep.ProcessJustificationAndFinalization) { return; } // Note: only run when present. Later phases introduce more to the epoch-processing. beaconStateTransition.ProcessJustificationAndFinalization(state); if (step == TestProcessStep.ProcessRewardsAndPenalties) { return; } beaconStateTransition.ProcessRewardsAndPenalties(state); if (step == TestProcessStep.ProcessRegistryUpdates) { return; } beaconStateTransition.ProcessRegistryUpdates(state); if (step == TestProcessStep.ProcessSlashings) { return; } beaconStateTransition.ProcessSlashings(state); if (step == TestProcessStep.ProcessFinalUpdates) { return; } beaconStateTransition.ProcessFinalUpdates(state); }