Move EL withdrawal/consolidation request processing into core/requests

beacon-chain/core/electra/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
         "transition.go",
         "upgrade.go",
         "validator.go",
-        "withdrawals.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra",
     visibility = ["//visibility:public"],
@@ -42,8 +41,6 @@ go_library(
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -63,12 +60,12 @@ go_test(
         "transition_test.go",
         "upgrade_test.go",
         "validator_test.go",
-        "withdrawals_test.go",
     ],
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -82,16 +79,12 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
         "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],
 )

beacon-chain/core/electra/consolidations.go

@@ -3,19 +3,14 @@ package electra
 import (
 	"bytes"
 	"context"
-	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
 )
 
@@ -95,217 +90,6 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 	return nil
 }
 
-// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
-// calls to the beacon state.
-//
-//	def process_consolidation_request(
-//	    state: BeaconState,
-//	    consolidation_request: ConsolidationRequest
-//	) -> None:
-//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
-//	        validator_pubkeys = [v.pubkey for v in state.validators]
-//	        request_source_pubkey = consolidation_request.source_pubkey
-//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
-//	        switch_to_compounding_validator(state, source_index)
-//	        return
-//
-//	    # Verify that source != target, so a consolidation cannot be used as an exit.
-//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
-//	        return
-//	    # If the pending consolidations queue is full, consolidation requests are ignored
-//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
-//	        return
-//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
-//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
-//	        return
-//
-//	    validator_pubkeys = [v.pubkey for v in state.validators]
-//	    # Verify pubkeys exists
-//	    request_source_pubkey = consolidation_request.source_pubkey
-//	    request_target_pubkey = consolidation_request.target_pubkey
-//	    if request_source_pubkey not in validator_pubkeys:
-//	        return
-//	    if request_target_pubkey not in validator_pubkeys:
-//	        return
-//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
-//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
-//	    source_validator = state.validators[source_index]
-//	    target_validator = state.validators[target_index]
-//
-//	    # Verify source withdrawal credentials
-//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
-//	    is_correct_source_address = (
-//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
-//	    )
-//	    if not (has_correct_credential and is_correct_source_address):
-//	        return
-//
-//	    # Verify that target has compounding withdrawal credentials
-//	    if not has_compounding_withdrawal_credential(target_validator):
-//	        return
-//
-//	    # Verify the source and the target are active
-//	    current_epoch = get_current_epoch(state)
-//	    if not is_active_validator(source_validator, current_epoch):
-//	        return
-//	    if not is_active_validator(target_validator, current_epoch):
-//	        return
-//	    # Verify exits for source and target have not been initiated
-//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        return
-//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        return
-//
-//	    # Verify the source has been active long enough
-//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
-//	        return
-//
-//	    # Verify the source has no pending withdrawals in the queue
-//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
-//	        return
-//	    # Initiate source validator exit and append pending consolidation
-//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
-//	        state, source_validator.effective_balance
-//	    )
-//	    source_validator.withdrawable_epoch = Epoch(
-//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-//	    )
-//	    state.pending_consolidations.append(PendingConsolidation(
-//	        source_index=source_index,
-//	        target_index=target_index
-//	    ))
-func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
-	if len(reqs) == 0 || st == nil {
-		return nil
-	}
-	curEpoch := slots.ToEpoch(st.Slot())
-	ffe := params.BeaconConfig().FarFutureEpoch
-	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
-	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
-
-	for _, cr := range reqs {
-		if cr == nil {
-			return errors.New("nil consolidation request")
-		}
-		if ctx.Err() != nil {
-			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
-		}
-		if IsValidSwitchToCompoundingRequest(st, cr) {
-			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
-			if !ok {
-				log.Error("Failed to find source validator index")
-				continue
-			}
-			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
-				log.WithError(err).Error("Failed to switch to compounding validator")
-			}
-			continue
-		}
-		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
-		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
-		if sourcePubkey == targetPubkey {
-			continue
-		}
-
-		if npc, err := st.NumPendingConsolidations(); err != nil {
-			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
-		} else if npc >= pcLimit {
-			continue
-		}
-
-		activeBal, err := helpers.TotalActiveBalance(st)
-		if err != nil {
-			return err
-		}
-		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
-			continue
-		}
-
-		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
-		if !ok {
-			continue
-		}
-		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
-		if !ok {
-			continue
-		}
-
-		srcV, err := st.ValidatorAtIndex(srcIdx)
-		if err != nil {
-			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
-		}
-
-		roSrcV, err := state_native.NewValidator(srcV)
-		if err != nil {
-			return err
-		}
-
-		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
-		if err != nil {
-			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
-		}
-
-		// Verify source withdrawal credentials
-		if !roSrcV.HasExecutionWithdrawalCredentials() {
-			continue
-		}
-		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
-		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
-			continue
-		}
-
-		// Target validator must have their withdrawal credentials set appropriately.
-		if !tgtV.HasCompoundingWithdrawalCredentials() {
-			continue
-		}
-
-		// Both validators must be active.
-		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
-			continue
-		}
-		// Neither validator is exiting.
-		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
-			continue
-		}
-
-		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
-		if overflow {
-			log.Error("Overflow when adding activation epoch and shard committee period")
-			continue
-		}
-		if uint64(curEpoch) < e {
-			continue
-		}
-		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
-		if err != nil {
-			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
-			continue
-		}
-		if hasBal {
-			continue
-		}
-
-		// Initiate the exit of the source validator.
-		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
-		if err != nil {
-			log.WithError(err).Error("Failed to compute consolidation epoch")
-			continue
-		}
-		srcV.ExitEpoch = exitEpoch
-		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
-		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
-			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
-		}
-
-		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
-			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
-		}
-	}
-
-	return nil
-}
-
 // IsValidSwitchToCompoundingRequest returns true if the given consolidation request is valid for switching to compounding.
 //
 // Spec code:

