epoch

Documentation

Overview

Package epoch contains epoch processing libraries according to spec, able to process new balance for validators, justify and finalize new check points, and shuffle validators to different slots and shards.

Index

• func AttestingBalance(ctx context.Context, state state.ReadOnlyBeaconState, ...) (uint64, error)
• func ProcessEffectiveBalanceUpdates(state state.BeaconState) (state.BeaconState, error)
• func ProcessEth1DataReset(state state.BeaconState) (state.BeaconState, error)
• func ProcessFinalUpdates(state state.BeaconState) (state.BeaconState, error)
• func ProcessHistoricalRootsUpdate(state state.BeaconState) (state.BeaconState, error)
• func ProcessParticipationRecordUpdates(state state.BeaconState) (state.BeaconState, error)
• func ProcessRandaoMixesReset(state state.BeaconState) (state.BeaconState, error)
• func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error)
• func ProcessSlashings(state state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error)
• func ProcessSlashingsReset(state state.BeaconState) (state.BeaconState, error)
• func UnslashedAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, ...) ([]types.ValidatorIndex, error)

Functions

func AttestingBalance

func AttestingBalance(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) (uint64, error)

AttestingBalance returns the total balance from all the attesting indices.

WARNING: This method allocates a new copy of the attesting validator indices set and is considered to be very memory expensive. Avoid using this unless you really need to get attesting balance from attestations.

Spec pseudocode definition:

def get_attesting_balance(state: BeaconState, attestations: Sequence[PendingAttestation]) -> Gwei:
  """
  Return the combined effective balance of the set of unslashed validators participating in ``attestations``.
  Note: ``get_total_balance`` returns ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero.
  """
  return get_total_balance(state, get_unslashed_attesting_indices(state, attestations))

func ProcessEffectiveBalanceUpdates

func ProcessEffectiveBalanceUpdates(state state.BeaconState) (state.BeaconState, error)

ProcessEffectiveBalanceUpdates processes effective balance updates during epoch processing.

Spec pseudocode definition:

