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

• func ActivatedValidatorIndices(epoch uint64, validators []*ethpb.Validator) []uint64
• func ExitedValidatorIndices(validators []*ethpb.Validator, activeValidatorCount uint64) ([]uint64, error)
• func InitiateValidatorExit(state *pb.BeaconState, idx uint64) (*pb.BeaconState, error)
• func SlashValidator(state *pb.BeaconState, slashedIdx uint64, whistleBlowerIdx uint64) (*pb.BeaconState, error)
• func SlashedValidatorIndices(epoch uint64, validators []*ethpb.Validator) []uint64

Functions

func ActivatedValidatorIndices

func ActivatedValidatorIndices(epoch uint64, validators []*ethpb.Validator) []uint64

ActivatedValidatorIndices determines the indices activated during the current epoch.

func ExitedValidatorIndices

func ExitedValidatorIndices(validators []*ethpb.Validator, activeValidatorCount uint64) ([]uint64, error)

ExitedValidatorIndices determines the indices exited during the current epoch.

func InitiateValidatorExit

func InitiateValidatorExit(state *pb.BeaconState, idx uint64) (*pb.BeaconState, 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 SlashValidator

func SlashValidator(state *pb.BeaconState, slashedIdx uint64, whistleBlowerIdx uint64) (*pb.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_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, whistleblower_reward - proposer_reward)

func SlashedValidatorIndices

func SlashedValidatorIndices(epoch uint64, validators []*ethpb.Validator) []uint64

SlashedValidatorIndices determines the indices slashed during the current epoch.