EIP-7002:Execution layer triggerable withdrawals

beacon-chain/core/electra/BUILD.bazel

@@ -22,6 +22,7 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/params:go_default_library",
@@ -33,6 +34,7 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
 )
@@ -46,6 +48,7 @@ go_test(
         "effective_balance_updates_test.go",
         "upgrade_test.go",
         "validator_test.go",
+        "withdrawals_test.go",
     ],
     deps = [
         ":go_default_library",
@@ -66,5 +69,6 @@ go_test(
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
     ],
 )

beacon-chain/core/electra/transition.go

@@ -73,10 +73,12 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process rewards and penalties")
 	}
+
 	state, err = ProcessRegistryUpdates(ctx, state)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process registry updates")
 	}
+
 	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
 	if err != nil {
 		return nil, err
@@ -89,6 +91,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	if err != nil {
 		return nil, err
 	}
+
 	if err = ProcessPendingBalanceDeposits(ctx, state, primitives.Gwei(bp.ActiveCurrentEpoch)); err != nil {
 		return nil, err
 	}
@@ -98,6 +101,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	if err := ProcessEffectiveBalanceUpdates(state); err != nil {
 		return nil, err
 	}
+
 	state, err = ProcessSlashingsReset(state)
 	if err != nil {
 		return nil, err

beacon-chain/core/electra/withdrawals.go

@@ -1,10 +1,21 @@
 package electra
 
 import (
+	"bytes"
 	"context"
 
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // ProcessExecutionLayerWithdrawRequests processes the validator withdrawals from the provided execution payload
@@ -75,6 +86,107 @@ import (
 //	   withdrawable_epoch=withdrawable_epoch,
 //	   ))
 func ProcessExecutionLayerWithdrawRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.ExecutionLayerWithdrawalRequest) (state.BeaconState, error) {
-	//TODO: replace with real implementation
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessExecutionLayerWithdrawRequests")
+	defer span.End()
+	currentEpoch := slots.ToEpoch(st.Slot())
+	for _, wr := range wrs {
+		if wr == nil {
+			return nil, errors.New("nil execution layer withdrawal request")
+		}
+		amount := wr.Amount
+		isFullExitRequest := amount == params.BeaconConfig().FullExitRequestAmount
+		// If partial withdrawal queue is full, only full exits are processed
+		if n, err := st.NumPendingPartialWithdrawals(); err != nil {
+			return nil, err
+		} else if n == params.BeaconConfig().PendingPartialWithdrawalsLimit && !isFullExitRequest {
+			// if the PendingPartialWithdrawalsLimit is met, the user would have paid for a partial withdrawal that's not included
+			log.Debugln("Skipping execution layer withdrawal request, PendingPartialWithdrawalsLimit reached")
+			continue
+		}
+
+		vIdx, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(wr.ValidatorPubkey))
+		if !exists {
+			log.Debugln("Skipping execution layer withdrawal request, validator index not found")
+			continue
+		}
+		validator, err := st.ValidatorAtIndex(vIdx)
+		if err != nil {
+			return nil, err
+		}
+		// Verify withdrawal credentials
+		hasCorrectCredential := helpers.HasExecutionWithdrawalCredentials(validator)
+		isCorrectSourceAddress := bytes.Equal(validator.WithdrawalCredentials[12:], wr.SourceAddress)
+		if !hasCorrectCredential || !isCorrectSourceAddress {
+			log.Debugln("Skipping execution layer withdrawal request, wrong withdrawal credentials")
+			continue
+		}
+
+		// Verify the validator is active.
+		if !helpers.IsActiveValidator(validator, currentEpoch) {
+			log.Debugln("Skipping execution layer withdrawal request, validator not active")
+			continue
+		}
+		// Verify the validator has not yet submitted an exit.
+		if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+			log.Debugln("Skipping execution layer withdrawal request, validator has submitted an exit already")
+			continue
+		}
+		// Verify the validator has been active long enough.
+		if currentEpoch < validator.ActivationEpoch.AddEpoch(params.BeaconConfig().ShardCommitteePeriod) {
+			log.Debugln("Skipping execution layer withdrawal request, validator has not been active long enough")
+			continue
+		}
+
+		pendingBalanceToWithdraw, err := st.PendingBalanceToWithdraw(vIdx)
+		if err != nil {
+			return nil, err
+		}
+		if isFullExitRequest {
+			// Only exit validator if it has no pending withdrawals in the queue
+			if pendingBalanceToWithdraw == 0 {
+				maxExitEpoch, churn := validators.MaxExitEpochAndChurn(st)
+				var err error
+				st, _, err = validators.InitiateValidatorExit(ctx, st, vIdx, maxExitEpoch, churn)
+				if err != nil {
+					return nil, err
+				}
+			}
+			continue
+		}
+
+		hasSufficientEffectiveBalance := validator.EffectiveBalance >= params.BeaconConfig().MinActivationBalance
+		vBal, err := st.BalanceAtIndex(vIdx)
+		if err != nil {
+			return nil, err
+		}
+		hasExcessBalance := vBal > params.BeaconConfig().MinActivationBalance+pendingBalanceToWithdraw
+
+		// Only allow partial withdrawals with compounding withdrawal credentials
+		if helpers.HasCompoundingWithdrawalCredential(validator) && hasSufficientEffectiveBalance && hasExcessBalance {
+			//to_withdraw = min(
+			//	state.balances[index] - MIN_ACTIVATION_BALANCE - pending_balance_to_withdraw,
+			//	amount
+			//)
+
+			// note: you can safely subtract these values because haxExcessBalance is checked
+			toWithdraw := min(vBal-params.BeaconConfig().MinActivationBalance-pendingBalanceToWithdraw, amount)
+			exitQueueEpoch, err := st.ExitEpochAndUpdateChurn(primitives.Gwei(toWithdraw))
+			if err != nil {
+				return nil, err
+			}
+			// safe add the uint64 to avoid overflow
+			withdrawableEpoch, err := exitQueueEpoch.SafeAddEpoch(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to add withdrawablility delay to exit queue")
+			}
+			if err := st.AppendPendingPartialWithdrawal(&ethpb.PendingPartialWithdrawal{
+				Index:             vIdx,
+				Amount:            toWithdraw,
+				WithdrawableEpoch: withdrawableEpoch,
+			}); err != nil {
+				return nil, err
+			}
+		}
+	}
 	return st, nil
 }