def process_effective_balance_updates(state: BeaconState) -> None:
  # Update effective balances with hysteresis
  for index, validator in enumerate(state.validators):
      balance = state.balances[index]
      HYSTERESIS_INCREMENT = uint64(EFFECTIVE_BALANCE_INCREMENT // HYSTERESIS_QUOTIENT)
      DOWNWARD_THRESHOLD = HYSTERESIS_INCREMENT * HYSTERESIS_DOWNWARD_MULTIPLIER
      UPWARD_THRESHOLD = HYSTERESIS_INCREMENT * HYSTERESIS_UPWARD_MULTIPLIER
      if (
          balance + DOWNWARD_THRESHOLD < validator.effective_balance
          or validator.effective_balance + UPWARD_THRESHOLD < balance
      ):
          validator.effective_balance = min(balance - balance % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)

func ProcessEth1DataReset

func ProcessEth1DataReset(state state.BeaconState) (state.BeaconState, error)

ProcessEth1DataReset processes updates to ETH1 data votes during epoch processing.

Spec pseudocode definition:

def process_eth1_data_reset(state: BeaconState) -> None:
  next_epoch = Epoch(get_current_epoch(state) + 1)
  # Reset eth1 data votes
  if next_epoch % EPOCHS_PER_ETH1_VOTING_PERIOD == 0:
      state.eth1_data_votes = []

func ProcessFinalUpdates

func ProcessFinalUpdates(state state.BeaconState) (state.BeaconState, error)

ProcessFinalUpdates processes the final updates during epoch processing.

func ProcessHistoricalRootsUpdate

func ProcessHistoricalRootsUpdate(state state.BeaconState) (state.BeaconState, error)

ProcessHistoricalRootsUpdate processes the updates to historical root accumulator during epoch processing.

Spec pseudocode definition:

def process_historical_roots_update(state: BeaconState) -> None:
  # Set historical root accumulator
  next_epoch = Epoch(get_current_epoch(state) + 1)
  if next_epoch % (SLOTS_PER_HISTORICAL_ROOT // SLOTS_PER_EPOCH) == 0:
      historical_batch = HistoricalBatch(block_roots=state.block_roots, state_roots=state.state_roots)
      state.historical_roots.append(hash_tree_root(historical_batch))

func ProcessParticipationRecordUpdates

func ProcessParticipationRecordUpdates(state state.BeaconState) (state.BeaconState, error)

ProcessParticipationRecordUpdates rotates current/previous epoch attestations during epoch processing.

Spec pseudocode definition:

def process_participation_record_updates(state: BeaconState) -> None:
  # Rotate current/previous epoch attestations
  state.previous_epoch_attestations = state.current_epoch_attestations
  state.current_epoch_attestations = []

func ProcessRandaoMixesReset

func ProcessRandaoMixesReset(state state.BeaconState) (state.BeaconState, error)

ProcessRandaoMixesReset processes the final updates to RANDAO mix during epoch processing.

Spec pseudocode definition:

def process_randao_mixes_reset(state: BeaconState) -> None:
  current_epoch = get_current_epoch(state)
  next_epoch = Epoch(current_epoch + 1)
  # Set randao mix
  state.randao_mixes[next_epoch % EPOCHS_PER_HISTORICAL_VECTOR] = get_randao_mix(state, current_epoch)

func ProcessRegistryUpdates

func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error)

ProcessRegistryUpdates rotates validators in and out of active pool. the amount to rotate is determined churn limit.

Spec pseudocode definition:

def process_registry_updates(state: BeaconState) -> None:
 # Process activation eligibility and ejections
 for index, validator in enumerate(state.validators):
     if is_eligible_for_activation_queue(validator):
         validator.activation_eligibility_epoch = get_current_epoch(state) + 1

     if is_active_validator(validator, get_current_epoch(state)) and validator.effective_balance <= EJECTION_BALANCE:
         initiate_validator_exit(state, ValidatorIndex(index))

 # Queue validators eligible for activation and not yet dequeued for activation
 activation_queue = sorted([
     index for index, validator in enumerate(state.validators)
     if is_eligible_for_activation(state, validator)
     # Order by the sequence of activation_eligibility_epoch setting and then index
 ], key=lambda index: (state.validators[index].activation_eligibility_epoch, index))
 # Dequeued validators for activation up to churn limit
 for index in activation_queue[:get_validator_churn_limit(state)]:
     validator = state.validators[index]
     validator.activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))

func ProcessSlashings

func ProcessSlashings(state state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error)

ProcessSlashings processes the slashed validators during epoch processing,

def process_slashings(state: BeaconState) -> None:
  epoch = get_current_epoch(state)
  total_balance = get_total_active_balance(state)
  adjusted_total_slashing_balance = min(sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER, total_balance)
  for index, validator in enumerate(state.validators):
      if validator.slashed and epoch + EPOCHS_PER_SLASHINGS_VECTOR // 2 == validator.withdrawable_epoch:
          increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from penalty numerator to avoid uint64 overflow
          penalty_numerator = validator.effective_balance // increment * adjusted_total_slashing_balance
          penalty = penalty_numerator // total_balance * increment
          decrease_balance(state, ValidatorIndex(index), penalty)

func ProcessSlashingsReset

func ProcessSlashingsReset(state state.BeaconState) (state.BeaconState, error)

ProcessSlashingsReset processes the total slashing balances updates during epoch processing.

Spec pseudocode definition:

def process_slashings_reset(state: BeaconState) -> None:
  next_epoch = Epoch(get_current_epoch(state) + 1)
  # Reset slashings
  state.slashings[next_epoch % EPOCHS_PER_SLASHINGS_VECTOR] = Gwei(0)

func UnslashedAttestingIndices

func UnslashedAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) ([]types.ValidatorIndex, error)

UnslashedAttestingIndices returns all the attesting indices from a list of attestations, it sorts the indices and filters out the slashed ones.

Spec pseudocode definition:

def get_unslashed_attesting_indices(state: BeaconState,
                                  attestations: Sequence[PendingAttestation]) -> Set[ValidatorIndex]:
  output = set()  # type: Set[ValidatorIndex]
  for a in attestations:
      output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
  return set(filter(lambda index: not state.validators[index].slashed, output))