validators

Documentation

Overview

Package validators contains libraries to shuffle validators and retrieve active validator indices from a given slot or an attestation. It also provides helper functions to locate validator based on pubic key.

Index

• Variables
• func ActivatedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator) []primitives.ValidatorIndex
• func EjectedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator, ...) ([]primitives.ValidatorIndex, error)
• func ExitedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator, ...) ([]primitives.ValidatorIndex, error)
• func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex, ...) (state.BeaconState, primitives.Epoch, error)
• func MaxExitEpochAndChurn(s state.BeaconState) (maxExitEpoch primitives.Epoch, churn uint64)
• func SlashValidator(ctx context.Context, s state.BeaconState, slashedIdx primitives.ValidatorIndex, ...) (state.BeaconState, error)
• func SlashedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator) []primitives.ValidatorIndex

Variables

var ValidatorAlreadyExitedErr = errors.New("validator already exited")

ValidatorAlreadyExitedErr is an error raised when trying to process an exit of an already exited validator

Functions

func ActivatedValidatorIndices

func ActivatedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator) []primitives.ValidatorIndex

ActivatedValidatorIndices determines the indices activated during the given epoch.

func EjectedValidatorIndices

func EjectedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator, activeValidatorCount uint64) ([]primitives.ValidatorIndex, error)

EjectedValidatorIndices determines the indices ejected during the given epoch.

func ExitedValidatorIndices

func ExitedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator, activeValidatorCount uint64) ([]primitives.ValidatorIndex, error)

ExitedValidatorIndices determines the indices exited during the current epoch.

func InitiateValidatorExit

func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex, exitQueueEpoch primitives.Epoch, churn uint64) (state.BeaconState, primitives.Epoch, error)

InitiateValidatorExit takes in validator index and updates validator with correct voluntary exit parameters.

Spec pseudocode definition:

def initiate_validator_exit(state: BeaconState, index: ValidatorIndex) -> None:
  """
  Initiate the exit of the validator with index ``index``.
  """
  # Return if validator already initiated exit
  validator = state.validators[index]
  if validator.exit_epoch != FAR_FUTURE_EPOCH:
      return

  # Compute exit queue epoch
  exit_epochs = [v.exit_epoch for v in state.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
  exit_queue_epoch = max(exit_epochs + [compute_activation_exit_epoch(get_current_epoch(state))])
  exit_queue_churn = len([v for v in state.validators if v.exit_epoch == exit_queue_epoch])
  if exit_queue_churn >= get_validator_churn_limit(state):
      exit_queue_epoch += Epoch(1)

  # Set validator exit epoch and withdrawable epoch
  validator.exit_epoch = exit_queue_epoch
  validator.withdrawable_epoch = Epoch(validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)

func MaxExitEpochAndChurn

func MaxExitEpochAndChurn(s state.BeaconState) (maxExitEpoch primitives.Epoch, churn uint64)

MaxExitEpochAndChurn returns the maximum non-FAR_FUTURE_EPOCH exit epoch and the number of them

func SlashValidator

func SlashValidator(
	ctx context.Context,
	s state.BeaconState,
	slashedIdx primitives.ValidatorIndex,
	penaltyQuotient uint64,
	proposerRewardQuotient uint64) (state.BeaconState, error)

SlashValidator slashes the malicious validator's balance and awards the whistleblower's balance.

Spec pseudocode definition:

def slash_validator(state: BeaconState,
                  slashed_index: ValidatorIndex,
                  whistleblower_index: ValidatorIndex=None) -> None:
  """
  Slash the validator with index ``slashed_index``.
  """
  epoch = get_current_epoch(state)
  initiate_validator_exit(state, slashed_index)
  validator = state.validators[slashed_index]
  validator.slashed = True
  validator.withdrawable_epoch = max(validator.withdrawable_epoch, Epoch(epoch + EPOCHS_PER_SLASHINGS_VECTOR))
  state.slashings[epoch % EPOCHS_PER_SLASHINGS_VECTOR] += validator.effective_balance
  decrease_balance(state, slashed_index, validator.effective_balance // MIN_SLASHING_PENALTY_QUOTIENT)

  # Apply proposer and whistleblower rewards
  proposer_index = get_beacon_proposer_index(state)
  if whistleblower_index is None:
      whistleblower_index = proposer_index
  whistleblower_reward = Gwei(validator.effective_balance // WHISTLEBLOWER_REWARD_QUOTIENT)
  proposer_reward = Gwei(whistleblower_reward // PROPOSER_REWARD_QUOTIENT)
  increase_balance(state, proposer_index, proposer_reward)
  increase_balance(state, whistleblower_index, Gwei(whistleblower_reward - proposer_reward))

func SlashedValidatorIndices

func SlashedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator) []primitives.ValidatorIndex

SlashedValidatorIndices determines the indices slashed during the given epoch.