[DRAFT] Increase MAX_EFFECTIVE_BALANCE minimal spec change

specs/_features/maxeb_increase/capella.py

@@ -144,6 +144,7 @@ def floorlog2(x: int) -> uint64:
 ENDIANNESS: Final = 'little'
 BLS_WITHDRAWAL_PREFIX = Bytes1('0x00')
 ETH1_ADDRESS_WITHDRAWAL_PREFIX = Bytes1('0x01')
+COMPOUNDING_WITHDRAWAL_PREFIX = Bytes1('0x02')
 DOMAIN_BEACON_PROPOSER = DomainType('0x00000000')
 DOMAIN_BEACON_ATTESTER = DomainType('0x01000000')
 DOMAIN_RANDAO = DomainType('0x02000000')
@@ -190,7 +191,8 @@ def floorlog2(x: int) -> uint64:
 HYSTERESIS_DOWNWARD_MULTIPLIER = uint64(1)
 HYSTERESIS_UPWARD_MULTIPLIER = uint64(5)
 MIN_DEPOSIT_AMOUNT = Gwei(1000000000)
-MAX_EFFECTIVE_BALANCE = Gwei(32000000000)
+MIN_ACTIVATION_BALANCE = Gwei(32000000000)
+MAX_EFFECTIVE_BALANCE = Gwei(2048000000000)
 EFFECTIVE_BALANCE_INCREMENT = Gwei(1000000000)
 MIN_ATTESTATION_INCLUSION_DELAY = uint64(1)
 SLOTS_PER_EPOCH = uint64(32)
@@ -656,6 +658,8 @@ class BeaconState(Container):
     # Registry
     validators: List[Validator, VALIDATOR_REGISTRY_LIMIT]
     balances: List[Gwei, VALIDATOR_REGISTRY_LIMIT]
+    activation_validator_balance: Gwei
+    exit_queue_churn: Gwei
     # Randomness
     randao_mixes: Vector[Bytes32, EPOCHS_PER_HISTORICAL_VECTOR]
     # Slashings