beacon-chain/core/electra/consolidations_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -457,7 +458,7 @@ func TestProcessConsolidationRequests(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := electra.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
+			err := requests.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return

beacon-chain/core/requests/BUILD.bazel

@@ -0,0 +1,52 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "consolidations.go",
+        "log.go",
+        "withdrawals.go",
+    ],
+    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/helpers: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",
+        "//consensus-types/primitives:go_default_library",
+        "//crypto/bls/common:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["withdrawals_test.go"],
+    deps = [
+        ":go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+    ],
+)

beacon-chain/core/requests/consolidations.go

@@ -0,0 +1,365 @@
+package requests
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	prysmMath "github.com/OffchainLabs/prysm/v7/math"
+	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/pkg/errors"
+)
+
+// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
+// calls to the beacon state.
+//
+//	def process_consolidation_request(
+//	    state: BeaconState,
+//	    consolidation_request: ConsolidationRequest
+//	) -> None:
+//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
+//	        validator_pubkeys = [v.pubkey for v in state.validators]
+//	        request_source_pubkey = consolidation_request.source_pubkey
+//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	        switch_to_compounding_validator(state, source_index)
+//	        return
+//
+//	    # Verify that source != target, so a consolidation cannot be used as an exit.
+//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
+//	        return
+//	    # If the pending consolidations queue is full, consolidation requests are ignored
+//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
+//	        return
+//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
+//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
+//	        return
+//
+//	    validator_pubkeys = [v.pubkey for v in state.validators]
+//	    # Verify pubkeys exists
+//	    request_source_pubkey = consolidation_request.source_pubkey
+//	    request_target_pubkey = consolidation_request.target_pubkey
+//	    if request_source_pubkey not in validator_pubkeys:
+//	        return
+//	    if request_target_pubkey not in validator_pubkeys:
+//	        return
+//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
+//	    source_validator = state.validators[source_index]
+//	    target_validator = state.validators[target_index]
+//
+//	    # Verify source withdrawal credentials
+//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
+//	    is_correct_source_address = (
+//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+//	    )
+//	    if not (has_correct_credential and is_correct_source_address):
+//	        return
+//
+//	    # Verify that target has compounding withdrawal credentials
+//	    if not has_compounding_withdrawal_credential(target_validator):
+//	        return
+//
+//	    # Verify the source and the target are active
+//	    current_epoch = get_current_epoch(state)
+//	    if not is_active_validator(source_validator, current_epoch):
+//	        return
+//	    if not is_active_validator(target_validator, current_epoch):
+//	        return
+//	    # Verify exits for source and target have not been initiated
+//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//
+//	    # Verify the source has been active long enough
+//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	        return
+//
+//	    # Verify the source has no pending withdrawals in the queue
+//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
+//	        return
+//	    # Initiate source validator exit and append pending consolidation
+//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
+//	        state, source_validator.effective_balance
+//	    )
+//	    source_validator.withdrawable_epoch = Epoch(
+//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+//	    )
+//	    state.pending_consolidations.append(PendingConsolidation(
+//	        source_index=source_index,
+//	        target_index=target_index
+//	    ))
+func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
+	ctx, span := trace.StartSpan(ctx, "requests.ProcessConsolidationRequests")
+	defer span.End()
+
+	if len(reqs) == 0 || st == nil {
+		return nil
+	}
+	curEpoch := slots.ToEpoch(st.Slot())
+	ffe := params.BeaconConfig().FarFutureEpoch
+	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
+
+	for _, cr := range reqs {
+		if cr == nil {
+			return errors.New("nil consolidation request")
+		}
+		if ctx.Err() != nil {
+			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
+		}
+
+		if isValidSwitchToCompoundingRequest(st, cr) {
+			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+			if !ok {
+				log.Error("Failed to find source validator index")
+				continue
+			}
+			if err := switchToCompoundingValidator(st, srcIdx); err != nil {
+				log.WithError(err).Error("Failed to switch to compounding validator")
+			}
+			continue
+		}
+
+		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
+		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
+		if sourcePubkey == targetPubkey {
+			continue
+		}
+
+		if npc, err := st.NumPendingConsolidations(); err != nil {
+			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
+		} else if npc >= pcLimit {
+			continue
+		}
+
+		activeBal, err := helpers.TotalActiveBalance(st)
+		if err != nil {
+			return err
+		}
+		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
+			continue
+		}
+
+		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
+		if !ok {
+			continue
+		}
+		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
+		if !ok {
+			continue
+		}
+
+		srcV, err := st.ValidatorAtIndex(srcIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
+		}
+
+		roSrcV, err := state_native.NewValidator(srcV)
+		if err != nil {
+			return err
+		}
+
+		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
+		}
+
+		// Verify source withdrawal credentials.
+		if !roSrcV.HasExecutionWithdrawalCredentials() {
+			continue
+		}
+		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address.
+		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
+			continue
+		}
+
+		// Target validator must have their withdrawal credentials set appropriately.
+		if !tgtV.HasCompoundingWithdrawalCredentials() {
+			continue
+		}
+
+		// Both validators must be active.
+		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
+			continue
+		}
+		// Neither validator is exiting.
+		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
+			continue
+		}
+
+		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
+		if overflow {
+			log.Error("Overflow when adding activation epoch and shard committee period")
+			continue
+		}
+		if uint64(curEpoch) < e {
+			continue
+		}
+
+		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
+		if err != nil {
+			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
+			continue
+		}
+		if hasBal {
+			continue
+		}
+
+		exitEpoch, err := computeConsolidationEpochAndUpdateChurn(st, primitives.Gwei(srcV.EffectiveBalance))
+		if err != nil {
+			log.WithError(err).Error("Failed to compute consolidation epoch")
+			continue
+		}
+		srcV.ExitEpoch = exitEpoch
+		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
+		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
+			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
+		}
+
+		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
+			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
+		}
+	}
+
+	return nil
+}
+
+func isValidSwitchToCompoundingRequest(st state.BeaconState, req *enginev1.ConsolidationRequest) bool {
+	if req.SourcePubkey == nil || req.TargetPubkey == nil {
+		return false
+	}
+
+	if !bytes.Equal(req.SourcePubkey, req.TargetPubkey) {
+		return false
+	}
+
+	srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.SourcePubkey))
+	if !ok {
+		return false
+	}
+	srcV, err := st.ValidatorAtIndexReadOnly(srcIdx)
+	if err != nil {
+		return false
+	}
+
+	sourceAddress := req.SourceAddress
+	withdrawalCreds := srcV.GetWithdrawalCredentials()
+	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
+		return false
+	}
+
+	if !srcV.HasETH1WithdrawalCredentials() {
+		return false
+	}
+
+	curEpoch := slots.ToEpoch(st.Slot())
+	if !helpers.IsActiveValidatorUsingTrie(srcV, curEpoch) {
+		return false
+	}
+
+	if srcV.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
+		return false
+	}
+
+	return true
+}
+
+func switchToCompoundingValidator(st state.BeaconState, idx primitives.ValidatorIndex) error {
+	v, err := st.ValidatorAtIndex(idx)
+	if err != nil {
+		return err
+	}
+	if len(v.WithdrawalCredentials) == 0 {
+		return errors.New("validator has no withdrawal credentials")
+	}
+
+	v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	if err := st.UpdateValidatorAtIndex(idx, v); err != nil {
+		return err
+	}
+	return queueExcessActiveBalance(st, idx)
+}
+
+func queueExcessActiveBalance(st state.BeaconState, idx primitives.ValidatorIndex) error {
+	bal, err := st.BalanceAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	if bal > params.BeaconConfig().MinActivationBalance {
+		if err := st.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
+			return err
+		}
+		excessBalance := bal - params.BeaconConfig().MinActivationBalance
+		val, err := st.ValidatorAtIndexReadOnly(idx)
+		if err != nil {
+			return err
+		}
+		pk := val.PublicKey()
+		return st.AppendPendingDeposit(&eth.PendingDeposit{
+			PublicKey:             pk[:],
+			WithdrawalCredentials: val.GetWithdrawalCredentials(),
+			Amount:                excessBalance,
+			Signature:             common.InfiniteSignature[:],
+			Slot:                  params.BeaconConfig().GenesisSlot,
+		})
+	}
+	return nil
+}
+
+func computeConsolidationEpochAndUpdateChurn(st state.BeaconState, consolidationBalance primitives.Gwei) (primitives.Epoch, error) {
+	earliestEpoch, err := st.EarliestConsolidationEpoch()
+	if err != nil {
+		return 0, err
+	}
+	earliestConsolidationEpoch := max(earliestEpoch, helpers.ActivationExitEpoch(slots.ToEpoch(st.Slot())))
+
+	activeBal, err := helpers.TotalActiveBalance(st)
+	if err != nil {
+		return 0, err
+	}
+	perEpochConsolidationChurn := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+
+	var consolidationBalanceToConsume primitives.Gwei
+	if earliestEpoch < earliestConsolidationEpoch {
+		consolidationBalanceToConsume = perEpochConsolidationChurn
+	} else {
+		consolidationBalanceToConsume, err = st.ConsolidationBalanceToConsume()
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	if consolidationBalance > consolidationBalanceToConsume {
+		balanceToProcess := consolidationBalance - consolidationBalanceToConsume
+		additionalEpochs, err := prysmMath.Div64(uint64(balanceToProcess-1), uint64(perEpochConsolidationChurn))
+		if err != nil {
+			return 0, err
+		}
+		additionalEpochs++
+		earliestConsolidationEpoch += primitives.Epoch(additionalEpochs)
+		consolidationBalanceToConsume += primitives.Gwei(additionalEpochs) * perEpochConsolidationChurn
+	}
+
+	if err := st.SetConsolidationBalanceToConsume(consolidationBalanceToConsume - consolidationBalance); err != nil {
+		return 0, err
+	}
+	if err := st.SetEarliestConsolidationEpoch(earliestConsolidationEpoch); err != nil {
+		return 0, err
+	}
+
+	return earliestConsolidationEpoch, nil
+}

beacon-chain/core/requests/log.go

@@ -0,0 +1,9 @@
+// Code generated by hack/gen-logs.sh; DO NOT EDIT.
+// This file is created and regenerated automatically. Anything added here might get removed.
+package requests
+
+import "github.com/sirupsen/logrus"
+
+// The prefix for logs from this package will be the text after the last slash in the package path.
+// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
+var log = logrus.WithField("package", "beacon-chain/core/requests")

beacon-chain/core/requests/withdrawals.go

@@ -1,4 +1,4 @@
-package electra
+package requests
 
 import (
 	"bytes"
@@ -88,7 +88,7 @@ import (
 //	        withdrawable_epoch=withdrawable_epoch,
 //	    ))
 func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.WithdrawalRequest) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "electra.ProcessWithdrawalRequests")
+	ctx, span := trace.StartSpan(ctx, "requests.ProcessWithdrawalRequests")
 	defer span.End()
 	currentEpoch := slots.ToEpoch(st.Slot())
 	if len(wrs) == 0 {

beacon-chain/core/requests/withdrawals_test.go

@@ -1,9 +1,9 @@
-package electra_test
+package requests_test
 
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -289,7 +289,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
-			got, err := electra.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
+			got, err := requests.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return

beacon-chain/core/transition/BUILD.bazel

@@ -27,6 +27,7 @@ go_library(
         "//beacon-chain/core/execution:go_default_library",
         "//beacon-chain/core/fulu:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",

beacon-chain/core/transition/electra.go

@@ -6,6 +6,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	coreRequests "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	v "github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -107,7 +108,7 @@ func electraOperations(ctx context.Context, st state.BeaconState, block interfac
 			return nil, electra.NewExecReqError("nil withdrawal request")
 		}
 	}
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
+	st, err = coreRequests.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
 	if err != nil {
 		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process withdrawal requests").Error())
 	}
@@ -116,7 +117,7 @@ func electraOperations(ctx context.Context, st state.BeaconState, block interfac
 			return nil, electra.NewExecReqError("nil consolidation request")
 		}
 	}
-	if err := electra.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
+	if err := coreRequests.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
 		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process consolidation requests").Error())
 	}
 	return st, nil

