feat(withdrawals): Allow for Disabling Withdrawals [DO NOT MERGE]

chain/spec.go

@@ -164,6 +164,10 @@ type WithdrawalsSpec interface {
 	// which is set to MIN_VALIDATOR_WITHDRAWABILITY_DELAY epochs after its exit_epoch.
 	// This is to allow some extra time for any slashable offences by the validator to be detected and reported.
 	MinValidatorWithdrawabilityDelay() math.Epoch
+
+	// WithdrawalsEnabled is a switch that can be used to freeze withdrawals in an emergency scenario.
+	// An exception is made for the EVM inflation withdrawal which is always active.
+	WithdrawalsEnabled(timestamp math.U64) bool
 }
 
 // Spec defines an interface for accessing chain-specific parameters.
@@ -469,3 +473,18 @@ func (s spec) EVMInflationPerBlock(timestamp math.U64) math.Gwei {
 		panic(fmt.Sprintf("EVMInflationPerBlock not supported for this fork version: %d", fv))
 	}
 }
+
+// WithdrawalsEnabled is a switch that can be used to freeze withdrawals in an emergency scenario.
+// An exception is made for the EVM inflation withdrawal which is always active.
+func (s spec) WithdrawalsEnabled(_ math.U64) bool {
+	return true
+	/*
+		Example:
+			 fv := s.ActiveForkVersionForTimestamp(timestamp)
+			 switch fv {
+			 case version.Electra1():
+				 return false
+			 default:
+			 	return true
+	*/
+}

state-transition/core/state/statedb.go

@@ -116,6 +116,16 @@ func (s *StateDB) ExpectedWithdrawals(timestamp math.U64) (engineprimitives.With
 	// The first withdrawal is fixed to be the EVM inflation withdrawal.
 	withdrawals = append(withdrawals, s.EVMInflationWithdrawal(timestamp))
 
+	// If withdrawals are not enabled, return only the inflation withdrawal.
+	// Once withdrawals are re-enabled, all pending withdrawals will be processed.
+	// 1. Partial Withdrawal Requests will remain untouched and will be handled after re-enabling.
+	// 2. Validators whose balance is above MAX_EFFECTIVE_BALANCE will not be withdrawn till re-enabled.
+	// 3. Validators who have initiated a full withdrawal will not be withdrawn till re-enabled.
+	// 4. Validators who have been kicked out due to validator set cap will not be withdrawn till re-enabled.
+	if !s.cs.WithdrawalsEnabled(timestamp) {
+		return withdrawals, processedPartialWithdrawals, nil
+	}
+
 	withdrawalIndex, err := s.GetNextWithdrawalIndex()
 	if err != nil {
 		return nil, 0, err

state-transition/core/state_processor_staking.go

@@ -67,8 +67,10 @@ func (sp *StateProcessor) processOperations(
 		}
 	}
 
-	if version.EqualsOrIsAfter(blk.GetForkVersion(), version.Electra()) {
-		// After Electra, validators can request withdrawals through execution requests which must be handled.
+	// After Electra, validators can request withdrawals through execution requests which must be handled.
+	// If withdrawals are enabled, process the withdrawals. Otherwise, the withdrawal requests are ignored
+	// to prevent withdrawals from excessively queuing up.
+	if version.EqualsOrIsAfter(blk.GetForkVersion(), version.Electra()) && sp.cs.WithdrawalsEnabled(blk.GetTimestamp()) {
 		requests, err := blk.GetBody().GetExecutionRequests()
 		if err != nil {
 			return err

testing/simulated/components.go

@@ -28,6 +28,7 @@ import (
 	"github.com/berachain/beacon-kit/chain"
 	"github.com/berachain/beacon-kit/config/spec"
 	"github.com/berachain/beacon-kit/node-core/components"
+	"github.com/berachain/beacon-kit/primitives/math"
 )
 
 func FixedComponents(t *testing.T) []any {
@@ -144,3 +145,40 @@ func ProvidePectraWithdrawalTestChainSpec() (chain.Spec, error) {
 	}
 	return chainSpec, nil
 }
+
+// frozenWithdrawalsSpec is used in ProvideFreezeWithdrawalsChainSpec as a chain spec with withdrawals disabled
+// after a certain time, then renabled
+type frozenWithdrawalsSpec struct {
+	chain.Spec
+}
+
+func (s frozenWithdrawalsSpec) WithdrawalsEnabled(timestamp math.U64) bool {
+	// withdrawals disabled from timestamp 10 to 30
+	if timestamp >= 10 && timestamp < 30 {
+		return false
+	}
+	return true
+}
+
+// ProvideFreezeWithdrawalsChainSpec provides a chain spec with pectra as the genesis, but with the
+// withdrawals disabled and then re-enabled.
+func ProvideFreezeWithdrawalsChainSpec() (chain.Spec, error) {
+	specData := spec.TestnetChainSpecData()
+	// Both Deneb1 and Electra happen in genesis.
+	specData.GenesisTime = 0
+	specData.Deneb1ForkTime = 0
+	specData.ElectraForkTime = 0
+	// We set slots per epoch to 1 for faster observation of withdrawal behaviour
+	specData.SlotsPerEpoch = 1
+	// We set this to 4 so tests are faster
+	specData.MinValidatorWithdrawabilityDelay = 4
+	// Reduced validator set cap so eviction withdrawals are easier to trigger
+	specData.ValidatorSetCap = 1
+
+	chainSpec, err := chain.NewSpec(specData)
+	if err != nil {
+		return nil, err
+	}
+
+	return frozenWithdrawalsSpec{chainSpec}, nil
+}