@@ -798,7 +802,7 @@ def is_eligible_for_activation_queue(validator: Validator) -> bool:
     """
     return (
         validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
-        and validator.effective_balance == MAX_EFFECTIVE_BALANCE
+        and validator.effective_balance >= MIN_ACTIVATION_BALANCE
     )
 
 
@@ -1021,12 +1025,11 @@ def get_active_validator_indices(state: BeaconState, epoch: Epoch) -> Sequence[V
     return [ValidatorIndex(i) for i, v in enumerate(state.validators) if is_active_validator(v, epoch)]
 
 
-def get_validator_churn_limit(state: BeaconState) -> uint64:
+def get_validator_churn_limit(state: BeaconState) -> Gwei:
     """
     Return the validator churn limit for the current epoch.
     """
-    active_validator_indices = get_active_validator_indices(state, get_current_epoch(state))
-    return max(config.MIN_PER_EPOCH_CHURN_LIMIT, uint64(len(active_validator_indices)) // config.CHURN_LIMIT_QUOTIENT)
+    return max(config.MIN_PER_EPOCH_CHURN_LIMIT * MIN_ACTIVATION_BALANCE, get_total_active_balance(state) // config.CHURN_LIMIT_QUOTIENT)
 
 
 def get_seed(state: BeaconState, epoch: Epoch, domain_type: DomainType) -> Bytes32:
@@ -1146,10 +1149,17 @@ def initiate_validator_exit(state: BeaconState, index: ValidatorIndex) -> None:
     # 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_balance_to_consume = validator.effective_balance
+    per_epoch_churn_limit = get_validator_churn_limit(state)
+    if state.exit_queue_churn + exit_balance_to_consume <= per_epoch_churn_limit:
+        state.exit_queue_churn += exit_balance_to_consume
+    else:  # Exit balance rolls over to subsequent epoch(s)
+        exit_balance_to_consume -= (per_epoch_churn_limit - state.exit_queue_churn)
         exit_queue_epoch += Epoch(1)
-
+        while exit_balance_to_consume >= per_epoch_churn_limit:
+            exit_balance_to_consume -= per_epoch_churn_limit
+            exit_queue_epoch += Epoch(1)
+        state.exit_queue_churn = exit_balance_to_consume
     # Set validator exit epoch and withdrawable epoch
     validator.exit_epoch = exit_queue_epoch
     validator.withdrawable_epoch = Epoch(validator.exit_epoch + config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
@@ -1209,7 +1219,7 @@ def initialize_beacon_state_from_eth1(eth1_block_hash: Hash32,
     for index, validator in enumerate(state.validators):
         balance = state.balances[index]
         validator.effective_balance = min(balance - balance % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
-        if validator.effective_balance == MAX_EFFECTIVE_BALANCE:
+        if validator.effective_balance >= MIN_ACTIVATION_BALANCE:
             validator.activation_eligibility_epoch = GENESIS_EPOCH
             validator.activation_epoch = GENESIS_EPOCH
 
@@ -1548,9 +1558,17 @@ def process_registry_updates(state: BeaconState) -> None:
         # 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)]:
+    activation_balance_to_consume = get_validator_churn_limit(state)
+    for index in activation_queue:
         validator = state.validators[index]
-        validator.activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
+        # Validator can now be activated
+        if state.activation_validator_balance + activation_balance_to_consume >= validator.effective_balance:
+            activation_balance_to_consume -= (validator.effective_balance - state.activation_validator_balance)
+            state.activation_validator_balance = Gwei(0)
+            validator.activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
+        else:  
+            state.activation_validator_balance += activation_balance_to_consume
+            break
 
 
 def process_slashings(state: BeaconState) -> None:
@@ -1794,9 +1812,9 @@ def apply_deposit(state: BeaconState,
             state.current_epoch_participation.append(ParticipationFlags(0b0000_0000))
             state.inactivity_scores.append(uint64(0))
     else:
-        # Increase balance by deposit amount
+        # Increase balance by deposit amount, up to MIN_ACTIVATION_BALANCE
         index = ValidatorIndex(validator_pubkeys.index(pubkey))
-        increase_balance(state, index, amount)
+        increase_balance(state, index, min(amount, MIN_ACTIVATION_BALANCE - state.balances[index]))
 
 
 def process_deposit(state: BeaconState, deposit: Deposit) -> None:
@@ -2334,9 +2352,14 @@ def get_slot_signature(state: BeaconState, slot: Slot, privkey: int) -> BLSSigna
     return bls.Sign(privkey, signing_root)
 
 
-def is_aggregator(state: BeaconState, slot: Slot, index: CommitteeIndex, slot_signature: BLSSignature) -> bool:
+def is_aggregator(state: BeaconState, slot: Slot, index: CommitteeIndex, validator_index: ValidatorIndex, slot_signature: BLSSignature) -> bool:
+    validator = state.validators[validator_index]
     committee = get_beacon_committee(state, slot, index)
-    modulo = max(1, len(committee) // TARGET_AGGREGATORS_PER_COMMITTEE)
+    min_balance_increments = validator.effective_balance // MIN_ACTIVATION_BALANCE
+    committee_balance = get_total_balance(state, set(committee))
+    denominator = committee_balance ** min_balance_increments
+    numerator = denominator - (committee_balance -  TARGET_AGGREGATORS_PER_COMMITTEE * MIN_ACTIVATION_BALANCE) ** min_balance_increments
+    modulo = denominator // numerator
     return bytes_to_uint64(hash(slot_signature)[0:8]) % modulo == 0
 
 
@@ -2378,7 +2401,7 @@ def compute_weak_subjectivity_period(state: BeaconState) -> uint64:
     N = len(get_active_validator_indices(state, get_current_epoch(state)))
     t = get_total_active_balance(state) // N // ETH_TO_GWEI
     T = MAX_EFFECTIVE_BALANCE // ETH_TO_GWEI
-    delta = get_validator_churn_limit(state)
+    delta = get_validator_churn_limit(state) // MIN_ACTIVATION_BALANCE
     Delta = MAX_DEPOSITS * SLOTS_PER_EPOCH
     D = SAFETY_DECAY
 
@@ -3540,24 +3563,38 @@ def has_eth1_withdrawal_credential(validator: Validator) -> bool:
     return validator.withdrawal_credentials[:1] == ETH1_ADDRESS_WITHDRAWAL_PREFIX
 
 
+def has_compounding_withdrawal_credential(validator: Validator) -> bool:
+    """
+    Check if ``validator`` has an 0x02 prefixed "compounding" withdrawal credential.
+    """
+    return validator.withdrawal_credentials[:1] == COMPOUNDING_WITHDRAWAL_PREFIX
+
+
 def is_fully_withdrawable_validator(validator: Validator, balance: Gwei, epoch: Epoch) -> bool:
     """
     Check if ``validator`` is fully withdrawable.
     """
     return (
-        has_eth1_withdrawal_credential(validator)
+        (has_eth1_withdrawal_credential(validator) or has_compounding_withdrawal_credential(validator))
         and validator.withdrawable_epoch <= epoch
         and balance > 0
     )
 
+def get_validator_excess_balance(validator: Validator, balance: Gwei) -> Gwei:
+    """
+    Get excess balance for partial withdrawals for ``validator``.
+    """
+    if has_compounding_withdrawal_credential(validator) and balance > MAX_EFFECTIVE_BALANCE:
+        return balance - MAX_EFFECTIVE_BALANCE
+    elif has_eth1_withdrawal_credential(validator) and balance > MIN_ACTIVATION_BALANCE:
+        return balance - MIN_ACTIVATION_BALANCE
+    return Gwei(0)
 
 def is_partially_withdrawable_validator(validator: Validator, balance: Gwei) -> bool:
     """
     Check if ``validator`` is partially withdrawable.
     """
-    has_max_effective_balance = validator.effective_balance == MAX_EFFECTIVE_BALANCE
-    has_excess_balance = balance > MAX_EFFECTIVE_BALANCE
-    return has_eth1_withdrawal_credential(validator) and has_max_effective_balance and has_excess_balance
+    return get_validator_excess_balance(validator, balance) > 0
 
 
 def process_historical_summaries_update(state: BeaconState) -> None:
@@ -3593,7 +3630,7 @@ def get_expected_withdrawals(state: BeaconState) -> Sequence[Withdrawal]:
                 index=withdrawal_index,
                 validator_index=validator_index,
                 address=ExecutionAddress(validator.withdrawal_credentials[12:]),
-                amount=balance - MAX_EFFECTIVE_BALANCE,
+                amount=get_validator_excess_balance(validator, balance),
             ))
             withdrawal_index += WithdrawalIndex(1)
         if len(withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD: