eth2.0-specs/specs/_features/eip7514/beacon_chain.md

EIP-7514 -- The Beacon Chain

Table of contents

• Introduction
• Configuration
  • Validator cycle
• Helper functions
  • Beacon state accessors
    • New get_validator_activation_churn_limit
• Beacon chain state transition function
  • Epoch processing
    • Registry updates

Introduction

This is the beacon chain specification to limit the max inbound churn value, motivated to limit the validator active set growth rate.

Note: This specification is built upon Capella and is under active development.

Configuration

Validator cycle

Name	Value
MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT	uint64(8) (= 8)

Helper functions

Beacon state accessors

New get_validator_activation_churn_limit

def get_validator_activation_churn_limit(state: BeaconState) -> uint64:
    """
    Return the validator activation churn limit for the current epoch.
    """
    return min(MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT, get_validator_churn_limit(state))

Beacon chain state transition function

Epoch processing

Registry updates

Note: The function process_registry_updates is modified to utilize get_validator_inbound_churn_limit() the rate limit the activation queue for EIP-7514.

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
    # [Modified in EIP7514]
    for index in activation_queue[:get_validator_activation_churn_limit(state)]:
        validator = state.validators[index]
        validator.activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))