feature(state-processor): update validators EffectiveBalance only when epoch turns

mod/chain-spec/pkg/chain/chain_spec.go

@@ -45,6 +45,12 @@ type Spec[
 	// calculations.
 	EffectiveBalanceIncrement() uint64
 
+	HysteresisQuotient() uint64
+
+	HysteresisDownwardMultiplier() uint64
+
+	HysteresisUpwardMultiplier() uint64
+
 	// Time parameters constants.
 
 	// SlotsPerEpoch returns the number of slots in an epoch.
@@ -245,6 +251,24 @@ func (c chainSpec[
 	return c.Data.EffectiveBalanceIncrement
 }
 
+func (c chainSpec[
+	DomainTypeT, EpochT, ExecutionAddressT, SlotT, CometBFTConfigT,
+]) HysteresisQuotient() uint64 {
+	return c.Data.HysteresisQuotient
+}
+
+func (c chainSpec[
+	DomainTypeT, EpochT, ExecutionAddressT, SlotT, CometBFTConfigT,
+]) HysteresisDownwardMultiplier() uint64 {
+	return c.Data.HysteresisDownwardMultiplier
+}
+
+func (c chainSpec[
+	DomainTypeT, EpochT, ExecutionAddressT, SlotT, CometBFTConfigT,
+]) HysteresisUpwardMultiplier() uint64 {
+	return c.Data.HysteresisUpwardMultiplier
+}
+
 // SlotsPerEpoch returns the number of slots per epoch.
 func (c chainSpec[
 	DomainTypeT, EpochT, ExecutionAddressT, SlotT, CometBFTConfigT,

mod/chain-spec/pkg/chain/data.go

@@ -43,6 +43,11 @@ type SpecData[
 	// EffectiveBalanceIncrement is the effective balance increment.
 	EffectiveBalanceIncrement uint64 `mapstructure:"effective-balance-increment"`
 
+	HysteresisQuotient uint64 `mapstructure:"hysteresis-quotient"`
+
+	HysteresisDownwardMultiplier uint64 `mapstructure:"hysteresis-downward-multiplier"`
+
+	HysteresisUpwardMultiplier uint64 `mapstructure:"hysteresis-upward-multiplier"`
 	// Time parameters constants.
 	//
 	// SlotsPerEpoch is the number of slots per epoch.

mod/state-transition/pkg/core/state_processor.go

@@ -23,6 +23,7 @@ package core
 import (
 	"bytes"
 
+	"github.com/berachain/beacon-kit/mod/consensus-types/pkg/types"
 	"github.com/berachain/beacon-kit/mod/errors"
 	"github.com/berachain/beacon-kit/mod/primitives/pkg/common"
 	"github.com/berachain/beacon-kit/mod/primitives/pkg/constants"
@@ -197,34 +198,26 @@ func (sp *StateProcessor[
 ]) ProcessSlots(
 	st BeaconStateT, slot math.Slot,
 ) (transition.ValidatorUpdates, error) {
-	var (
-		validatorUpdates      transition.ValidatorUpdates
-		epochValidatorUpdates transition.ValidatorUpdates
-	)
-
+	var res transition.ValidatorUpdates
 	stateSlot, err := st.GetSlot()
 	if err != nil {
 		return nil, err
 	}
 
 	// Iterate until we are "caught up".
 	for ; stateSlot < slot; stateSlot++ {
-		// Process the slot
 		if err = sp.processSlot(st); err != nil {
 			return nil, err
 		}
 
 		// Process the Epoch Boundary.
 		boundary := (stateSlot.Unwrap()+1)%sp.cs.SlotsPerEpoch() == 0
 		if boundary {
-			if epochValidatorUpdates, err =
-				sp.processEpoch(st); err != nil {
+			var epochUpdates transition.ValidatorUpdates
+			if epochUpdates, err = sp.processEpoch(st); err != nil {
 				return nil, err
 			}
-			validatorUpdates = append(
-				validatorUpdates,
-				epochValidatorUpdates...,
-			)
+			res = append(res, epochUpdates...)
 		}
 
 		// We update on the state because we need to
@@ -234,7 +227,7 @@ func (sp *StateProcessor[
 		}
 	}
 
-	return validatorUpdates, nil
+	return res, nil
 }
 
 // processSlot is run when a slot is missed.
@@ -336,6 +329,9 @@ func (sp *StateProcessor[
 	if err := sp.processRewardsAndPenalties(st); err != nil {
 		return nil, err
 	}
+	if err := sp.processEffectiveBalanceUpdates(st); err != nil {
+		return nil, err
+	}
 	if err := sp.processSlashingsReset(st); err != nil {
 		return nil, err
 	}
@@ -516,3 +512,54 @@ func (sp *StateProcessor[
 
 	return nil
 }
+
+// processEffectiveBalanceUpdates as defined in the Ethereum 2.0 specification.
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#effective-balances-updates
+//
+//nolint:lll
+func (sp *StateProcessor[
+	_, _, _, BeaconStateT, _, _, _, _, _, _, _, _, _, _, _, _, _,
+]) processEffectiveBalanceUpdates(
+	st BeaconStateT,
+) error {
+	// Update effective balances with hysteresis
+	validators, err := st.GetValidators()
+	if err != nil {
+		return err
+	}
+
+	var (
+		hysteresisIncrement = sp.cs.EffectiveBalanceIncrement() / sp.cs.HysteresisQuotient()
+		downwardThreshold   = hysteresisIncrement * sp.cs.HysteresisDownwardMultiplier()
+		upwardThreshold     = hysteresisIncrement * sp.cs.HysteresisUpwardMultiplier()
+
+		idx     math.U64
+		balance math.Gwei
+	)
+
+	for _, val := range validators {
+		idx, err = st.ValidatorIndexByPubkey(val.GetPubkey())
+		if err != nil {
+			return err
+		}
+
+		balance, err = st.GetBalance(idx)
+		if err != nil {
+			return err
+		}
+
+		if balance+math.Gwei(downwardThreshold) < val.GetEffectiveBalance() ||
+			val.GetEffectiveBalance()+math.Gwei(upwardThreshold) < balance {
+			updatedBalance := types.ComputeEffectiveBalance(
+				balance,
+				math.U64(sp.cs.EffectiveBalanceIncrement()),
+				math.U64(sp.cs.MaxEffectiveBalance()),
+			)
+			val.SetEffectiveBalance(updatedBalance)
+			if err = st.UpdateValidatorAtIndex(idx, val); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

mod/state-transition/pkg/core/state_processor_committee.go

@@ -21,6 +21,7 @@
 package core
 
 import (
+	"github.com/berachain/beacon-kit/mod/primitives/pkg/math"
 	"github.com/berachain/beacon-kit/mod/primitives/pkg/transition"
 	"github.com/sourcegraph/conc/iter"
 )
@@ -36,8 +37,16 @@ func (sp *StateProcessor[
 		return nil, err
 	}
 
+	// filter out validators whose effective balance is not sufficient to validate
+	activeVals := make([]ValidatorT, 0, len(vals))
+	for _, val := range vals {
+		if val.GetEffectiveBalance() > math.U64(sp.cs.EjectionBalance()) {
+			activeVals = append(activeVals, val)
+		}
+	}
+
 	return iter.MapErr(
-		vals,
+		activeVals,
 		func(val *ValidatorT) (*transition.ValidatorUpdate, error) {
 			v := (*val)
 			return &transition.ValidatorUpdate{