changelog/terencechain_core-requests.md

@@ -0,0 +1,2 @@
+### Ignored
+- Move withdrawal/consolidation request processing into `beacon-chain/core/requests` to avoid fork/package dependency cycles.

specrefs/functions.yml

@@ -5388,7 +5388,7 @@
 
 - name: process_consolidation_request
   sources:
-    - file: beacon-chain/core/electra/consolidations.go
+    - file: beacon-chain/core/requests/consolidations.go
       search: func ProcessConsolidationRequests(
   spec: |
     <spec fn="process_consolidation_request" fork="electra" hash="4da4b0fb">
@@ -6993,7 +6993,7 @@
 
 - name: process_withdrawal_request
   sources:
-    - file: beacon-chain/core/electra/withdrawals.go
+    - file: beacon-chain/core/requests/withdrawals.go
       search: func ProcessWithdrawalRequests(
   spec: |
     <spec fn="process_withdrawal_request" fork="electra" hash="c21a0a53">

testing/spectest/shared/common/operations/BUILD.bazel

@@ -29,6 +29,7 @@ go_library(
         "//beacon-chain/core/electra:go_default_library",
         "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",

testing/spectest/shared/common/operations/consolidations.go

@@ -5,7 +5,7 @@ import (
 	"path"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
@@ -32,7 +32,7 @@ func RunConsolidationTest(t *testing.T, config string, fork string, block blockW
 				if err != nil {
 					return nil, err
 				}
-				return s, electra.ProcessConsolidationRequests(ctx, s, er.Consolidations)
+				return nil, requests.ProcessConsolidationRequests(ctx, s, er.Consolidations)
 			})
 		})
 	}

testing/spectest/shared/common/operations/withdrawal_request.go

@@ -5,7 +5,7 @@ import (
 	"path"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
@@ -33,7 +33,7 @@ func RunWithdrawalRequestTest(t *testing.T, config string, fork string, block bl
 				bod := b.Block().Body()
 				e, err := bod.ExecutionRequests()
 				require.NoError(t, err)
-				return electra.ProcessWithdrawalRequests(ctx, s, e.Withdrawals)
+				return requests.ProcessWithdrawalRequests(ctx, s, e.Withdrawals)
 			})
 		})
 	}