Tests

CHANGELOG.md

@@ -14,6 +14,8 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Light client support: Add light client database changes.
 - Light client support: Implement capella and deneb changes.
 - Light client support: Implement `BlockToLightClientHeader` function.
+- Electra EIP6110: Queue deposit
+- Light client support: Implement `BlockToLightClientHeaderXXX` functions upto Deneb
 - GetBeaconStateV2: add Electra case.
 - Implement [consensus-specs/3875](https://github.com/ethereum/consensus-specs/pull/3875)
 - Tests to ensure sepolia config matches the official upstream yaml
@@ -38,6 +40,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - `grpc-gateway-corsdomain` is renamed to http-cors-domain. The old name can still be used as an alias.
 - `api-timeout` is changed from int flag to duration flag, default value updated.
 - Light client support: abstracted out the light client headers with different versions.
+- Electra EIP6110: Queue deposit requests changes from consensus spec pr #3818
 - `ApplyToEveryValidator` has been changed to prevent misuse bugs, it takes a closure that takes a `ReadOnlyValidator` and returns a raw pointer to a `Validator`. 
 - Removed gorilla mux library and replaced it with net/http updates in go 1.22.
 - Clean up `ProposeBlock` for validator client to reduce cognitive scoring and enable further changes.
@@ -47,6 +50,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Update light client helper functions to reference `dev` branch of CL specs
 - Updated Libp2p Dependencies to allow prysm to use gossipsub v1.2 .
 - Updated Sepolia bootnodes.
+- Switch to compounding when consolidating with source==target.
 
 ### Deprecated
 - `--disable-grpc-gateway` flag is deprecated due to grpc gateway removal.

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.6"
+consensus_spec_version = "v1.5.0-alpha.7"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-M7u/Ot/Vzorww+dFbHp0cxLyM2mezJjijCzq+LY3uvs=",
+    integrity = "sha256-Vo4+1bsRNYMGXjlpIYKEqt2WPjeGSbjeFQFKVUhf1Yc=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-deOSeLRsmHXvkRp8n2bs3HXdkGUJWWqu8KFM/QABbZg=",
+    integrity = "sha256-TsQtQVPyQA6htrTjL1cd/oWEkM83aK4Y0pT9W6ssKYU=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-Zz7YCf6XVf57nzSEGq9ToflJFHM0lAGwhd18l9Rf3hA=",
+    integrity = "sha256-4g7EijlsIJVKGADlVL6ka9ikcwow8WuKHaABONA0Cxg=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-BoXckDxXnDcEmAjg/dQgf/tLiJsb6CT0aZvmWHFijrY=",
+    integrity = "sha256-i5+48P/BqxA+q39OufAiotW2llUq97+4j1++ViI96dM=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/server/structs/conversions.go

@@ -1476,12 +1476,15 @@ func DepositSnapshotFromConsensus(ds *eth.DepositSnapshot) *DepositSnapshot {
 	}
 }
 
-func PendingBalanceDepositsFromConsensus(ds []*eth.PendingBalanceDeposit) []*PendingBalanceDeposit {
+func PendingDepositsFromConsensus(ds []*eth.PendingDeposit) []*PendingDeposit {
-	deposits := make([]*PendingBalanceDeposit, len(ds))
+	deposits := make([]*PendingDeposit, len(ds))
 	for i, d := range ds {
-		deposits[i] = &PendingBalanceDeposit{
+		deposits[i] = &PendingDeposit{
-			Index:  fmt.Sprintf("%d", d.Index),
+			Pubkey:                hexutil.Encode(d.PublicKey),
-			Amount: fmt.Sprintf("%d", d.Amount),
+			WithdrawalCredentials: hexutil.Encode(d.WithdrawalCredentials),
+			Amount:                fmt.Sprintf("%d", d.Amount),
+			Signature:             hexutil.Encode(d.Signature),
+			Slot:                  fmt.Sprintf("%d", d.Slot),
 		}
 	}
 	return deposits

api/server/structs/conversions_state.go

@@ -722,7 +722,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 	if err != nil {
 		return nil, err
 	}
-	pbd, err := st.PendingBalanceDeposits()
+	pbd, err := st.PendingDeposits()
 	if err != nil {
 		return nil, err
 	}
@@ -770,7 +770,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
 		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
 		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
-		PendingBalanceDeposits:        PendingBalanceDepositsFromConsensus(pbd),
+		PendingDeposits:               PendingDepositsFromConsensus(pbd),
 		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
 		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
 	}, nil

api/server/structs/other.go

@@ -257,9 +257,12 @@ type ConsolidationRequest struct {
 	TargetPubkey  string `json:"target_pubkey"`
 }
 
-type PendingBalanceDeposit struct {
+type PendingDeposit struct {
-	Index  string `json:"index"`
+	Pubkey                string `json:"pubkey"`
-	Amount string `json:"amount"`
+	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Amount                string `json:"amount"`
+	Signature             string `json:"signature"`
+	Slot                  string `json:"slot"`
 }
 
 type PendingPartialWithdrawal struct {

api/server/structs/state.go

@@ -176,7 +176,7 @@ type BeaconStateElectra struct {
 	EarliestExitEpoch             string                         `json:"earliest_exit_epoch"`
 	ConsolidationBalanceToConsume string                         `json:"consolidation_balance_to_consume"`
 	EarliestConsolidationEpoch    string                         `json:"earliest_consolidation_epoch"`
-	PendingBalanceDeposits        []*PendingBalanceDeposit       `json:"pending_balance_deposits"`
+	PendingDeposits               []*PendingDeposit              `json:"pending_deposits"`
 	PendingPartialWithdrawals     []*PendingPartialWithdrawal    `json:"pending_partial_withdrawals"`
 	PendingConsolidations         []*PendingConsolidation        `json:"pending_consolidations"`
 }

beacon-chain/core/altair/deposit.go

@@ -7,10 +7,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 // ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
@@ -130,7 +128,7 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verif
 				return beaconState, nil
 			}
 		}
-		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
+		if err := blocks.AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
 			return nil, err
 		}
 	} else {
@@ -140,72 +138,3 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verif
 	}
 	return beaconState, nil
 }
-
-// AddValidatorToRegistry updates the beacon state with validator information
-// def add_validator_to_registry(state: BeaconState,
-//
-//	                          pubkey: BLSPubkey,
-//	                          withdrawal_credentials: Bytes32,
-//	                          amount: uint64) -> None:
-//	index = get_index_for_new_validator(state)
-//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
-//	set_or_append_list(state.validators, index, validator)
-//	set_or_append_list(state.balances, index, 0)
-//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
-//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
-//	set_or_append_list(state.inactivity_scores, index, uint64(0)) // New in Altair
-func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
-	val := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
-	if err := beaconState.AppendValidator(val); err != nil {
-		return err
-	}
-	if err := beaconState.AppendBalance(amount); err != nil {
-		return err
-	}
-
-	// only active in altair and only when it's a new validator (after append balance)
-	if beaconState.Version() >= version.Altair {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
-			return err
-		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// GetValidatorFromDeposit gets a new validator object with provided parameters
-//
-// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
-//
-//	effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
-//
-//	return Validator(
-//	    pubkey=pubkey,
-//	    withdrawal_credentials=withdrawal_credentials,
-//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
-//	    activation_epoch=FAR_FUTURE_EPOCH,
-//	    exit_epoch=FAR_FUTURE_EPOCH,
-//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
-//	    effective_balance=effective_balance,
-//	)
-func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
-	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
-	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
-		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
-	}
-
-	return &ethpb.Validator{
-		PublicKey:                  pubKey,
-		WithdrawalCredentials:      withdrawalCredentials,
-		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
-		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-		EffectiveBalance:           effectiveBalance,
-	}
-}

beacon-chain/core/blocks/deposit.go

@@ -14,8 +14,78 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
+// AddValidatorToRegistry updates the beacon state with validator information
+// def add_validator_to_registry(state: BeaconState,
+//
+//	                          pubkey: BLSPubkey,
+//	                          withdrawal_credentials: Bytes32,
+//	                          amount: uint64) -> None:
+//	index = get_index_for_new_validator(state)
+//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, 0)
+//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.inactivity_scores, index, uint64(0)) // New in Altair
+func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
+	val := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
+	if err := beaconState.AppendValidator(val); err != nil {
+		return err
+	}
+	if err := beaconState.AppendBalance(amount); err != nil {
+		return err
+	}
+
+	// only active in altair and only when it's a new validator (after append balance)
+	if beaconState.Version() >= version.Altair {
+		if err := beaconState.AppendInactivityScore(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetValidatorFromDeposit gets a new validator object with provided parameters
+//
+// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
+//
+//	effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
+//
+//	return Validator(
+//	    pubkey=pubkey,
+//	    withdrawal_credentials=withdrawal_credentials,
+//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
+//	    activation_epoch=FAR_FUTURE_EPOCH,
+//	    exit_epoch=FAR_FUTURE_EPOCH,
+//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	    effective_balance=effective_balance,
+//	)
+func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
+	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+	}
+
+	return &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           effectiveBalance,
+	}
+}
+
 // ActivateValidatorWithEffectiveBalance updates validator's effective balance, and if it's above MaxEffectiveBalance, validator becomes active in genesis.
 func ActivateValidatorWithEffectiveBalance(beaconState state.BeaconState, deposits []*ethpb.Deposit) (state.BeaconState, error) {
 	for _, d := range deposits {
@@ -63,6 +133,22 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 	return verified, nil
 }
 
+// BatchVerifyPendingDepositsSignatures batch verifies pending deposit signatures.
+func BatchVerifyPendingDepositsSignatures(ctx context.Context, deposits []*ethpb.PendingDeposit) (bool, error) {
+	var err error
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	if err != nil {
+		return false, err
+	}
+
+	verified := false
+	if err := verifyPendingDepositDataWithDomain(ctx, deposits, domain); err != nil {
+		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
+		verified = true
+	}
+	return verified, nil
+}
+
 // IsValidDepositSignature returns whether deposit_data is valid
 // def is_valid_deposit_signature(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> bool:
 //
@@ -159,3 +245,44 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
 	}
 	return nil
 }
+
+func verifyPendingDepositDataWithDomain(ctx context.Context, deps []*ethpb.PendingDeposit, domain []byte) error {
+	if len(deps) == 0 {
+		return nil
+	}
+	pks := make([]bls.PublicKey, len(deps))
+	sigs := make([][]byte, len(deps))
+	msgs := make([][32]byte, len(deps))
+	for i, dep := range deps {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		if dep == nil {
+			return errors.New("nil deposit")
+		}
+		dpk, err := bls.PublicKeyFromBytes(dep.PublicKey)
+		if err != nil {
+			return err
+		}
+		pks[i] = dpk
+		sigs[i] = dep.Signature
+		depositMessage := &ethpb.DepositMessage{
+			PublicKey:             dep.PublicKey,
+			WithdrawalCredentials: dep.WithdrawalCredentials,
+			Amount:                dep.Amount,
+		}
+		sr, err := signing.ComputeSigningRoot(depositMessage, domain)
+		if err != nil {
+			return err
+		}
+		msgs[i] = sr
+	}
+	verify, err := bls.VerifyMultipleSignatures(sigs, msgs, pks)
+	if err != nil {
+		return errors.Errorf("could not verify multiple signatures: %v", err)
+	}
+	if !verify {
+		return errors.New("one or more deposit signatures did not verify")
+	}
+	return nil
+}

beacon-chain/core/electra/BUILD.bazel

@@ -32,6 +32,7 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//contracts/deposit:go_default_library",
+        "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
@@ -65,11 +66,13 @@ go_test(
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
+        "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/core/electra/consolidations.go

@@ -22,25 +22,29 @@ import (
 //
 // Spec definition:
 //
-//	def process_pending_consolidations(state: BeaconState) -> None:
-//	    next_pending_consolidation = 0
-//	    for pending_consolidation in state.pending_consolidations:
-//	        source_validator = state.validators[pending_consolidation.source_index]
-//	        if source_validator.slashed:
-//	            next_pending_consolidation += 1
 //	            continue
-//	        if source_validator.withdrawable_epoch > get_current_epoch(state):
+// def process_pending_consolidations(state: BeaconState) -> None:
-//	            break
 //
-//	        # Churn any target excess active balance of target and raise its max
+//	next_epoch = Epoch(get_current_epoch(state) + 1)
-//	        switch_to_compounding_validator(state, pending_consolidation.target_index)
+//	next_pending_consolidation = 0
-//	        # Move active balance to target. Excess balance is withdrawable.
+//	for pending_consolidation in state.pending_consolidations:
-//	        active_balance = get_active_balance(state, pending_consolidation.source_index)
+//	    source_validator = state.validators[pending_consolidation.source_index]
-//	        decrease_balance(state, pending_consolidation.source_index, active_balance)
+//	    if source_validator.slashed:
-//	        increase_balance(state, pending_consolidation.target_index, active_balance)
 //	        next_pending_consolidation += 1
+//	        continue
+//	    if source_validator.withdrawable_epoch > next_epoch:
+//	        break
 //
-//	    state.pending_consolidations = state.pending_consolidations[next_pending_consolidation:]
+//	    # Calculate the consolidated balance
+//	    max_effective_balance = get_max_effective_balance(source_validator)
+//	    source_effective_balance = min(state.balances[pending_consolidation.source_index], max_effective_balance)
+//
+//	    # Move active balance to target. Excess balance is withdrawable.
+//	    decrease_balance(state, pending_consolidation.source_index, source_effective_balance)
+//	    increase_balance(state, pending_consolidation.target_index, source_effective_balance)
+//	    next_pending_consolidation += 1
+//
+//	state.pending_consolidations = state.pending_consolidations[next_pending_consolidation:]
 func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) error {
 	_, span := trace.StartSpan(ctx, "electra.ProcessPendingConsolidations")
 	defer span.End()
@@ -70,18 +74,19 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			break
 		}
 
-		if err := SwitchToCompoundingValidator(st, pc.TargetIndex); err != nil {
+		sourceEffectiveBalance := helpers.ValidatorMaxEffectiveBalance(sourceValidator)
-			return err
+		validatorBalance, err := st.BalanceAtIndex(pc.SourceIndex)
-		}
-
-		activeBalance, err := st.ActiveBalanceAtIndex(pc.SourceIndex)
 		if err != nil {
 			return err
 		}
-		if err := helpers.DecreaseBalance(st, pc.SourceIndex, activeBalance); err != nil {
+		if sourceEffectiveBalance > validatorBalance {
+			sourceEffectiveBalance = validatorBalance
+		}
+
+		if err := helpers.DecreaseBalance(st, pc.SourceIndex, sourceEffectiveBalance); err != nil {
 			return err
 		}
-		if err := helpers.IncreaseBalance(st, pc.TargetIndex, activeBalance); err != nil {
+		if err := helpers.IncreaseBalance(st, pc.TargetIndex, sourceEffectiveBalance); err != nil {
 			return err
 		}
 		nextPendingConsolidation++
@@ -101,6 +106,16 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    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
@@ -121,10 +136,6 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    source_validator = state.validators[source_index]
 //	    target_validator = state.validators[target_index]
 //
-//	    # Verify that source != target, so a consolidation cannot be used as an exit.
-//	    if source_index == target_index:
-//	        return
-//
 //	    # Verify source withdrawal credentials
 //	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
 //	    is_correct_source_address = (
@@ -160,19 +171,14 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	        source_index=source_index,
 //	        target_index=target_index
 //	    ))
+//
+//	    # Churn any target excess active balance of target and raise its max
+//	    if has_eth1_withdrawal_credential(target_validator):
+//	        switch_to_compounding_validator(state, target_index)
 func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
 	if len(reqs) == 0 || st == nil {
 		return nil
 	}
-
-	activeBal, err := helpers.TotalActiveBalance(st)
-	if err != nil {
-		return err
-	}
-	churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-	if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
-		return nil
-	}
 	curEpoch := slots.ToEpoch(st.Slot())
 	ffe := params.BeaconConfig().FarFutureEpoch
 	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
@@ -182,22 +188,47 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if ctx.Err() != nil {
 			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
 		}
+		canSwitch, err := IsValidSwitchToCompoundingRequest(ctx, st, cr)
+		if err != nil {
+			return fmt.Errorf("failed to validate consolidation request: %w", err)
+		}
+		if canSwitch {
+			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+			if !ok {
+				return errors.New("could not find validator in registry")
+			}
+			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
+				return fmt.Errorf("failed to switch to compounding validator: %w", err)
+			}
+			return nil
+		}
+		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 {
 			return nil
 		}
 
-		srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+		activeBal, err := helpers.TotalActiveBalance(st)
-		if !ok {
+		if err != nil {
-			continue
+			return err
 		}
-		tgtIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.TargetPubkey))
+		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-		if !ok {
+		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
-			continue
+			return nil
 		}
 
-		if srcIdx == tgtIdx {
+		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
+		if !ok {
+			continue
+		}
+		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
+		if !ok {
 			continue
 		}
 
@@ -248,7 +279,94 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		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.
 		}
+
+		if helpers.HasETH1WithdrawalCredential(tgtV) {
+			if err := SwitchToCompoundingValidator(st, tgtIdx); err != nil {
+				return fmt.Errorf("failed to switch to compounding validator: %w", err)
+			}
+		}
 	}
 
 	return nil
 }
+
+// IsValidSwitchToCompoundingRequest returns true if the given consolidation request is valid for switching to compounding.
+//
+// Spec code:
+//
+// def is_valid_switch_to_compounding_request(
+//
+//	state: BeaconState,
+//	consolidation_request: ConsolidationRequest
+//
+// ) -> bool:
+//
+//	# Switch to compounding requires source and target be equal
+//	if consolidation_request.source_pubkey != consolidation_request.target_pubkey:
+//	    return False
+//
+//	# Verify pubkey exists
+//	source_pubkey = consolidation_request.source_pubkey
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//	if source_pubkey not in validator_pubkeys:
+//	    return False
+//
+//	source_validator = state.validators[ValidatorIndex(validator_pubkeys.index(source_pubkey))]
+//
+//	# Verify request has been authorized
+//	if source_validator.withdrawal_credentials[12:] != consolidation_request.source_address:
+//	    return False
+//
+//	# Verify source withdrawal credentials
+//	if not has_eth1_withdrawal_credential(source_validator):
+//	    return False
+//
+//	# Verify the source is active
+//	current_epoch = get_current_epoch(state)
+//	if not is_active_validator(source_validator, current_epoch):
+//	    return False
+//
+//	# Verify exit for source have not been initiated
+//	if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	    return False
+//
+//	return True
+func IsValidSwitchToCompoundingRequest(ctx context.Context, st state.BeaconState, req *enginev1.ConsolidationRequest) (bool, error) {
+	if req.SourcePubkey == nil || req.TargetPubkey == nil {
+		return false, errors.New("nil source or target pubkey")
+	}
+
+	sourcePubKey := bytesutil.ToBytes48(req.SourcePubkey)
+	targetPubKey := bytesutil.ToBytes48(req.TargetPubkey)
+	if sourcePubKey != targetPubKey {
+		return false, nil
+	}
+
+	srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubKey)
+	if !ok {
+		return false, nil
+	}
+	srcV, err := st.ValidatorAtIndex(srcIdx)
+	if err != nil {
+		return false, err
+	}
+	sourceAddress := req.SourceAddress
+	withdrawalCreds := srcV.WithdrawalCredentials
+	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
+		return false, nil
+	}
+
+	if !helpers.HasETH1WithdrawalCredential(srcV) {
+		return false, nil
+	}
+
+	curEpoch := slots.ToEpoch(st.Slot())
+	if !helpers.IsActiveValidator(srcV, curEpoch) {
+		return false, nil
+	}
+
+	if srcV.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+		return false, nil
+	}
+	return true, nil
+}

beacon-chain/core/electra/consolidations_test.go

@@ -13,6 +13,7 @@ import (
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
 func TestProcessPendingConsolidations(t *testing.T) {
@@ -201,38 +202,6 @@ func TestProcessPendingConsolidations(t *testing.T) {
 	}
 }
 
-func stateWithActiveBalanceETH(t *testing.T, balETH uint64) state.BeaconState {
-	gwei := balETH * 1_000_000_000
-	balPerVal := params.BeaconConfig().MinActivationBalance
-	numVals := gwei / balPerVal
-
-	vals := make([]*eth.Validator, numVals)
-	bals := make([]uint64, numVals)
-	for i := uint64(0); i < numVals; i++ {
-		wc := make([]byte, 32)
-		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-		wc[31] = byte(i)
-		vals[i] = &eth.Validator{
-			ActivationEpoch:       0,
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance:      balPerVal,
-			WithdrawalCredentials: wc,
-		}
-		bals[i] = balPerVal
-	}
-	st, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
-		Slot:       10 * params.BeaconConfig().SlotsPerEpoch,
-		Validators: vals,
-		Balances:   bals,
-		Fork: &eth.Fork{
-			CurrentVersion: params.BeaconConfig().ElectraForkVersion,
-		},
-	})
-	require.NoError(t, err)
-
-	return st
-}
-
 func TestProcessConsolidationRequests(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -428,3 +397,96 @@ func TestProcessConsolidationRequests(t *testing.T) {
 		})
 	}
 }
+
+func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
+	ctx := context.Background()
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	t.Run("nil source pubkey", func(t *testing.T) {
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			SourcePubkey: nil,
+			TargetPubkey: []byte{'a'},
+		})
+		require.ErrorContains(t, "nil source or target pubkey", err)
+		require.Equal(t, false, ok)
+	})
+	t.Run("nil target pubkey", func(t *testing.T) {
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			TargetPubkey: nil,
+			SourcePubkey: []byte{'a'},
+		})
+		require.ErrorContains(t, "nil source or target pubkey", err)
+		require.Equal(t, false, ok)
+	})
+	t.Run("different source and target pubkey", func(t *testing.T) {
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			TargetPubkey: []byte{'a'},
+			SourcePubkey: []byte{'b'},
+		})
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+	t.Run("source validator not found in state", func(t *testing.T) {
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			SourceAddress: make([]byte, 20),
+			TargetPubkey:  []byte{'a'},
+			SourcePubkey:  []byte{'a'},
+		})
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+	t.Run("incorrect source address", func(t *testing.T) {
+		v, err := st.ValidatorAtIndex(0)
+		require.NoError(t, err)
+		pubkey := v.PublicKey
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			SourceAddress: make([]byte, 20),
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+	t.Run("incorrect eth1 withdrawal credential", func(t *testing.T) {
+		v, err := st.ValidatorAtIndex(0)
+		require.NoError(t, err)
+		pubkey := v.PublicKey
+		wc := v.WithdrawalCredentials
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			SourceAddress: wc[12:],
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+	t.Run("is valid compounding request", func(t *testing.T) {
+		v, err := st.ValidatorAtIndex(0)
+		require.NoError(t, err)
+		pubkey := v.PublicKey
+		wc := v.WithdrawalCredentials
+		v.WithdrawalCredentials[0] = 1
+		require.NoError(t, st.UpdateValidatorAtIndex(0, v))
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			SourceAddress: wc[12:],
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+	t.Run("already has an exit epoch", func(t *testing.T) {
+		v, err := st.ValidatorAtIndex(0)
+		require.NoError(t, err)
+		pubkey := v.PublicKey
+		wc := v.WithdrawalCredentials
+		v.ExitEpoch = 100
+		require.NoError(t, st.UpdateValidatorAtIndex(0, v))
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
+			SourceAddress: wc[12:],
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+}

beacon-chain/core/electra/deposits.go

@@ -2,7 +2,6 @@ package electra
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
@@ -96,31 +95,41 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 }
 
 // ApplyDeposit
-// def apply_deposit(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> None:
+// def apply_deposit(state: BeaconState,
-// validator_pubkeys = [v.pubkey for v in state.validators]
-// if pubkey not in validator_pubkeys:
 //
-//	# Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	              pubkey: BLSPubkey,
-//	if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
+//	              withdrawal_credentials: Bytes32,
-//	  add_validator_to_registry(state, pubkey, withdrawal_credentials, amount)
+//	              amount: uint64,
-//
+//	              signature: BLSSignature) -> None:
-// else:
+//	validator_pubkeys = [v.pubkey for v in state.validators]
-//
+//	if pubkey not in validator_pubkeys:
-//	# Increase balance by deposit amount
+//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
-//	index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//	    if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
-//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [Modified in Electra:EIP-7251]
+//	        add_validator_to_registry(state, pubkey, withdrawal_credentials, Gwei(0))  # [Modified in Electra:EIP7251]
-//	# Check if valid deposit switch to compounding credentials
+//	        # [New in Electra:EIP7251]
-//
+//	        state.pending_deposits.append(PendingDeposit(
-// if ( is_compounding_withdrawal_credential(withdrawal_credentials) and has_eth1_withdrawal_credential(state.validators[index])
+//	            pubkey=pubkey,
-//
+//	            withdrawal_credentials=withdrawal_credentials,
-//	 and is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature)
+//	            amount=amount,
-//	):
+//	            signature=signature,
-//	 switch_to_compounding_validator(state, index)
+//	            slot=GENESIS_SLOT,
+//	        ))
+//	else:
+//	    # Increase balance by deposit amount
+//	    # [Modified in Electra:EIP7251]
+//	    state.pending_deposits.append(PendingDeposit(
+//	        pubkey=pubkey,
+//	        withdrawal_credentials=withdrawal_credentials,
+//	        amount=amount,
+//	        signature=signature,
+//	        slot=GENESIS_SLOT
+//	    ))
 func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
 	pubKey := data.PublicKey
 	amount := data.Amount
 	withdrawalCredentials := data.WithdrawalCredentials
-	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+	signature := data.Signature
+	_, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
 		if verifySignature {
 			valid, err := IsValidDepositSignature(data)
@@ -131,32 +140,20 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verif
 				return beaconState, nil
 			}
 		}
-		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
+
+		if err := blocks.AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, 0); err != nil { // # [Modified in Electra:EIP7251]
 			return nil, errors.Wrap(err, "could not add validator to registry")
 		}
-	} else {
+	}
-		// no validation on top-ups (phase0 feature). no validation before state change
+	// no validation on top-ups (phase0 feature). no validation before state change
-		if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
-			return nil, err
+		PublicKey:             pubKey,
-		}
+		WithdrawalCredentials: withdrawalCredentials,
-		val, err := beaconState.ValidatorAtIndex(index)
+		Amount:                amount,
-		if err != nil {
+		Signature:             signature,
-			return nil, err
+		Slot:                  params.BeaconConfig().GenesisSlot,
-		}
+	}); err != nil {
-		if helpers.IsCompoundingWithdrawalCredential(withdrawalCredentials) && helpers.HasETH1WithdrawalCredential(val) {
+		return nil, err
-			if verifySignature {
-				valid, err := IsValidDepositSignature(data)
-				if err != nil {
-					return nil, errors.Wrap(err, "could not verify deposit signature")
-				}
-				if !valid {
-					return beaconState, nil
-				}
-			}
-			if err := SwitchToCompoundingValidator(beaconState, index); err != nil {
-				return nil, errors.Wrap(err, "could not switch to compound validator")
-			}
-		}
 	}
 	return beaconState, nil
 }
@@ -185,47 +182,80 @@ func verifyDepositDataSigningRoot(obj *ethpb.Deposit_Data, domain []byte) error
 	return deposit.VerifyDepositSignature(obj, domain)
 }
 
-// ProcessPendingBalanceDeposits implements the spec definition below. This method mutates the state.
+// ProcessPendingDeposits implements the spec definition below. This method mutates the state.
+// Iterating over `pending_deposits` queue this function runs the following checks before applying pending deposit:
+// 1. All Eth1 bridge deposits are processed before the first deposit request gets processed.
+// 2. Deposit position in the queue is finalized.
+// 3. Deposit does not exceed the `MAX_PENDING_DEPOSITS_PER_EPOCH` limit.
+// 4. Deposit does not exceed the activation churn limit.
 //
 // Spec definition:
 //
-//	def process_pending_balance_deposits(state: BeaconState) -> None:
+//		def process_pending_deposits(state: BeaconState) -> None:
-//	    available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
+//	   available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
-//	    processed_amount = 0
+//	   processed_amount = 0
-//	    next_deposit_index = 0
+//	   next_deposit_index = 0
-//	    deposits_to_postpone = []
+//	   deposits_to_postpone = []
+//	   is_churn_limit_reached = False
+//	   finalized_slot = compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)
 //
-//	    for deposit in state.pending_balance_deposits:
+//	   for deposit in state.pending_deposits:
-//	        validator = state.validators[deposit.index]
+//	       # Do not process deposit requests if Eth1 bridge deposits are not yet applied.
-//	        # Validator is exiting, postpone the deposit until after withdrawable epoch
+//	       if (
-//	        if validator.exit_epoch < FAR_FUTURE_EPOCH:
+//	           # Is deposit request
-//	            if get_current_epoch(state) <= validator.withdrawable_epoch:
+//	           deposit.slot > GENESIS_SLOT and
-//	                deposits_to_postpone.append(deposit)
+//	           # There are pending Eth1 bridge deposits
-//	            # Deposited balance will never become active. Increase balance but do not consume churn
+//	           state.eth1_deposit_index < state.deposit_requests_start_index
-//	            else:
+//	       ):
-//	                increase_balance(state, deposit.index, deposit.amount)
+//	           break
-//	        # Validator is not exiting, attempt to process deposit
-//	        else:
-//	            # Deposit does not fit in the churn, no more deposit processing in this epoch.
-//	            if processed_amount + deposit.amount > available_for_processing:
-//	                break
-//	            # Deposit fits in the churn, process it. Increase balance and consume churn.
-//	            else:
-//	                increase_balance(state, deposit.index, deposit.amount)
-//	                processed_amount += deposit.amount
-//	        # Regardless of how the deposit was handled, we move on in the queue.
-//	        next_deposit_index += 1
 //
-//	    state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:]
+//	       # Check if deposit has been finalized, otherwise, stop processing.
+//	       if deposit.slot > finalized_slot:
+//	           break
 //
-//	    if len(state.pending_balance_deposits) == 0:
+//	       # Check if number of processed deposits has not reached the limit, otherwise, stop processing.
-//	        state.deposit_balance_to_consume = Gwei(0)
+//	       if next_deposit_index >= MAX_PENDING_DEPOSITS_PER_EPOCH:
-//	    else:
+//	           break
-//	        state.deposit_balance_to_consume = available_for_processing - processed_amount
 //
-//	    state.pending_balance_deposits += deposits_to_postpone
+//	       # Read validator state
-func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, activeBalance primitives.Gwei) error {
+//	       is_validator_exited = False
-	_, span := trace.StartSpan(ctx, "electra.ProcessPendingBalanceDeposits")
+//	       is_validator_withdrawn = False
+//	       validator_pubkeys = [v.pubkey for v in state.validators]
+//	       if deposit.pubkey in validator_pubkeys:
+//	           validator = state.validators[ValidatorIndex(validator_pubkeys.index(deposit.pubkey))]
+//	           is_validator_exited = validator.exit_epoch < FAR_FUTURE_EPOCH
+//	           is_validator_withdrawn = validator.withdrawable_epoch < get_current_epoch(state)
+//
+//	       if is_validator_withdrawn:
+//	           # Deposited balance will never become active. Increase balance but do not consume churn
+//	           apply_pending_deposit(state, deposit)
+//	       elif is_validator_exited:
+//	           # Validator is exiting, postpone the deposit until after withdrawable epoch
+//	           deposits_to_postpone.append(deposit)
+//	       else:
+//	           # Check if deposit fits in the churn, otherwise, do no more deposit processing in this epoch.
+//	           is_churn_limit_reached = processed_amount + deposit.amount > available_for_processing
+//	           if is_churn_limit_reached:
+//	               break
+//
+//	           # Consume churn and apply deposit.
+//	           processed_amount += deposit.amount
+//	           apply_pending_deposit(state, deposit)
+//
+//	       # Regardless of how the deposit was handled, we move on in the queue.
+//	       next_deposit_index += 1
+//
+//	   state.pending_deposits = state.pending_deposits[next_deposit_index:]
+//
+//	   # Accumulate churn only if the churn limit has been hit.
+//	   if is_churn_limit_reached:
+//	       state.deposit_balance_to_consume = available_for_processing - processed_amount
+//	   else:
+//	       state.deposit_balance_to_consume = Gwei(0)
+//
+//	   state.pending_deposits += deposits_to_postpone
+func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBalance primitives.Gwei) error {
+	_, span := trace.StartSpan(ctx, "electra.ProcessPendingDeposits")
 	defer span.End()
 
 	if st == nil || st.IsNil() {
@@ -238,99 +268,180 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 	}
 	availableForProcessing := depBalToConsume + helpers.ActivationExitChurnLimit(activeBalance)
 	processedAmount := uint64(0)
-	nextDepositIndex := 0
+	nextDepositIndex := uint64(0)
-	var depositsToPostpone []*eth.PendingBalanceDeposit
+	var depositsToPostpone []*eth.PendingDeposit
 
-	deposits, err := st.PendingBalanceDeposits()
+	deposits, err := st.PendingDeposits()
 	if err != nil {
 		return err
 	}
-
+	isChurnLimitReached := false
+	finalizedSlot, err := slots.EpochStart(st.FinalizedCheckpoint().Epoch)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized slot")
+	}
 	// constants
 	ffe := params.BeaconConfig().FarFutureEpoch
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
+	curEpoch := slots.ToEpoch(st.Slot())
 
-	for _, balanceDeposit := range deposits {
+	// Slice to collect deposits needing signature verification
-		v, err := st.ValidatorAtIndexReadOnly(balanceDeposit.Index)
+	var depositsToVerify []*ethpb.PendingDeposit
+	for _, pendingDeposit := range deposits {
+		startIndex, err := st.DepositRequestsStartIndex()
 		if err != nil {
-			return fmt.Errorf("failed to fetch validator at index: %w", err)
+			return errors.Wrap(err, "could not get starting pendingDeposit index")
 		}
 
-		// If the validator is currently exiting, postpone the deposit until after the withdrawable
+		// Do not process pendingDeposit requests if Eth1 bridge deposits are not yet applied.
-		// epoch.
+		if pendingDeposit.Slot > params.BeaconConfig().GenesisSlot && st.Eth1DepositIndex() < startIndex {
-		if v.ExitEpoch() < ffe {
+			break
-			if nextEpoch <= v.WithdrawableEpoch() {
+		}
-				depositsToPostpone = append(depositsToPostpone, balanceDeposit)
+
-			} else {
+		// Check if pendingDeposit has been finalized, otherwise, stop processing.
-				// The deposited balance will never become active. Therefore, we increase the balance but do
+		if pendingDeposit.Slot > finalizedSlot {
-				// not consume the churn.
+			break
-				if err := helpers.IncreaseBalance(st, balanceDeposit.Index, balanceDeposit.Amount); err != nil {
+		}
-					return err
+
-				}
+		// Check if number of processed deposits has not reached the limit, otherwise, stop processing.
+		if nextDepositIndex >= params.BeaconConfig().MaxPendingDepositsPerEpoch {
+			break
+		}
+
+		var isValidatorExited bool
+		var isValidatorWithdrawn bool
+		index, found := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(pendingDeposit.PublicKey))
+		if found {
+			val, err := st.ValidatorAtIndexReadOnly(index)
+			if err != nil {
+				return errors.Wrap(err, "could not get validator")
 			}
+			isValidatorExited = val.ExitEpoch() < ffe
+			isValidatorWithdrawn = val.WithdrawableEpoch() < curEpoch
+		}
+
+		if isValidatorWithdrawn {
+			// Deposited balance will never become active. Increase balance but do not consume churn
+			if err := ApplyPendingDeposit(ctx, st, pendingDeposit, true); err != nil {
+				return errors.Wrap(err, "could not apply pending deposit")
+			}
+		} else if isValidatorExited {
+			// Validator is exiting, postpone the pendingDeposit until after withdrawable epoch
+			depositsToPostpone = append(depositsToPostpone, pendingDeposit)
 		} else {
-			// Validator is not exiting, attempt to process deposit.
+			// Check if pendingDeposit fits in the churn, otherwise, do no more pendingDeposit processing in this epoch.
-			if primitives.Gwei(processedAmount+balanceDeposit.Amount) > availableForProcessing {
+			isChurnLimitReached = primitives.Gwei(processedAmount+pendingDeposit.Amount) > availableForProcessing
+			if isChurnLimitReached { // Is churn limit reached?
 				break
 			}
-			// Deposit fits in churn, process it. Increase balance and consume churn.
+			// Consume churn and apply pendingDeposit.
-			if err := helpers.IncreaseBalance(st, balanceDeposit.Index, balanceDeposit.Amount); err != nil {
+			processedAmount += pendingDeposit.Amount
-				return err
+			if found {
+				if err := ApplyPendingDeposit(ctx, st, pendingDeposit, true); err != nil {
+					return errors.Wrap(err, "could not apply pending deposit")
+				}
+			} else {
+				// Collect deposit for batch signature verification
+				depositsToVerify = append(depositsToVerify, pendingDeposit)
 			}
-			processedAmount += balanceDeposit.Amount
 		}
 
-		// Regardless of how the deposit was handled, we move on in the queue.
+		// Regardless of how the pendingDeposit was handled, we move on in the queue.
 		nextDepositIndex++
 	}
 
-	// Combined operation:
+	// Perform batch signature verification on deposits on unfound validators
-	// - state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:]
+	if len(depositsToVerify) > 0 {
-	// - state.pending_balance_deposits += deposits_to_postpone
+		batchVerified, err := blocks.BatchVerifyPendingDepositsSignatures(ctx, depositsToVerify)
-	// However, the number of remaining deposits must be maintained to properly update the deposit
+		if err != nil {
-	// balance to consume.
+			return errors.Wrap(err, "could not batch verify deposit signatures")
-	numRemainingDeposits := len(deposits[nextDepositIndex:])
+		}
-	deposits = append(deposits[nextDepositIndex:], depositsToPostpone...)
+
-	if err := st.SetPendingBalanceDeposits(deposits); err != nil {
+		// Apply deposits that passed verification
-		return err
+		for _, dep := range depositsToVerify {
+			if err := ApplyPendingDeposit(ctx, st, dep, batchVerified); err != nil {
+				return errors.Wrap(err, "could not apply pending deposit")
+			}
+		}
 	}
 
-	if numRemainingDeposits == 0 {
+	// Combined operation:
-		return st.SetDepositBalanceToConsume(0)
+	// - state.pending_deposits = state.pending_deposits[next_deposit_index:]
-	} else {
+	// - state.pending_deposits += deposits_to_postpone
+	// However, the number of remaining deposits must be maintained to properly update the pendingDeposit
+	// balance to consume.
+	deposits = append(deposits[nextDepositIndex:], depositsToPostpone...)
+	if err := st.SetPendingDeposits(deposits); err != nil {
+		return errors.Wrap(err, "could not set pending deposits")
+	}
+	// Accumulate churn only if the churn limit has been hit.
+	if isChurnLimitReached {
 		return st.SetDepositBalanceToConsume(availableForProcessing - primitives.Gwei(processedAmount))
 	}
+	return st.SetDepositBalanceToConsume(0)
+}
+
+// ApplyPendingDeposit implements the spec definition below.
+//
+// Spec Definition:
+//
+// def apply_pending_deposit(state: BeaconState, deposit: PendingDeposit) -> None:
+//
+//	"""
+//	Applies ``deposit`` to the ``state``.
+//	"""
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//	if deposit.pubkey not in validator_pubkeys:
+//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	    if is_valid_deposit_signature(
+//	        deposit.pubkey,
+//	        deposit.withdrawal_credentials,
+//	        deposit.amount,
+//	        deposit.signature
+//	    ):
+//	        add_validator_to_registry(state, deposit.pubkey, deposit.withdrawal_credentials, deposit.amount)
+//	else:
+//	    validator_index = ValidatorIndex(validator_pubkeys.index(deposit.pubkey))
+//	    # Increase balance
+//	    increase_balance(state, validator_index, deposit.amount)
+func ApplyPendingDeposit(ctx context.Context, st state.BeaconState, deposit *ethpb.PendingDeposit, isSigVerified bool) error {
+	_, span := trace.StartSpan(ctx, "electra.ApplyPendingDeposit")
+	defer span.End()
+	index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(deposit.PublicKey))
+	if !ok {
+		var err error
+		if !isSigVerified {
+			isSigVerified, err = blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
+				PublicKey:             bytesutil.SafeCopyBytes(deposit.PublicKey),
+				WithdrawalCredentials: bytesutil.SafeCopyBytes(deposit.WithdrawalCredentials),
+				Amount:                deposit.Amount,
+				Signature:             bytesutil.SafeCopyBytes(deposit.Signature),
+			})
+			if err != nil {
+				return errors.Wrap(err, "could not verify deposit signature")
+			}
+		}
+		if isSigVerified {
+			if err := blocks.AddValidatorToRegistry(st, deposit.PublicKey, deposit.WithdrawalCredentials, deposit.Amount); err != nil {
+				return errors.Wrap(err, "could not add validator to registry")
+			}
+		}
+		return nil
+	}
+	return helpers.IncreaseBalance(st, index, deposit.Amount)
 }
 
 // ProcessDepositRequests is a function as part of electra to process execution layer deposits
 func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
 	defer span.End()
 
 	if len(requests) == 0 {
 		return beaconState, nil
 	}
 
-	deposits := make([]*ethpb.Deposit, 0)
+	var err error
-	for _, req := range requests {
-		if req == nil {
-			return nil, errors.New("got a nil DepositRequest")
-		}
-		deposits = append(deposits, &ethpb.Deposit{
-			Data: &ethpb.Deposit_Data{
-				PublicKey:             req.Pubkey,
-				WithdrawalCredentials: req.WithdrawalCredentials,
-				Amount:                req.Amount,
-				Signature:             req.Signature,
-			},
-		})
-	}
-	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
-	}
 	for _, receipt := range requests {
-		beaconState, err = processDepositRequest(beaconState, receipt, batchVerified)
+		beaconState, err = processDepositRequest(beaconState, receipt)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not apply deposit request")
 		}
@@ -341,31 +452,38 @@ func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState,
 // processDepositRequest processes the specific deposit receipt
 // def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
 //
-//	# Set deposit request start index
+//		# Set deposit request start index
-//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUEST_START_INDEX:
+//		if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUEST_START_INDEX:
-//	    state.deposit_requests_start_index = deposit_request.index
+//		    state.deposit_requests_start_index = deposit_request.index
 //
-//	apply_deposit(
+//		state.pending_deposits.append(PendingDeposit(
-//	    state=state,
+//	       pubkey=deposit_request.pubkey,
-//	    pubkey=deposit_request.pubkey,
+//	       withdrawal_credentials=deposit_request.withdrawal_credentials,
-//	    withdrawal_credentials=deposit_request.withdrawal_credentials,
+//	       amount=deposit_request.amount,
-//	    amount=deposit_request.amount,
+//	       signature=deposit_request.signature,
-//	    signature=deposit_request.signature,
+//	       slot=state.slot,
-//	)
+//	   ))
-func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest, verifySignature bool) (state.BeaconState, error) {
+func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) (state.BeaconState, error) {
 	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get deposit requests start index")
 	}
 	if requestsStartIndex == params.BeaconConfig().UnsetDepositRequestsStartIndex {
+		if request == nil {
+			return nil, errors.New("nil deposit request")
+		}
 		if err := beaconState.SetDepositRequestsStartIndex(request.Index); err != nil {
 			return nil, errors.Wrap(err, "could not set deposit requests start index")
 		}
 	}
-	return ApplyDeposit(beaconState, &ethpb.Deposit_Data{
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
 		PublicKey:             bytesutil.SafeCopyBytes(request.Pubkey),
 		Amount:                request.Amount,
 		WithdrawalCredentials: bytesutil.SafeCopyBytes(request.WithdrawalCredentials),
 		Signature:             bytesutil.SafeCopyBytes(request.Signature),
-	}, verifySignature)
+		Slot:                  beaconState.Slot(),
+	}); err != nil {
+		return nil, errors.Wrap(err, "could not append deposit request")
+	}
+	return beaconState, nil
 }

beacon-chain/core/electra/deposits_test.go

@@ -9,10 +9,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	stateTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -20,7 +22,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestProcessPendingBalanceDeposits(t *testing.T) {
+func TestProcessPendingDeposits(t *testing.T) {
 	tests := []struct {
 		name    string
 		state   state.BeaconState
@@ -48,17 +50,10 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 		{
 			name: "more deposits than balance to consume processes partial deposits",
 			state: func() state.BeaconState {
-				st := stateWithActiveBalanceETH(t, 1_000)
-				require.NoError(t, st.SetDepositBalanceToConsume(100))
 				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-				deps := make([]*eth.PendingBalanceDeposit, 20)
+				depositAmount := uint64(amountAvailForProcessing) / 10
-				for i := 0; i < len(deps); i += 1 {
+				st := stateWithPendingDeposits(t, 1_000, 20, depositAmount)
-					deps[i] = &eth.PendingBalanceDeposit{
+				require.NoError(t, st.SetDepositBalanceToConsume(100))
-						Amount: uint64(amountAvailForProcessing) / 10,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
 				return st
 			}(),
 			check: func(t *testing.T, st state.BeaconState) {
@@ -74,7 +69,7 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 				}
 
 				// Half of the balance deposits should have been processed.
-				remaining, err := st.PendingBalanceDeposits()
+				remaining, err := st.PendingDeposits()
 				require.NoError(t, err)
 				require.Equal(t, 10, len(remaining))
 			},
@@ -82,17 +77,10 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 		{
 			name: "less deposits than balance to consume processes all deposits",
 			state: func() state.BeaconState {
-				st := stateWithActiveBalanceETH(t, 1_000)
-				require.NoError(t, st.SetDepositBalanceToConsume(0))
 				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-				deps := make([]*eth.PendingBalanceDeposit, 5)
+				depositAmount := uint64(amountAvailForProcessing) / 5
-				for i := 0; i < len(deps); i += 1 {
+				st := stateWithPendingDeposits(t, 1_000, 5, depositAmount)
-					deps[i] = &eth.PendingBalanceDeposit{
+				require.NoError(t, st.SetDepositBalanceToConsume(0))
-						Amount: uint64(amountAvailForProcessing) / 5,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
 				return st
 			}(),
 			check: func(t *testing.T, st state.BeaconState) {
@@ -108,7 +96,74 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 				}
 
 				// All of the balance deposits should have been processed.
-				remaining, err := st.PendingBalanceDeposits()
+				remaining, err := st.PendingDeposits()
+				require.NoError(t, err)
+				require.Equal(t, 0, len(remaining))
+			},
+		},
+		{
+			name: "process pending deposit for unknown key, activates new key",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 0)
+				sk, err := bls.RandKey()
+				require.NoError(t, err)
+				wc := make([]byte, 32)
+				wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+				wc[31] = byte(0)
+				dep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
+				require.NoError(t, st.SetPendingDeposits([]*eth.PendingDeposit{dep}))
+				require.Equal(t, 0, len(st.Validators()))
+				require.Equal(t, 0, len(st.Balances()))
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				res, err := st.DepositBalanceToConsume()
+				require.NoError(t, err)
+				require.Equal(t, primitives.Gwei(0), res)
+				b, err := st.BalanceAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, b)
+
+				// All of the balance deposits should have been processed.
+				remaining, err := st.PendingDeposits()
+				require.NoError(t, err)
+				require.Equal(t, 0, len(remaining))
+
+				// validator becomes active
+				require.Equal(t, 1, len(st.Validators()))
+				require.Equal(t, 1, len(st.Balances()))
+			},
+		},
+		{
+			name: "process excess balance that uses a point to infinity signature, processed as a topup",
+			state: func() state.BeaconState {
+				excessBalance := uint64(100)
+				st := stateWithActiveBalanceETH(t, 32)
+				validators := st.Validators()
+				sk, err := bls.RandKey()
+				require.NoError(t, err)
+				wc := make([]byte, 32)
+				wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+				wc[31] = byte(0)
+				validators[0].PublicKey = sk.PublicKey().Marshal()
+				validators[0].WithdrawalCredentials = wc
+				dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
+				dep.Signature = common.InfiniteSignature[:]
+				require.NoError(t, st.SetValidators(validators))
+				st.SaveValidatorIndices()
+				require.NoError(t, st.SetPendingDeposits([]*eth.PendingDeposit{dep}))
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				res, err := st.DepositBalanceToConsume()
+				require.NoError(t, err)
+				require.Equal(t, primitives.Gwei(0), res)
+				b, err := st.BalanceAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(100), b)
+
+				// All of the balance deposits should have been processed.
+				remaining, err := st.PendingDeposits()
 				require.NoError(t, err)
 				require.Equal(t, 0, len(remaining))
 			},
@@ -116,17 +171,10 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 		{
 			name: "exiting validator deposit postponed",
 			state: func() state.BeaconState {
-				st := stateWithActiveBalanceETH(t, 1_000)
-				require.NoError(t, st.SetDepositBalanceToConsume(0))
 				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-				deps := make([]*eth.PendingBalanceDeposit, 5)
+				depositAmount := uint64(amountAvailForProcessing) / 5
-				for i := 0; i < len(deps); i += 1 {
+				st := stateWithPendingDeposits(t, 1_000, 5, depositAmount)
-					deps[i] = &eth.PendingBalanceDeposit{
+				require.NoError(t, st.SetDepositBalanceToConsume(0))
-						Amount: uint64(amountAvailForProcessing) / 5,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
 				v, err := st.ValidatorAtIndex(0)
 				require.NoError(t, err)
 				v.ExitEpoch = 10
@@ -148,7 +196,7 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 
 				// All of the balance deposits should have been processed, except validator index 0 was
 				// added back to the pending deposits queue.
-				remaining, err := st.PendingBalanceDeposits()
+				remaining, err := st.PendingDeposits()
 				require.NoError(t, err)
 				require.Equal(t, 1, len(remaining))
 			},
@@ -156,15 +204,7 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 		{
 			name: "exited validator balance increased",
 			state: func() state.BeaconState {
-				st := stateWithActiveBalanceETH(t, 1_000)
+				st := stateWithPendingDeposits(t, 1_000, 1, 1_000_000)
-				deps := make([]*eth.PendingBalanceDeposit, 1)
-				for i := 0; i < len(deps); i += 1 {
-					deps[i] = &eth.PendingBalanceDeposit{
-						Amount: 1_000_000,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
 				v, err := st.ValidatorAtIndex(0)
 				require.NoError(t, err)
 				v.ExitEpoch = 2
@@ -182,7 +222,7 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 				require.Equal(t, uint64(1_100_000), b)
 
 				// All of the balance deposits should have been processed.
-				remaining, err := st.PendingBalanceDeposits()
+				remaining, err := st.PendingDeposits()
 				require.NoError(t, err)
 				require.Equal(t, 0, len(remaining))
 			},
@@ -199,7 +239,7 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 				tab, err = helpers.TotalActiveBalance(tt.state)
 			}
 			require.NoError(t, err)
-			err = electra.ProcessPendingBalanceDeposits(context.TODO(), tt.state, primitives.Gwei(tab))
+			err = electra.ProcessPendingDeposits(context.TODO(), tt.state, primitives.Gwei(tab))
 			require.Equal(t, tt.wantErr, err != nil, "wantErr=%v, got err=%s", tt.wantErr, err)
 			if tt.check != nil {
 				tt.check(t, tt.state)
@@ -220,7 +260,7 @@ func TestProcessDepositRequests(t *testing.T) {
 	})
 	t.Run("nil request errors", func(t *testing.T) {
 		_, err = electra.ProcessDepositRequests(context.Background(), st, []*enginev1.DepositRequest{nil})
-		require.ErrorContains(t, "got a nil DepositRequest", err)
+		require.ErrorContains(t, "nil deposit request", err)
 	})
 
 	vals := st.Validators()
@@ -230,7 +270,7 @@ func TestProcessDepositRequests(t *testing.T) {
 	bals := st.Balances()
 	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
 	require.NoError(t, st.SetBalances(bals))
-	require.NoError(t, st.SetPendingBalanceDeposits(make([]*eth.PendingBalanceDeposit, 0))) // reset pbd as the determinitstic state populates this already
+	require.NoError(t, st.SetPendingDeposits(make([]*eth.PendingDeposit, 0))) // reset pbd as the determinitstic state populates this already
 	withdrawalCred := make([]byte, 32)
 	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
 	depositMessage := &eth.DepositMessage{
@@ -255,11 +295,10 @@ func TestProcessDepositRequests(t *testing.T) {
 	st, err = electra.ProcessDepositRequests(context.Background(), st, requests)
 	require.NoError(t, err)
 
-	pbd, err := st.PendingBalanceDeposits()
+	pbd, err := st.PendingDeposits()
 	require.NoError(t, err)
-	require.Equal(t, 2, len(pbd))
+	require.Equal(t, 1, len(pbd))
 	require.Equal(t, uint64(1000), pbd[0].Amount)
-	require.Equal(t, uint64(2000), pbd[1].Amount)
 }
 
 func TestProcessDeposit_Electra_Simple(t *testing.T) {
@@ -286,7 +325,7 @@ func TestProcessDeposit_Electra_Simple(t *testing.T) {
 	require.NoError(t, err)
 	pdSt, err := electra.ProcessDeposits(context.Background(), st, deps)
 	require.NoError(t, err)
-	pbd, err := pdSt.PendingBalanceDeposits()
+	pbd, err := pdSt.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, params.BeaconConfig().MinActivationBalance, pbd[2].Amount)
 	require.Equal(t, 3, len(pbd))
@@ -361,40 +400,128 @@ func TestApplyDeposit_TopUps_WithBadSignature(t *testing.T) {
 	require.NoError(t, st.SetValidators(vals))
 	adSt, err := electra.ApplyDeposit(st, depositData, true)
 	require.NoError(t, err)
-	pbd, err := adSt.PendingBalanceDeposits()
+	pbd, err := adSt.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 1, len(pbd))
 	require.Equal(t, topUpAmount, pbd[0].Amount)
 }
 
-func TestApplyDeposit_Electra_SwitchToCompoundingValidator(t *testing.T) {
+// stateWithActiveBalanceETH generates a mock beacon state given a balance in eth
-	st, _ := util.DeterministicGenesisStateElectra(t, 3)
+func stateWithActiveBalanceETH(t *testing.T, balETH uint64) state.BeaconState {
+	gwei := balETH * 1_000_000_000
+	balPerVal := params.BeaconConfig().MinActivationBalance
+	numVals := gwei / balPerVal
+
+	vals := make([]*eth.Validator, numVals)
+	bals := make([]uint64, numVals)
+	for i := uint64(0); i < numVals; i++ {
+		wc := make([]byte, 32)
+		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		wc[31] = byte(i)
+		vals[i] = &eth.Validator{
+			ActivationEpoch:       0,
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance:      balPerVal,
+			WithdrawalCredentials: wc,
+			WithdrawableEpoch:     params.BeaconConfig().FarFutureEpoch,
+		}
+		bals[i] = balPerVal
+	}
+	st, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+		Slot:       10 * params.BeaconConfig().SlotsPerEpoch,
+		Validators: vals,
+		Balances:   bals,
+		Fork: &eth.Fork{
+			CurrentVersion: params.BeaconConfig().ElectraForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	// set some fake finalized checkpoint
+	require.NoError(t, st.SetFinalizedCheckpoint(&eth.Checkpoint{
+		Epoch: 0,
+		Root:  make([]byte, 32),
+	}))
+	return st
+}
+
+// stateWithPendingDeposits with pending deposits and existing ethbalance
+func stateWithPendingDeposits(t *testing.T, balETH uint64, numDeposits, amount uint64) state.BeaconState {
+	st := stateWithActiveBalanceETH(t, balETH)
+	deps := make([]*eth.PendingDeposit, numDeposits)
+	validators := st.Validators()
+	for i := 0; i < len(deps); i += 1 {
+		sk, err := bls.RandKey()
+		require.NoError(t, err)
+		wc := make([]byte, 32)
+		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		wc[31] = byte(i)
+		validators[i].PublicKey = sk.PublicKey().Marshal()
+		validators[i].WithdrawalCredentials = wc
+		deps[i] = stateTesting.GeneratePendingDeposit(t, sk, amount, bytesutil.ToBytes32(wc), 0)
+	}
+	require.NoError(t, st.SetValidators(validators))
+	st.SaveValidatorIndices()
+	require.NoError(t, st.SetPendingDeposits(deps))
+	return st
+}
+
+func TestApplyPendingDeposit_TopUp(t *testing.T) {
+	excessBalance := uint64(100)
+	st := stateWithActiveBalanceETH(t, 32)
+	validators := st.Validators()
 	sk, err := bls.RandKey()
 	require.NoError(t, err)
-	withdrawalCred := make([]byte, 32)
+	wc := make([]byte, 32)
-	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-	depositData := &eth.Deposit_Data{
+	wc[31] = byte(0)
-		PublicKey:             sk.PublicKey().Marshal(),
+	validators[0].PublicKey = sk.PublicKey().Marshal()
-		Amount:                1000,
+	validators[0].WithdrawalCredentials = wc
-		WithdrawalCredentials: withdrawalCred,
+	dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
-		Signature:             make([]byte, fieldparams.BLSSignatureLength),
+	dep.Signature = common.InfiniteSignature[:]
-	}
+	require.NoError(t, st.SetValidators(validators))
-	vals := st.Validators()
+	st.SaveValidatorIndices()
-	vals[0].PublicKey = sk.PublicKey().Marshal()
+
-	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep, false))
-	require.NoError(t, st.SetValidators(vals))
+
-	bals := st.Balances()
+	b, err := st.BalanceAtIndex(0)
-	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
-	require.NoError(t, st.SetBalances(bals))
-	sr, err := signing.ComputeSigningRoot(depositData, bytesutil.ToBytes(3, 32))
 	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
+	require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(excessBalance), b)
-	depositData.Signature = sig.Marshal()
+}
-	adSt, err := electra.ApplyDeposit(st, depositData, false)
+
-	require.NoError(t, err)
+func TestApplyPendingDeposit_UnknownKey(t *testing.T) {
-	pbd, err := adSt.PendingBalanceDeposits()
+	st := stateWithActiveBalanceETH(t, 0)
-	require.NoError(t, err)
+	sk, err := bls.RandKey()
-	require.Equal(t, 2, len(pbd))
+	require.NoError(t, err)
-	require.Equal(t, uint64(1000), pbd[0].Amount)
+	wc := make([]byte, 32)
-	require.Equal(t, uint64(2000), pbd[1].Amount)
+	wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	wc[31] = byte(0)
+	dep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
+	require.Equal(t, 0, len(st.Validators()))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep, false))
+	// activates new validator
+	require.Equal(t, 1, len(st.Validators()))
+	b, err := st.BalanceAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, b)
+}
+
+func TestApplyPendingDeposit_InvalidSignature(t *testing.T) {
+	st := stateWithActiveBalanceETH(t, 0)
+
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	wc := make([]byte, 32)
+	wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	wc[31] = byte(0)
+	dep := &eth.PendingDeposit{
+		PublicKey:             sk.PublicKey().Marshal(),
+		WithdrawalCredentials: wc,
+		Amount:                100,
+	}
+	require.Equal(t, 0, len(st.Validators()))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep, false))
+	// no validator added
+	require.Equal(t, 0, len(st.Validators()))
+	// no topup either
+	require.Equal(t, 0, len(st.Balances()))
 }

beacon-chain/core/electra/transition.go

@@ -44,7 +44,7 @@ var (
 //	    process_registry_updates(state)
 //	    process_slashings(state)
 //	    process_eth1_data_reset(state)
-//	    process_pending_balance_deposits(state)  # New in EIP7251
+//	    process_pending_deposits(state)  # New in EIP7251
 //	    process_pending_consolidations(state)  # New in EIP7251
 //	    process_effective_balance_updates(state)
 //	    process_slashings_reset(state)
@@ -94,7 +94,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 		return err
 	}
 
-	if err = ProcessPendingBalanceDeposits(ctx, state, primitives.Gwei(bp.ActiveCurrentEpoch)); err != nil {
+	if err = ProcessPendingDeposits(ctx, state, primitives.Gwei(bp.ActiveCurrentEpoch)); err != nil {
 		return err
 	}
 	if err = ProcessPendingConsolidations(ctx, state); err != nil {

beacon-chain/core/electra/transition_test.go

@@ -57,14 +57,17 @@ func TestProcessEpoch_CanProcessElectra(t *testing.T) {
 	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, st.SetDepositBalanceToConsume(100))
 	amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-	deps := make([]*ethpb.PendingBalanceDeposit, 20)
+	validators := st.Validators()
+	deps := make([]*ethpb.PendingDeposit, 20)
 	for i := 0; i < len(deps); i += 1 {
-		deps[i] = &ethpb.PendingBalanceDeposit{
+		deps[i] = &ethpb.PendingDeposit{
-			Amount: uint64(amountAvailForProcessing) / 10,
+			PublicKey:             validators[i].PublicKey,
-			Index:  primitives.ValidatorIndex(i),
+			WithdrawalCredentials: validators[i].WithdrawalCredentials,
+			Amount:                uint64(amountAvailForProcessing) / 10,
+			Slot:                  0,
 		}
 	}
-	require.NoError(t, st.SetPendingBalanceDeposits(deps))
+	require.NoError(t, st.SetPendingDeposits(deps))
 	require.NoError(t, st.SetPendingConsolidations([]*ethpb.PendingConsolidation{
 		{
 			SourceIndex: 2,
@@ -108,7 +111,7 @@ func TestProcessEpoch_CanProcessElectra(t *testing.T) {
 	require.Equal(t, primitives.Gwei(100), res)
 
 	// Half of the balance deposits should have been processed.
-	remaining, err := st.PendingBalanceDeposits()
+	remaining, err := st.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 10, len(remaining))
 

beacon-chain/core/electra/upgrade.go

@@ -101,7 +101,7 @@ import (
 //	    earliest_exit_epoch=earliest_exit_epoch,
 //	    consolidation_balance_to_consume=0,
 //	    earliest_consolidation_epoch=compute_activation_exit_epoch(get_current_epoch(pre)),
-//	    pending_balance_deposits=[],
+//	    pending_deposits=[],
 //	    pending_partial_withdrawals=[],
 //	    pending_consolidations=[],
 //	)
@@ -272,7 +272,7 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 		EarliestExitEpoch:             earliestExitEpoch,
 		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(primitives.Gwei(tab)),
 		EarliestConsolidationEpoch:    helpers.ActivationExitEpoch(slots.ToEpoch(beaconState.Slot())),
-		PendingBalanceDeposits:        make([]*ethpb.PendingBalanceDeposit, 0),
+		PendingDeposits:               make([]*ethpb.PendingDeposit, 0),
 		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
 		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
 	}

beacon-chain/core/electra/upgrade_test.go

@@ -169,10 +169,10 @@ func TestUpgradeToElectra(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, helpers.ActivationExitEpoch(slots.ToEpoch(preForkState.Slot())), earliestConsolidationEpoch)
 
-	pendingBalanceDeposits, err := mSt.PendingBalanceDeposits()
+	pendingDeposits, err := mSt.PendingDeposits()
 	require.NoError(t, err)
-	require.Equal(t, 2, len(pendingBalanceDeposits))
+	require.Equal(t, 2, len(pendingDeposits))
-	require.Equal(t, uint64(1000), pendingBalanceDeposits[1].Amount)
+	require.Equal(t, uint64(1000), pendingDeposits[1].Amount)
 
 	numPendingPartialWithdrawals, err := mSt.NumPendingPartialWithdrawals()
 	require.NoError(t, err)

beacon-chain/core/electra/validator.go

@@ -3,87 +3,21 @@ package electra
 import (
 	"errors"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"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"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
-// AddValidatorToRegistry updates the beacon state with validator information
-// def add_validator_to_registry(state: BeaconState,
-//
-//	                          pubkey: BLSPubkey,
-//	                          withdrawal_credentials: Bytes32,
-//	                          amount: uint64) -> None:
-//	index = get_index_for_new_validator(state)
-//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
-//	set_or_append_list(state.validators, index, validator)
-//	set_or_append_list(state.balances, index, 0)  # [Modified in Electra:EIP7251]
-//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000))
-//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000))
-//	set_or_append_list(state.inactivity_scores, index, uint64(0))
-//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [New in Electra:EIP7251]
-func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
-	val := ValidatorFromDeposit(pubKey, withdrawalCredentials)
-	if err := beaconState.AppendValidator(val); err != nil {
-		return err
-	}
-	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
-	if !ok {
-		return errors.New("could not find validator in registry")
-	}
-	if err := beaconState.AppendBalance(0); err != nil {
-		return err
-	}
-	if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
-		return err
-	}
-	if err := beaconState.AppendInactivityScore(0); err != nil {
-		return err
-	}
-	if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-		return err
-	}
-	return beaconState.AppendCurrentParticipationBits(0)
-}
-
-// ValidatorFromDeposit gets a new validator object with provided parameters
-//
-// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32) -> Validator:
-//
-//	return Validator(
-//	pubkey=pubkey,
-//	withdrawal_credentials=withdrawal_credentials,
-//	activation_eligibility_epoch=FAR_FUTURE_EPOCH,
-//	activation_epoch=FAR_FUTURE_EPOCH,
-//	exit_epoch=FAR_FUTURE_EPOCH,
-//	withdrawable_epoch=FAR_FUTURE_EPOCH,
-//	effective_balance=0,  # [Modified in Electra:EIP7251]
-//
-// )
-func ValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte) *ethpb.Validator {
-	return &ethpb.Validator{
-		PublicKey:                  pubKey,
-		WithdrawalCredentials:      withdrawalCredentials,
-		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
-		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-		EffectiveBalance:           0, // [Modified in Electra:EIP7251]
-	}
-}
-
 // SwitchToCompoundingValidator
 //
 // Spec definition:
 //
 //	 def switch_to_compounding_validator(state: BeaconState, index: ValidatorIndex) -> None:
 //		validator = state.validators[index]
-//		if has_eth1_withdrawal_credential(validator):
+//		validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
-//		    validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
+//		queue_excess_active_balance(state, index)
-//		    queue_excess_active_balance(state, index)
 func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	v, err := s.ValidatorAtIndex(idx)
 	if err != nil {
@@ -92,28 +26,31 @@ func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorI
 	if len(v.WithdrawalCredentials) == 0 {
 		return errors.New("validator has no withdrawal credentials")
 	}
-	if helpers.HasETH1WithdrawalCredential(v) {
+
-		v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-		if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
+	if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
-			return err
+		return err
-		}
-		return QueueExcessActiveBalance(s, idx)
 	}
-	return nil
+	return QueueExcessActiveBalance(s, idx)
 }
 
-// QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending balance deposit.
+// QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending deposit.
 //
 // Spec definition:
 //
-//	def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
+//		def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
-//	    balance = state.balances[index]
+//		    balance = state.balances[index]
-//	    if balance > MIN_ACTIVATION_BALANCE:
+//		    if balance > MIN_ACTIVATION_BALANCE:
-//	        excess_balance = balance - MIN_ACTIVATION_BALANCE
+//		        excess_balance = balance - MIN_ACTIVATION_BALANCE
-//	        state.balances[index] = MIN_ACTIVATION_BALANCE
+//		        state.balances[index] = MIN_ACTIVATION_BALANCE
-//	        state.pending_balance_deposits.append(
+//		        validator = state.validators[index]
-//	            PendingBalanceDeposit(index=index, amount=excess_balance)
+//	         state.pending_deposits.append(PendingDeposit(
-//	        )
+//	           pubkey=validator.pubkey,
+//	           withdrawal_credentials=validator.withdrawal_credentials,
+//	           amount=excess_balance,
+//	           signature=bls.G2_POINT_AT_INFINITY,
+//	           slot=GENESIS_SLOT,
+//	         ))
 func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	bal, err := s.BalanceAtIndex(idx)
 	if err != nil {
@@ -121,11 +58,21 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 	}
 
 	if bal > params.BeaconConfig().MinActivationBalance {
+		val, err := s.ValidatorAtIndex(idx)
+		if err != nil {
+			return err
+		}
 		excessBalance := bal - params.BeaconConfig().MinActivationBalance
 		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
 			return err
 		}
-		return s.AppendPendingBalanceDeposit(idx, excessBalance)
+		return s.AppendPendingDeposit(&ethpb.PendingDeposit{
+			PublicKey:             val.PublicKey,
+			WithdrawalCredentials: val.WithdrawalCredentials,
+			Amount:                excessBalance,
+			Signature:             common.InfiniteSignature[:],
+			Slot:                  params.BeaconConfig().GenesisSlot,
+		})
 	}
 	return nil
 }
@@ -134,15 +81,19 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 //
 // Spec definition:
 //
-//	def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//		def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
-//	    balance = state.balances[index]
+//		    balance = state.balances[index]
-//	    state.balances[index] = 0
+//		    state.balances[index] = 0
-//	    validator = state.validators[index]
+//		    validator = state.validators[index]
-//	    validator.effective_balance = 0
+//		    validator.effective_balance = 0
-//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
+//		    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
-//	    state.pending_balance_deposits.append(
+//		    state.pending_deposits.append(PendingDeposit(
-//	        PendingBalanceDeposit(index=index, amount=balance)
+//	       pubkey=validator.pubkey,
-//	    )
+//	       withdrawal_credentials=validator.withdrawal_credentials,
+//	       amount=balance,
+//	       signature=bls.G2_POINT_AT_INFINITY,
+//	       slot=GENESIS_SLOT,
+//	     ))
 //
 //nolint:dupword
 func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
@@ -166,5 +117,11 @@ func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.Val
 		return err
 	}
 
-	return s.AppendPendingBalanceDeposit(idx, bal)
+	return s.AppendPendingDeposit(&ethpb.PendingDeposit{
+		PublicKey:             v.PublicKey,
+		WithdrawalCredentials: v.WithdrawalCredentials,
+		Amount:                bal,
+		Signature:             common.InfiniteSignature[:],
+		Slot:                  params.BeaconConfig().GenesisSlot,
+	})
 }

beacon-chain/core/electra/validator_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -14,20 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestAddValidatorToRegistry(t *testing.T) {
-	st, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{})
-	require.NoError(t, err)
-	require.NoError(t, electra.AddValidatorToRegistry(st, make([]byte, fieldparams.BLSPubkeyLength), make([]byte, fieldparams.RootLength), 100))
-	balances := st.Balances()
-	require.Equal(t, 1, len(balances))
-	require.Equal(t, uint64(0), balances[0])
-	pbds, err := st.PendingBalanceDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(pbds))
-	require.Equal(t, uint64(100), pbds[0].Amount)
-	require.Equal(t, primitives.ValidatorIndex(0), pbds[0].Index)
-}
-
 func TestSwitchToCompoundingValidator(t *testing.T) {
 	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
 		Validators: []*eth.Validator{
@@ -60,7 +45,7 @@ func TestSwitchToCompoundingValidator(t *testing.T) {
 	b, err := s.BalanceAtIndex(1)
 	require.NoError(t, err)
 	require.Equal(t, params.BeaconConfig().MinActivationBalance, b, "balance was changed")
-	pbd, err := s.PendingBalanceDeposits()
+	pbd, err := s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 0, len(pbd), "pending balance deposits should be empty")
 
@@ -69,11 +54,10 @@ func TestSwitchToCompoundingValidator(t *testing.T) {
 	b, err = s.BalanceAtIndex(2)
 	require.NoError(t, err)
 	require.Equal(t, params.BeaconConfig().MinActivationBalance, b, "balance was not changed")
-	pbd, err = s.PendingBalanceDeposits()
+	pbd, err = s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 1, len(pbd), "pending balance deposits should have one element")
 	require.Equal(t, uint64(100_000), pbd[0].Amount, "pending balance deposit amount is incorrect")
-	require.Equal(t, primitives.ValidatorIndex(2), pbd[0].Index, "pending balance deposit index is incorrect")
 }
 
 func TestQueueEntireBalanceAndResetValidator(t *testing.T) {
@@ -97,11 +81,10 @@ func TestQueueEntireBalanceAndResetValidator(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), v.EffectiveBalance, "effective balance was not reset")
 	require.Equal(t, params.BeaconConfig().FarFutureEpoch, v.ActivationEligibilityEpoch, "activation eligibility epoch was not reset")
-	pbd, err := s.PendingBalanceDeposits()
+	pbd, err := s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 1, len(pbd), "pending balance deposits should have one element")
 	require.Equal(t, params.BeaconConfig().MinActivationBalance+100_000, pbd[0].Amount, "pending balance deposit amount is incorrect")
-	require.Equal(t, primitives.ValidatorIndex(0), pbd[0].Index, "pending balance deposit index is incorrect")
 }
 
 func TestSwitchToCompoundingValidator_Ok(t *testing.T) {
@@ -114,7 +97,7 @@ func TestSwitchToCompoundingValidator_Ok(t *testing.T) {
 	require.NoError(t, st.SetBalances(bals))
 	require.NoError(t, electra.SwitchToCompoundingValidator(st, 0))
 
-	pbd, err := st.PendingBalanceDeposits()
+	pbd, err := st.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1010), pbd[0].Amount) // appends it at the end
 	val, err := st.ValidatorAtIndex(0)
@@ -132,7 +115,7 @@ func TestQueueExcessActiveBalance_Ok(t *testing.T) {
 	err := electra.QueueExcessActiveBalance(st, 0)
 	require.NoError(t, err)
 
-	pbd, err := st.PendingBalanceDeposits()
+	pbd, err := st.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1000), pbd[0].Amount) // appends it at the end
 
@@ -149,7 +132,7 @@ func TestQueueEntireBalanceAndResetValidator_Ok(t *testing.T) {
 	err := electra.QueueEntireBalanceAndResetValidator(st, 0)
 	require.NoError(t, err)
 
-	pbd, err := st.PendingBalanceDeposits()
+	pbd, err := st.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 1, len(pbd))
 	require.Equal(t, params.BeaconConfig().MinActivationBalance-1000, pbd[0].Amount)

beacon-chain/p2p/encoder/ssz_test.go

@@ -110,7 +110,7 @@ type BeaconStateElectraCreator struct{}
 type PowBlockCreator struct{}
 type HistoricalSummaryCreator struct{}
 type BlobIdentifierCreator struct{}
-type PendingBalanceDepositCreator struct{}
+type PendingDepositCreator struct{}
 type PendingPartialWithdrawalCreator struct{}
 type PendingConsolidationCreator struct{}
 type StatusCreator struct{}
@@ -279,8 +279,8 @@ func (BeaconStateElectraCreator) Create() MarshalerProtoMessage { return &ethpb.
 func (PowBlockCreator) Create() MarshalerProtoMessage           { return &ethpb.PowBlock{} }
 func (HistoricalSummaryCreator) Create() MarshalerProtoMessage  { return &ethpb.HistoricalSummary{} }
 func (BlobIdentifierCreator) Create() MarshalerProtoMessage     { return &ethpb.BlobIdentifier{} }
-func (PendingBalanceDepositCreator) Create() MarshalerProtoMessage {
+func (PendingDepositCreator) Create() MarshalerProtoMessage {
-	return &ethpb.PendingBalanceDeposit{}
+	return &ethpb.PendingDeposit{}
 }
 func (PendingPartialWithdrawalCreator) Create() MarshalerProtoMessage {
 	return &ethpb.PendingPartialWithdrawal{}
@@ -397,7 +397,7 @@ var creators = []MarshalerProtoCreator{
 	PowBlockCreator{},
 	HistoricalSummaryCreator{},
 	BlobIdentifierCreator{},
-	PendingBalanceDepositCreator{},
+	PendingDepositCreator{},
 	PendingPartialWithdrawalCreator{},
 	PendingConsolidationCreator{},
 	StatusCreator{},

beacon-chain/rpc/eth/config/handlers_test.go

@@ -138,7 +138,7 @@ func TestGetSpec(t *testing.T) {
 	config.WhistleBlowerRewardQuotientElectra = 79
 	config.PendingPartialWithdrawalsLimit = 80
 	config.MinActivationBalance = 81
-	config.PendingBalanceDepositLimit = 82
+	config.PendingDepositLimit = 82
 	config.MaxPendingPartialsPerWithdrawalsSweep = 83
 	config.PendingConsolidationsLimit = 84
 	config.MaxPartialWithdrawalsPerPayload = 85
@@ -150,6 +150,7 @@ func TestGetSpec(t *testing.T) {
 	config.MaxCellsInExtendedMatrix = 91
 	config.UnsetDepositRequestsStartIndex = 92
 	config.MaxDepositRequestsPerPayload = 93
+	config.MaxPendingDepositsPerEpoch = 94
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -499,7 +500,7 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "80", v)
 			case "MIN_ACTIVATION_BALANCE":
 				assert.Equal(t, "81", v)
-			case "PENDING_BALANCE_DEPOSITS_LIMIT":
+			case "PENDING_DEPOSITS_LIMIT":
 				assert.Equal(t, "82", v)
 			case "MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP":
 				assert.Equal(t, "83", v)
@@ -523,6 +524,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "92", v)
 			case "MAX_DEPOSIT_REQUESTS_PER_PAYLOAD":
 				assert.Equal(t, "93", v)
+			case "MAX_PENDING_DEPOSITS_PER_EPOCH":
+				assert.Equal(t, "94", v)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}

beacon-chain/state/interfaces.go

@@ -225,7 +225,7 @@ type ReadOnlySyncCommittee interface {
 type ReadOnlyDeposits interface {
 	DepositBalanceToConsume() (primitives.Gwei, error)
 	DepositRequestsStartIndex() (uint64, error)
-	PendingBalanceDeposits() ([]*ethpb.PendingBalanceDeposit, error)
+	PendingDeposits() ([]*ethpb.PendingDeposit, error)
 }
 
 type ReadOnlyConsolidations interface {
@@ -331,8 +331,8 @@ type WriteOnlyConsolidations interface {
 }
 
 type WriteOnlyDeposits interface {
-	AppendPendingBalanceDeposit(index primitives.ValidatorIndex, amount uint64) error
+	AppendPendingDeposit(pd *ethpb.PendingDeposit) error
 	SetDepositRequestsStartIndex(index uint64) error
-	SetPendingBalanceDeposits(val []*ethpb.PendingBalanceDeposit) error
+	SetPendingDeposits(val []*ethpb.PendingDeposit) error
 	SetDepositBalanceToConsume(primitives.Gwei) error
 }

beacon-chain/state/state-native/BUILD.bazel

@@ -7,11 +7,11 @@ go_library(
         "doc.go",
         "error.go",
         "getters_attestation.go",
-        "getters_balance_deposits.go",
         "getters_block.go",
         "getters_checkpoint.go",
         "getters_consolidation.go",
         "getters_deposit_requests.go",
+        "getters_deposits.go",
         "getters_eth1.go",
         "getters_exit.go",
         "getters_misc.go",
@@ -27,12 +27,12 @@ go_library(
         "proofs.go",
         "readonly_validator.go",
         "setters_attestation.go",
-        "setters_balance_deposits.go",
         "setters_block.go",
         "setters_checkpoint.go",
         "setters_churn.go",
         "setters_consolidation.go",
         "setters_deposit_requests.go",
+        "setters_deposits.go",
         "setters_eth1.go",
         "setters_misc.go",
         "setters_participation.go",
@@ -91,11 +91,11 @@ go_test(
     name = "go_default_test",
     srcs = [
         "getters_attestation_test.go",
-        "getters_balance_deposits_test.go",
         "getters_block_test.go",
         "getters_checkpoint_test.go",
         "getters_consolidation_test.go",
         "getters_deposit_requests_test.go",
+        "getters_deposits_test.go",
         "getters_exit_test.go",
         "getters_participation_test.go",
         "getters_test.go",
@@ -107,10 +107,10 @@ go_test(
         "readonly_validator_test.go",
         "references_test.go",
         "setters_attestation_test.go",
-        "setters_balance_deposits_test.go",
         "setters_churn_test.go",
         "setters_consolidation_test.go",
         "setters_deposit_requests_test.go",
+        "setters_deposits_test.go",
         "setters_eth1_test.go",
         "setters_misc_test.go",
         "setters_participation_test.go",

beacon-chain/state/state-native/beacon_state.go

@@ -65,7 +65,7 @@ type BeaconState struct {
 	earliestExitEpoch             primitives.Epoch
 	consolidationBalanceToConsume primitives.Gwei
 	earliestConsolidationEpoch    primitives.Epoch
-	pendingBalanceDeposits        []*ethpb.PendingBalanceDeposit    // pending_balance_deposits: List[PendingBalanceDeposit, PENDING_BALANCE_DEPOSITS_LIMIT]
+	pendingDeposits               []*ethpb.PendingDeposit           // pending_deposits: List[PendingDeposit, PENDING_DEPOSITS_LIMIT]
 	pendingPartialWithdrawals     []*ethpb.PendingPartialWithdrawal // pending_partial_withdrawals: List[PartialWithdrawal, PENDING_PARTIAL_WITHDRAWALS_LIMIT]
 	pendingConsolidations         []*ethpb.PendingConsolidation     // pending_consolidations: List[PendingConsolidation, PENDING_CONSOLIDATIONS_LIMIT]
 
@@ -121,7 +121,7 @@ type beaconStateMarshalable struct {
 	EarliestExitEpoch                   primitives.Epoch                        `json:"earliest_exit_epoch" yaml:"earliest_exit_epoch"`
 	ConsolidationBalanceToConsume       primitives.Gwei                         `json:"consolidation_balance_to_consume" yaml:"consolidation_balance_to_consume"`
 	EarliestConsolidationEpoch          primitives.Epoch                        `json:"earliest_consolidation_epoch" yaml:"earliest_consolidation_epoch"`
-	PendingBalanceDeposits              []*ethpb.PendingBalanceDeposit          `json:"pending_balance_deposits" yaml:"pending_balance_deposits"`
+	PendingDeposits                     []*ethpb.PendingDeposit                 `json:"pending_deposits" yaml:"pending_deposits"`
 	PendingPartialWithdrawals           []*ethpb.PendingPartialWithdrawal       `json:"pending_partial_withdrawals" yaml:"pending_partial_withdrawals"`
 	PendingConsolidations               []*ethpb.PendingConsolidation           `json:"pending_consolidations" yaml:"pending_consolidations"`
 }
@@ -190,7 +190,7 @@ func (b *BeaconState) MarshalJSON() ([]byte, error) {
 		EarliestExitEpoch:                   b.earliestExitEpoch,
 		ConsolidationBalanceToConsume:       b.consolidationBalanceToConsume,
 		EarliestConsolidationEpoch:          b.earliestConsolidationEpoch,
-		PendingBalanceDeposits:              b.pendingBalanceDeposits,
+		PendingDeposits:                     b.pendingDeposits,
 		PendingPartialWithdrawals:           b.pendingPartialWithdrawals,
 		PendingConsolidations:               b.pendingConsolidations,
 	}

beacon-chain/state/state-native/getters_deposits.go

@@ -18,22 +18,22 @@ func (b *BeaconState) DepositBalanceToConsume() (primitives.Gwei, error) {
 	return b.depositBalanceToConsume, nil
 }
 
-// PendingBalanceDeposits is a non-mutating call to the beacon state which returns a deep copy of
+// PendingDeposits is a non-mutating call to the beacon state which returns a deep copy of
 // the pending balance deposit slice. This method requires access to the RLock on the state and
 // only applies in electra or later.
-func (b *BeaconState) PendingBalanceDeposits() ([]*ethpb.PendingBalanceDeposit, error) {
+func (b *BeaconState) PendingDeposits() ([]*ethpb.PendingDeposit, error) {
 	if b.version < version.Electra {
-		return nil, errNotSupported("PendingBalanceDeposits", b.version)
+		return nil, errNotSupported("PendingDeposits", b.version)
 	}
 	b.lock.RLock()
 	defer b.lock.RUnlock()
-	return b.pendingBalanceDepositsVal(), nil
+	return b.pendingDepositsVal(), nil
 }
 
-func (b *BeaconState) pendingBalanceDepositsVal() []*ethpb.PendingBalanceDeposit {
+func (b *BeaconState) pendingDepositsVal() []*ethpb.PendingDeposit {
-	if b.pendingBalanceDeposits == nil {
+	if b.pendingDeposits == nil {
 		return nil
 	}
 
-	return ethpb.CopySlice(b.pendingBalanceDeposits)
+	return ethpb.CopySlice(b.pendingDeposits)
 }

beacon-chain/state/state-native/getters_deposits_test.go

@@ -25,21 +25,40 @@ func TestDepositBalanceToConsume(t *testing.T) {
 	require.ErrorContains(t, "not supported", err)
 }
 
-func TestPendingBalanceDeposits(t *testing.T) {
+func TestPendingDeposits(t *testing.T) {
 	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
-		PendingBalanceDeposits: []*eth.PendingBalanceDeposit{
+		PendingDeposits: []*eth.PendingDeposit{
-			{Index: 1, Amount: 2},
+			{
-			{Index: 3, Amount: 4},
+				PublicKey:             []byte{1, 2, 3},
+				WithdrawalCredentials: []byte{4, 5, 6},
+				Amount:                2,
+				Signature:             []byte{7, 8, 9},
+				Slot:                  1,
+			},
+			{
+				PublicKey:             []byte{11, 22, 33},
+				WithdrawalCredentials: []byte{44, 55, 66},
+				Amount:                4,
+				Signature:             []byte{77, 88, 99},
+				Slot:                  2,
+			},
 		},
 	})
 	require.NoError(t, err)
-	pbd, err := s.PendingBalanceDeposits()
+	pbd, err := s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 2, len(pbd))
-	require.Equal(t, primitives.ValidatorIndex(1), pbd[0].Index)
+	require.DeepEqual(t, []byte{1, 2, 3}, pbd[0].PublicKey)
+	require.DeepEqual(t, []byte{4, 5, 6}, pbd[0].WithdrawalCredentials)
 	require.Equal(t, uint64(2), pbd[0].Amount)
-	require.Equal(t, primitives.ValidatorIndex(3), pbd[1].Index)
+	require.DeepEqual(t, []byte{7, 8, 9}, pbd[0].Signature)
+	require.Equal(t, primitives.Slot(1), pbd[0].Slot)
+
+	require.DeepEqual(t, []byte{11, 22, 33}, pbd[1].PublicKey)
+	require.DeepEqual(t, []byte{44, 55, 66}, pbd[1].WithdrawalCredentials)
 	require.Equal(t, uint64(4), pbd[1].Amount)
+	require.DeepEqual(t, []byte{77, 88, 99}, pbd[1].Signature)
+	require.Equal(t, primitives.Slot(2), pbd[1].Slot)
 
 	// Fails for older than electra state
 	s, err = state_native.InitializeFromProtoDeneb(&eth.BeaconStateDeneb{})

beacon-chain/state/state-native/getters_state.go

@@ -208,7 +208,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			EarliestExitEpoch:             b.earliestExitEpoch,
 			ConsolidationBalanceToConsume: b.consolidationBalanceToConsume,
 			EarliestConsolidationEpoch:    b.earliestConsolidationEpoch,
-			PendingBalanceDeposits:        b.pendingBalanceDeposits,
+			PendingDeposits:               b.pendingDeposits,
 			PendingPartialWithdrawals:     b.pendingPartialWithdrawals,
 			PendingConsolidations:         b.pendingConsolidations,
 		}
@@ -414,7 +414,7 @@ func (b *BeaconState) ToProto() interface{} {
 			EarliestExitEpoch:             b.earliestExitEpoch,
 			ConsolidationBalanceToConsume: b.consolidationBalanceToConsume,
 			EarliestConsolidationEpoch:    b.earliestConsolidationEpoch,
-			PendingBalanceDeposits:        b.pendingBalanceDepositsVal(),
+			PendingDeposits:               b.pendingDepositsVal(),
 			PendingPartialWithdrawals:     b.pendingPartialWithdrawalsVal(),
 			PendingConsolidations:         b.pendingConsolidationsVal(),
 		}

beacon-chain/state/state-native/getters_withdrawal.go

@@ -113,6 +113,7 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 	epoch := slots.ToEpoch(b.slot)
 
 	// Electra partial withdrawals functionality.
+	var partialWithdrawalsCount uint64
 	if b.version >= version.Electra {
 		for _, w := range b.pendingPartialWithdrawals {
 			if w.WithdrawableEpoch > epoch || len(withdrawals) >= int(params.BeaconConfig().MaxPendingPartialsPerWithdrawalsSweep) {
@@ -139,9 +140,9 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 				})
 				withdrawalIndex++
 			}
+			partialWithdrawalsCount++
 		}
 	}
-	partialWithdrawalsCount := uint64(len(withdrawals))
 
 	validatorsLen := b.validatorsLen()
 	bound := mathutil.Min(uint64(validatorsLen), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)

beacon-chain/state/state-native/getters_withdrawal_test.go

@@ -343,10 +343,28 @@ func TestExpectedWithdrawals(t *testing.T) {
 		require.NoError(t, pb.UnmarshalSSZ(serializedSSZ))
 		s, err := state_native.InitializeFromProtoElectra(pb)
 		require.NoError(t, err)
-		t.Log(s.NumPendingPartialWithdrawals())
 		expected, partialWithdrawalsCount, err := s.ExpectedWithdrawals()
 		require.NoError(t, err)
 		require.Equal(t, 8, len(expected))
 		require.Equal(t, uint64(8), partialWithdrawalsCount)
 	})
+
+	t.Run("electra some pending partial withdrawals", func(t *testing.T) {
+		// Load a serialized Electra state from disk.
+		// This spectest has a fully hydrated beacon state with partial pending withdrawals.
+		serializedBytes, err := util.BazelFileBytes("tests/mainnet/electra/operations/withdrawal_request/pyspec_tests/pending_withdrawals_consume_all_excess_balance/pre.ssz_snappy")
+		require.NoError(t, err)
+		serializedSSZ, err := snappy.Decode(nil /* dst */, serializedBytes)
+		require.NoError(t, err)
+		pb := &ethpb.BeaconStateElectra{}
+		require.NoError(t, pb.UnmarshalSSZ(serializedSSZ))
+		s, err := state_native.InitializeFromProtoElectra(pb)
+		require.NoError(t, err)
+		p, err := s.PendingPartialWithdrawals()
+		require.NoError(t, err)
+		require.NoError(t, s.UpdateBalancesAtIndex(p[0].Index, 0)) // This should still count as partial withdrawal.
+		_, partialWithdrawalsCount, err := s.ExpectedWithdrawals()
+		require.NoError(t, err)
+		require.Equal(t, uint64(10), partialWithdrawalsCount)
+	})
 }

beacon-chain/state/state-native/hasher.go

@@ -296,12 +296,12 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		eceRoot := ssz.Uint64Root(uint64(state.earliestConsolidationEpoch))
 		fieldRoots[types.EarliestConsolidationEpoch.RealPosition()] = eceRoot[:]
 
-		// PendingBalanceDeposits root.
+		// PendingDeposits root.
-		pbdRoot, err := stateutil.PendingBalanceDepositsRoot(state.pendingBalanceDeposits)
+		pbdRoot, err := stateutil.PendingDepositsRoot(state.pendingDeposits)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not compute pending balance deposits merkleization")
 		}
-		fieldRoots[types.PendingBalanceDeposits.RealPosition()] = pbdRoot[:]
+		fieldRoots[types.PendingDeposits.RealPosition()] = pbdRoot[:]
 
 		// PendingPartialWithdrawals root.
 		ppwRoot, err := stateutil.PendingPartialWithdrawalsRoot(state.pendingPartialWithdrawals)

beacon-chain/state/state-native/setters_deposits.go

@@ -8,43 +8,43 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
-// AppendPendingBalanceDeposit is a mutating call to the beacon state to create and append a pending
+// AppendPendingDeposit is a mutating call to the beacon state to create and append a pending
 // balance deposit object on to the state. This method requires access to the Lock on the state and
 // only applies in electra or later.
-func (b *BeaconState) AppendPendingBalanceDeposit(index primitives.ValidatorIndex, amount uint64) error {
+func (b *BeaconState) AppendPendingDeposit(pd *ethpb.PendingDeposit) error {
 	if b.version < version.Electra {
-		return errNotSupported("AppendPendingBalanceDeposit", b.version)
+		return errNotSupported("AppendPendingDeposit", b.version)
 	}
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	b.sharedFieldReferences[types.PendingBalanceDeposits].MinusRef()
+	b.sharedFieldReferences[types.PendingDeposits].MinusRef()
-	b.sharedFieldReferences[types.PendingBalanceDeposits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingDeposits] = stateutil.NewRef(1)
 
-	b.pendingBalanceDeposits = append(b.pendingBalanceDeposits, &ethpb.PendingBalanceDeposit{Index: index, Amount: amount})
+	b.pendingDeposits = append(b.pendingDeposits, pd)
 
-	b.markFieldAsDirty(types.PendingBalanceDeposits)
+	b.markFieldAsDirty(types.PendingDeposits)
-	b.rebuildTrie[types.PendingBalanceDeposits] = true
+	b.rebuildTrie[types.PendingDeposits] = true
 	return nil
 }
 
-// SetPendingBalanceDeposits is a mutating call to the beacon state which replaces the pending
+// SetPendingDeposits is a mutating call to the beacon state which replaces the pending
 // balance deposit slice with the provided value. This method requires access to the Lock on the
 // state and only applies in electra or later.
-func (b *BeaconState) SetPendingBalanceDeposits(val []*ethpb.PendingBalanceDeposit) error {
+func (b *BeaconState) SetPendingDeposits(val []*ethpb.PendingDeposit) error {
 	if b.version < version.Electra {
-		return errNotSupported("SetPendingBalanceDeposits", b.version)
+		return errNotSupported("SetPendingDeposits", b.version)
 	}
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	b.sharedFieldReferences[types.PendingBalanceDeposits].MinusRef()
+	b.sharedFieldReferences[types.PendingDeposits].MinusRef()
-	b.sharedFieldReferences[types.PendingBalanceDeposits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingDeposits] = stateutil.NewRef(1)
 
-	b.pendingBalanceDeposits = val
+	b.pendingDeposits = val
 
-	b.markFieldAsDirty(types.PendingBalanceDeposits)
+	b.markFieldAsDirty(types.PendingDeposits)
-	b.rebuildTrie[types.PendingBalanceDeposits] = true
+	b.rebuildTrie[types.PendingDeposits] = true
 	return nil
 }
 

beacon-chain/state/state-native/setters_deposits_test.go

@@ -9,40 +9,52 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
-func TestAppendPendingBalanceDeposit(t *testing.T) {
+func TestAppendPendingDeposit(t *testing.T) {
 	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{})
 	require.NoError(t, err)
-	pbd, err := s.PendingBalanceDeposits()
+	pbd, err := s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 0, len(pbd))
-	require.NoError(t, s.AppendPendingBalanceDeposit(1, 10))
+	creds := []byte{0xFA, 0xCC}
-	pbd, err = s.PendingBalanceDeposits()
+	pubkey := []byte{0xAA, 0xBB}
+	sig := []byte{0xCC, 0xDD}
+	require.NoError(t, s.AppendPendingDeposit(&eth.PendingDeposit{
+		PublicKey:             pubkey,
+		WithdrawalCredentials: creds,
+		Amount:                10,
+		Signature:             sig,
+		Slot:                  1,
+	}))
+	pbd, err = s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 1, len(pbd))
-	require.Equal(t, primitives.ValidatorIndex(1), pbd[0].Index)
+	require.DeepEqual(t, pubkey, pbd[0].PublicKey)
 	require.Equal(t, uint64(10), pbd[0].Amount)
+	require.DeepEqual(t, creds, pbd[0].WithdrawalCredentials)
+	require.Equal(t, primitives.Slot(1), pbd[0].Slot)
+	require.DeepEqual(t, sig, pbd[0].Signature)
 
 	// Fails for versions older than electra
 	s, err = state_native.InitializeFromProtoDeneb(&eth.BeaconStateDeneb{})
 	require.NoError(t, err)
-	require.ErrorContains(t, "not supported", s.AppendPendingBalanceDeposit(1, 1))
+	require.ErrorContains(t, "not supported", s.AppendPendingDeposit(&eth.PendingDeposit{}))
 }
 
-func TestSetPendingBalanceDeposits(t *testing.T) {
+func TestSetPendingDeposits(t *testing.T) {
 	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{})
 	require.NoError(t, err)
-	pbd, err := s.PendingBalanceDeposits()
+	pbd, err := s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 0, len(pbd))
-	require.NoError(t, s.SetPendingBalanceDeposits([]*eth.PendingBalanceDeposit{{}, {}, {}}))
+	require.NoError(t, s.SetPendingDeposits([]*eth.PendingDeposit{{}, {}, {}}))
-	pbd, err = s.PendingBalanceDeposits()
+	pbd, err = s.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 3, len(pbd))
 
 	// Fails for versions older than electra
 	s, err = state_native.InitializeFromProtoDeneb(&eth.BeaconStateDeneb{})
 	require.NoError(t, err)
-	require.ErrorContains(t, "not supported", s.SetPendingBalanceDeposits([]*eth.PendingBalanceDeposit{{}, {}, {}}))
+	require.ErrorContains(t, "not supported", s.SetPendingDeposits([]*eth.PendingDeposit{{}, {}, {}}))
 }
 
 func TestSetDepositBalanceToConsume(t *testing.T) {

beacon-chain/state/state-native/state_trie.go

@@ -106,7 +106,7 @@ var electraFields = append(
 	types.EarliestExitEpoch,
 	types.ConsolidationBalanceToConsume,
 	types.EarliestConsolidationEpoch,
-	types.PendingBalanceDeposits,
+	types.PendingDeposits,
 	types.PendingPartialWithdrawals,
 	types.PendingConsolidations,
 )
@@ -755,7 +755,7 @@ func InitializeFromProtoUnsafeElectra(st *ethpb.BeaconStateElectra) (state.Beaco
 		earliestExitEpoch:                 st.EarliestExitEpoch,
 		consolidationBalanceToConsume:     st.ConsolidationBalanceToConsume,
 		earliestConsolidationEpoch:        st.EarliestConsolidationEpoch,
-		pendingBalanceDeposits:            st.PendingBalanceDeposits,
+		pendingDeposits:                   st.PendingDeposits,
 		pendingPartialWithdrawals:         st.PendingPartialWithdrawals,
 		pendingConsolidations:             st.PendingConsolidations,
 
@@ -820,7 +820,7 @@ func InitializeFromProtoUnsafeElectra(st *ethpb.BeaconStateElectra) (state.Beaco
 	b.sharedFieldReferences[types.CurrentEpochParticipationBits] = stateutil.NewRef(1)
 	b.sharedFieldReferences[types.LatestExecutionPayloadHeaderDeneb] = stateutil.NewRef(1) // New in Electra.
 	b.sharedFieldReferences[types.HistoricalSummaries] = stateutil.NewRef(1)               // New in Capella.
-	b.sharedFieldReferences[types.PendingBalanceDeposits] = stateutil.NewRef(1)            // New in Electra.
+	b.sharedFieldReferences[types.PendingDeposits] = stateutil.NewRef(1)                   // New in Electra.
 	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)         // New in Electra.
 	b.sharedFieldReferences[types.PendingConsolidations] = stateutil.NewRef(1)             // New in Electra.
 	if !features.Get().EnableExperimentalState {
@@ -898,7 +898,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 		currentEpochParticipation:  b.currentEpochParticipation,
 		inactivityScores:           b.inactivityScores,
 		inactivityScoresMultiValue: b.inactivityScoresMultiValue,
-		pendingBalanceDeposits:     b.pendingBalanceDeposits,
+		pendingDeposits:            b.pendingDeposits,
 		pendingPartialWithdrawals:  b.pendingPartialWithdrawals,
 		pendingConsolidations:      b.pendingConsolidations,
 
@@ -1301,8 +1301,8 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return ssz.Uint64Root(uint64(b.consolidationBalanceToConsume)), nil
 	case types.EarliestConsolidationEpoch:
 		return ssz.Uint64Root(uint64(b.earliestConsolidationEpoch)), nil
-	case types.PendingBalanceDeposits:
+	case types.PendingDeposits:
-		return stateutil.PendingBalanceDepositsRoot(b.pendingBalanceDeposits)
+		return stateutil.PendingDepositsRoot(b.pendingDeposits)
 	case types.PendingPartialWithdrawals:
 		return stateutil.PendingPartialWithdrawalsRoot(b.pendingPartialWithdrawals)
 	case types.PendingConsolidations:

beacon-chain/state/state-native/types/types.go

@@ -106,8 +106,8 @@ func (f FieldIndex) String() string {
 		return "consolidationBalanceToConsume"
 	case EarliestConsolidationEpoch:
 		return "earliestConsolidationEpoch"
-	case PendingBalanceDeposits:
+	case PendingDeposits:
-		return "pendingBalanceDeposits"
+		return "pendingDeposits"
 	case PendingPartialWithdrawals:
 		return "pendingPartialWithdrawals"
 	case PendingConsolidations:
@@ -189,7 +189,7 @@ func (f FieldIndex) RealPosition() int {
 		return 32
 	case EarliestConsolidationEpoch:
 		return 33
-	case PendingBalanceDeposits:
+	case PendingDeposits:
 		return 34
 	case PendingPartialWithdrawals:
 		return 35
@@ -256,7 +256,7 @@ const (
 	EarliestExitEpoch             // Electra: EIP-7251
 	ConsolidationBalanceToConsume // Electra: EIP-7251
 	EarliestConsolidationEpoch    // Electra: EIP-7251
-	PendingBalanceDeposits        // Electra: EIP-7251
+	PendingDeposits               // Electra: EIP-7251
 	PendingPartialWithdrawals     // Electra: EIP-7251
 	PendingConsolidations         // Electra: EIP-7251
 )

beacon-chain/state/stategen/BUILD.bazel

@@ -72,18 +72,21 @@ go_test(
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/testing:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/blocks/testing:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/mock:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version: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_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

beacon-chain/state/stategen/replay_test.go

@@ -4,15 +4,18 @@ import (
 	"context"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
+	stateTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/testing"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
@@ -209,13 +212,30 @@ func TestReplayBlocks_ProcessEpoch_Electra(t *testing.T) {
 	beaconState, _ := util.DeterministicGenesisStateElectra(t, 1)
 	require.NoError(t, beaconState.SetDepositBalanceToConsume(100))
 	amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-	require.NoError(t, beaconState.SetPendingBalanceDeposits([]*ethpb.PendingBalanceDeposit{
+	genesisBlock := util.NewBeaconBlockElectra()
+
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	ethAddress, err := hexutil.Decode("0x967646dCD8d34F4E02204faeDcbAe0cC96fB9245")
+	require.NoError(t, err)
+	newCredentials := make([]byte, 12)
+	newCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	withdrawalCredentials := append(newCredentials, ethAddress...)
+	ffe := params.BeaconConfig().FarFutureEpoch
+	require.NoError(t, beaconState.SetValidators([]*ethpb.Validator{
 		{
-			Amount: uint64(amountAvailForProcessing) / 10,
+			PublicKey:             sk.PublicKey().Marshal(),
-			Index:  primitives.ValidatorIndex(0),
+			WithdrawalCredentials: withdrawalCredentials,
+			ExitEpoch:             ffe,
+			EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
 		},
 	}))
-	genesisBlock := util.NewBeaconBlockElectra()
+	beaconState.SaveValidatorIndices()
+
+	require.NoError(t, beaconState.SetPendingDeposits([]*ethpb.PendingDeposit{
+		stateTesting.GeneratePendingDeposit(t, sk, uint64(amountAvailForProcessing)/10, bytesutil.ToBytes32(withdrawalCredentials), genesisBlock.Block.Slot),
+	}))
+
 	bodyRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	err = beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
@@ -238,7 +258,7 @@ func TestReplayBlocks_ProcessEpoch_Electra(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, primitives.Gwei(0), res)
 
-	remaining, err := newState.PendingBalanceDeposits()
+	remaining, err := newState.PendingDeposits()
 	require.NoError(t, err)
 	require.Equal(t, 0, len(remaining))
 

beacon-chain/state/stateutil/BUILD.bazel

@@ -12,8 +12,8 @@ go_library(
         "historical_summaries_root.go",
         "participation_bit_root.go",
         "pending_attestation_root.go",
-        "pending_balance_deposits_root.go",
         "pending_consolidations_root.go",
+        "pending_deposits_root.go",
         "pending_partial_withdrawals_root.go",
         "reference.go",
         "sync_committee.root.go",

beacon-chain/state/stateutil/pending_deposits_root.go

@@ -6,6 +6,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
-func PendingBalanceDepositsRoot(slice []*ethpb.PendingBalanceDeposit) ([32]byte, error) {
+func PendingDepositsRoot(slice []*ethpb.PendingDeposit) ([32]byte, error) {
-	return ssz.SliceRoot(slice, fieldparams.PendingBalanceDepositsLimit)
+	return ssz.SliceRoot(slice, fieldparams.PendingDepositsLimit)
 }

beacon-chain/state/testing/BUILD.bazel

@@ -4,17 +4,25 @@ go_library(
     name = "go_default_library",
     testonly = True,
     srcs = [
+        "generators.go",
         "getters.go",
         "getters_block.go",
         "getters_checkpoint.go",
         "getters_validator.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/testing",
-    visibility = ["//beacon-chain/state:__subpackages__"],
+    visibility = [
+        "//beacon-chain/core:__subpackages__",
+        "//beacon-chain/state:__subpackages__",
+    ],
     deps = [
+        "//beacon-chain/core/blocks:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams: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",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/state/testing/generators.go

@@ -0,0 +1,44 @@
+package testing
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+// GeneratePendingDeposit is used for testing and producing a signed pending deposit
+func GeneratePendingDeposit(t *testing.T, key common.SecretKey, amount uint64, withdrawalCredentials [32]byte, slot primitives.Slot) *ethpb.PendingDeposit {
+	dm := &ethpb.DepositMessage{
+		PublicKey:             key.PublicKey().Marshal(),
+		WithdrawalCredentials: withdrawalCredentials[:],
+		Amount:                amount,
+	}
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(dm, domain)
+	require.NoError(t, err)
+	sig := key.Sign(sr[:])
+	depositData := &ethpb.Deposit_Data{
+		PublicKey:             bytesutil.SafeCopyBytes(dm.PublicKey),
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(dm.WithdrawalCredentials),
+		Amount:                dm.Amount,
+		Signature:             sig.Marshal(),
+	}
+	valid, err := blocks.IsValidDepositSignature(depositData)
+	require.NoError(t, err)
+	require.Equal(t, true, valid)
+	return &ethpb.PendingDeposit{
+		PublicKey:             bytesutil.SafeCopyBytes(dm.PublicKey),
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(dm.WithdrawalCredentials),
+		Amount:                dm.Amount,
+		Signature:             sig.Marshal(),
+		Slot:                  slot,
+	}
+}

config/fieldparams/mainnet.go

@@ -34,7 +34,7 @@ const (
 	BlobSidecarSize                       = 131928        // defined to match blob sidecar size in bazel ssz codegen
 	KzgCommitmentInclusionProofDepth      = 17            // Merkle proof depth for blob_kzg_commitments list item
 	NextSyncCommitteeBranchDepth          = 5             // NextSyncCommitteeBranchDepth defines the depth of the next sync committee branch.
-	PendingBalanceDepositsLimit           = 134217728     // Maximum number of pending balance deposits in the beacon state.
+	PendingDepositsLimit                  = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 134217728     // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 262144        // Maximum number of pending consolidations in the beacon state.
 	MaxDepositRequestsPerPayload          = 8192          // Maximum number of deposit requests in an execution payload.

config/fieldparams/minimal.go

@@ -34,7 +34,7 @@ const (
 	BlobSidecarSize                       = 131928        // defined to match blob sidecar size in bazel ssz codegen
 	KzgCommitmentInclusionProofDepth      = 17            // Merkle proof depth for blob_kzg_commitments list item
 	NextSyncCommitteeBranchDepth          = 5             // NextSyncCommitteeBranchDepth defines the depth of the next sync committee branch.
-	PendingBalanceDepositsLimit           = 134217728     // Maximum number of pending balance deposits in the beacon state.
+	PendingDepositsLimit                  = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 64            // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 64            // Maximum number of pending consolidations in the beacon state.
 	MaxDepositRequestsPerPayload          = 4             // Maximum number of deposit requests in an execution payload.

config/params/config.go

@@ -244,11 +244,12 @@ type BeaconChainConfig struct {
 	MaxEffectiveBalanceElectra            uint64 `yaml:"MAX_EFFECTIVE_BALANCE_ELECTRA" spec:"true"`              // MaxEffectiveBalanceElectra is the maximal amount of Gwei that is effective for staking, increased in electra.
 	MinSlashingPenaltyQuotientElectra     uint64 `yaml:"MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA" spec:"true"`      // MinSlashingPenaltyQuotientElectra is used to calculate the minimum penalty to prevent DoS attacks, modified for electra.
 	WhistleBlowerRewardQuotientElectra    uint64 `yaml:"WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA" spec:"true"`      // WhistleBlowerRewardQuotientElectra is used to calculate whistle blower reward, modified in electra.
-	PendingBalanceDepositLimit            uint64 `yaml:"PENDING_BALANCE_DEPOSITS_LIMIT" spec:"true"`             // PendingBalanceDepositLimit is the maximum number of pending balance deposits allowed in the beacon state.
+	PendingDepositLimit                   uint64 `yaml:"PENDING_DEPOSITS_LIMIT" spec:"true"`                     // PendingDepositLimit is the maximum number of pending balance deposits allowed in the beacon state.
 	PendingPartialWithdrawalsLimit        uint64 `yaml:"PENDING_PARTIAL_WITHDRAWALS_LIMIT" spec:"true"`          // PendingPartialWithdrawalsLimit is the maximum number of pending partial withdrawals allowed in the beacon state.
 	PendingConsolidationsLimit            uint64 `yaml:"PENDING_CONSOLIDATIONS_LIMIT" spec:"true"`               // PendingConsolidationsLimit is the maximum number of pending validator consolidations allowed in the beacon state.
 	MaxConsolidationsRequestsPerPayload   uint64 `yaml:"MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD" spec:"true"`     // MaxConsolidationsRequestsPerPayload is the maximum number of consolidations in a block.
 	MaxPendingPartialsPerWithdrawalsSweep uint64 `yaml:"MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP" spec:"true"` // MaxPendingPartialsPerWithdrawalsSweep is the maximum number of pending partial withdrawals to process per payload.
+	MaxPendingDepositsPerEpoch            uint64 `yaml:"MAX_PENDING_DEPOSITS_PER_EPOCH" spec:"true"`             // MaxPendingDepositsPerEpoch is the maximum number of pending deposits per epoch processing.
 	FullExitRequestAmount                 uint64 `yaml:"FULL_EXIT_REQUEST_AMOUNT" spec:"true"`                   // FullExitRequestAmount is the amount of Gwei required to request a full exit.
 	MaxWithdrawalRequestsPerPayload       uint64 `yaml:"MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD" spec:"true"`        // MaxWithdrawalRequestsPerPayload is the maximum number of execution layer withdrawal requests in each payload.
 	MaxDepositRequestsPerPayload          uint64 `yaml:"MAX_DEPOSIT_REQUESTS_PER_PAYLOAD" spec:"true"`           // MaxDepositRequestsPerPayload is the maximum number of execution layer deposits in each payload

config/params/mainnet_config.go

@@ -282,12 +282,13 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxEffectiveBalanceElectra:            2048_000_000_000,
 	MinSlashingPenaltyQuotientElectra:     4096,
 	WhistleBlowerRewardQuotientElectra:    4096,
-	PendingBalanceDepositLimit:            134_217_728,
+	PendingDepositLimit:                   134_217_728,
 	PendingPartialWithdrawalsLimit:        134_217_728,
 	PendingConsolidationsLimit:            262_144,
 	MinActivationBalance:                  32_000_000_000,
 	MaxConsolidationsRequestsPerPayload:   1,
 	MaxPendingPartialsPerWithdrawalsSweep: 8,
+	MaxPendingDepositsPerEpoch:            16,
 	FullExitRequestAmount:                 0,
 	MaxWithdrawalRequestsPerPayload:       16,
 	MaxDepositRequestsPerPayload:          8192, // 2**13 (= 8192)

config/params/minimal_config.go

@@ -111,6 +111,8 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.MaxDepositRequestsPerPayload = 4
 	minimalConfig.PendingPartialWithdrawalsLimit = 64
 	minimalConfig.MaxPendingPartialsPerWithdrawalsSweep = 1
+	minimalConfig.PendingDepositLimit = 134217728
+	minimalConfig.MaxPendingDepositsPerEpoch = 16
 
 	// Ethereum PoW parameters.
 	minimalConfig.DepositChainID = 5   // Chain ID of eth1 goerli.

proto/prysm/v1alpha1/BUILD.bazel

@@ -144,8 +144,8 @@ ssz_electra_objs = [
     "BlindedBeaconBlockElectra",
     "Consolidation",
     "IndexedAttestationElectra",
-    "PendingBalanceDeposit",
+    "PendingDeposit",
-    "PendingBalanceDeposits",
+    "PendingDeposits",
     "PendingConsolidation",
     "PendingPartialWithdrawal",
     "SignedAggregateAttestationAndProofElectra",

proto/prysm/v1alpha1/beacon_block.go

@@ -625,14 +625,3 @@ func (summary *HistoricalSummary) Copy() *HistoricalSummary {
 		StateSummaryRoot: bytesutil.SafeCopyBytes(summary.StateSummaryRoot),
 	}
 }
-
-// Copy --
-func (pbd *PendingBalanceDeposit) Copy() *PendingBalanceDeposit {
-	if pbd == nil {
-		return nil
-	}
-	return &PendingBalanceDeposit{
-		Index:  pbd.Index,
-		Amount: pbd.Amount,
-	}
-}

proto/prysm/v1alpha1/beacon_block_fuzz_test.go

@@ -62,5 +62,5 @@ func TestCopyBeaconBlockFields_Fuzz(t *testing.T) {
 	fuzzCopies(t, &eth.SignedBLSToExecutionChange{})
 	fuzzCopies(t, &eth.BLSToExecutionChange{})
 	fuzzCopies(t, &eth.HistoricalSummary{})
-	fuzzCopies(t, &eth.PendingBalanceDeposit{})
+	fuzzCopies(t, &eth.PendingDeposit{})
 }

proto/prysm/v1alpha1/beacon_state.pb.go

@@ -1873,7 +1873,7 @@ type BeaconStateElectra struct {
 	EarliestExitEpoch             github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch          `protobuf:"varint,12004,opt,name=earliest_exit_epoch,json=earliestExitEpoch,proto3" json:"earliest_exit_epoch,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Epoch"`
 	ConsolidationBalanceToConsume github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Gwei           `protobuf:"varint,12005,opt,name=consolidation_balance_to_consume,json=consolidationBalanceToConsume,proto3" json:"consolidation_balance_to_consume,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Gwei"`
 	EarliestConsolidationEpoch    github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch          `protobuf:"varint,12006,opt,name=earliest_consolidation_epoch,json=earliestConsolidationEpoch,proto3" json:"earliest_consolidation_epoch,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Epoch"`
-	PendingBalanceDeposits        []*PendingBalanceDeposit                                                    `protobuf:"bytes,12007,rep,name=pending_balance_deposits,json=pendingBalanceDeposits,proto3" json:"pending_balance_deposits,omitempty" ssz-max:"134217728"`
+	PendingDeposits               []*PendingDeposit                                                           `protobuf:"bytes,12007,rep,name=pending_deposits,json=pendingDeposits,proto3" json:"pending_deposits,omitempty" ssz-max:"134217728"`
 	PendingPartialWithdrawals     []*PendingPartialWithdrawal                                                 `protobuf:"bytes,12008,rep,name=pending_partial_withdrawals,json=pendingPartialWithdrawals,proto3" json:"pending_partial_withdrawals,omitempty" ssz-max:"134217728"`
 	PendingConsolidations         []*PendingConsolidation                                                     `protobuf:"bytes,12009,rep,name=pending_consolidations,json=pendingConsolidations,proto3" json:"pending_consolidations,omitempty" ssz-max:"262144"`
 }
@@ -2148,9 +2148,9 @@ func (x *BeaconStateElectra) GetEarliestConsolidationEpoch() github_com_prysmati
 	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch(0)
 }
 
-func (x *BeaconStateElectra) GetPendingBalanceDeposits() []*PendingBalanceDeposit {
+func (x *BeaconStateElectra) GetPendingDeposits() []*PendingDeposit {
 	if x != nil {
-		return x.PendingBalanceDeposits
+		return x.PendingDeposits
 	}
 	return nil
 }
@@ -3010,7 +3010,7 @@ var file_proto_prysm_v1alpha1_beacon_state_proto_rawDesc = []byte{
 	0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72,
 	0x79, 0x42, 0x0c, 0x92, 0xb5, 0x18, 0x08, 0x31, 0x36, 0x37, 0x37, 0x37, 0x32, 0x31, 0x36, 0x52,
 	0x13, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61,
-	0x72, 0x69, 0x65, 0x73, 0x22, 0xcf, 0x19, 0x0a, 0x12, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53,
+	0x72, 0x69, 0x65, 0x73, 0x22, 0xb9, 0x19, 0x0a, 0x12, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53,
 	0x74, 0x61, 0x74, 0x65, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x61, 0x12, 0x22, 0x0a, 0x0c, 0x67,
 	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0xe9, 0x07, 0x20, 0x01,
 	0x28, 0x04, 0x52, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x12,
@@ -3192,57 +3192,56 @@ var file_proto_prysm_v1alpha1_beacon_state_proto_rawDesc = []byte{
 	0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f,
 	0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68,
 	0x52, 0x1a, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x76, 0x0a, 0x18,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x60, 0x0a, 0x10,
-	0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f,
+	0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73,
-	0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73, 0x18, 0xe7, 0x5d, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x18, 0xe7, 0x5d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
-	0x2c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
+	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42,
+	0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x42, 0x0d,
-	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x42, 0x0d, 0x92,
+	0x92, 0xb5, 0x18, 0x09, 0x31, 0x33, 0x34, 0x32, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52, 0x0f, 0x70,
-	0xb5, 0x18, 0x09, 0x31, 0x33, 0x34, 0x32, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52, 0x16, 0x70, 0x65,
+	0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73, 0x12, 0x7f,
-	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x70, 0x6f,
+	0x0a, 0x1b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61,
-	0x73, 0x69, 0x74, 0x73, 0x12, 0x7f, 0x0a, 0x1b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f,
+	0x6c, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x18, 0xe8, 0x5d,
-	0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
-	0x61, 0x6c, 0x73, 0x18, 0xe8, 0x5d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x65, 0x74, 0x68,
+	0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x6e,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x74, 0x68, 0x64,
-	0x61, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61,
+	0x72, 0x61, 0x77, 0x61, 0x6c, 0x42, 0x0d, 0x92, 0xb5, 0x18, 0x09, 0x31, 0x33, 0x34, 0x32, 0x31,
-	0x6c, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x42, 0x0d, 0x92, 0xb5, 0x18,
+	0x37, 0x37, 0x32, 0x38, 0x52, 0x19, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x72,
-	0x09, 0x31, 0x33, 0x34, 0x32, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52, 0x19, 0x70, 0x65, 0x6e, 0x64,
+	0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x12,
-	0x69, 0x6e, 0x67, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72,
+	0x6f, 0x0a, 0x16, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x6f,
-	0x61, 0x77, 0x61, 0x6c, 0x73, 0x12, 0x6f, 0x0a, 0x16, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe9, 0x5d, 0x20, 0x03, 0x28, 0x0b,
-	0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x32, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
-	0xe9, 0x5d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67,
-	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50,
+	0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0a, 0x92,
-	0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0xb5, 0x18, 0x06, 0x32, 0x36, 0x32, 0x31, 0x34, 0x34, 0x52, 0x15, 0x70, 0x65, 0x6e, 0x64, 0x69,
-	0x69, 0x6f, 0x6e, 0x42, 0x0a, 0x92, 0xb5, 0x18, 0x06, 0x32, 0x36, 0x32, 0x31, 0x34, 0x34, 0x52,
+	0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x15, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64,
+	0x22, 0x8d, 0x01, 0x0a, 0x08, 0x50, 0x6f, 0x77, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x25, 0x0a,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x8d, 0x01, 0x0a, 0x08, 0x50, 0x6f, 0x77, 0x42, 0x6c,
+	0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x6f, 0x63, 0x6b, 0x12, 0x25, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73,
+	0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52,
+	0x48, 0x61, 0x73, 0x68, 0x12, 0x27, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68,
-	0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x12, 0x27, 0x0a, 0x0b, 0x70, 0x61,
+	0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33,
-	0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42,
+	0x32, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x31, 0x0a,
-	0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48,
+	0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74,
-	0x61, 0x73, 0x68, 0x12, 0x31, 0x0a, 0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x66,
+	0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52,
-	0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
+	0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79,
-	0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66,
+	0x22, 0x7f, 0x0a, 0x11, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x53, 0x75,
-	0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x7f, 0x0a, 0x11, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72,
+	0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x34, 0x0a, 0x12, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x73,
-	0x69, 0x63, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x34, 0x0a, 0x12, 0x62,
+	0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x6f, 0x6f,
+	0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x10, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52,
+	0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x34, 0x0a, 0x12, 0x73,
-	0x10, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x6f, 0x6f,
+	0x74, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x6f, 0x6f,
-	0x74, 0x12, 0x34, 0x0a, 0x12, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61,
+	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52,
-	0x72, 0x79, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
+	0x10, 0x73, 0x74, 0x61, 0x74, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x6f, 0x6f,
-	0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x10, 0x73, 0x74, 0x61, 0x74, 0x65, 0x53, 0x75, 0x6d, 0x6d,
+	0x74, 0x42, 0x9b, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
-	0x61, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x42, 0x9b, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e,
+	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42,
-	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61,
+	0x10, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x10, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61,
+	0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75,
+	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
-	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c,
+	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79,
-	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f,
+	0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa,
-	0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56,
-	0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
+	0x31, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65,
-	0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x31, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15,
+	0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62,
-	0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -3285,7 +3284,7 @@ var file_proto_prysm_v1alpha1_beacon_state_proto_goTypes = []interface{}{
 	(*v1.ExecutionPayloadHeader)(nil),        // 23: ethereum.engine.v1.ExecutionPayloadHeader
 	(*v1.ExecutionPayloadHeaderCapella)(nil), // 24: ethereum.engine.v1.ExecutionPayloadHeaderCapella
 	(*v1.ExecutionPayloadHeaderDeneb)(nil),   // 25: ethereum.engine.v1.ExecutionPayloadHeaderDeneb
-	(*PendingBalanceDeposit)(nil),            // 26: ethereum.eth.v1alpha1.PendingBalanceDeposit
+	(*PendingDeposit)(nil),                   // 26: ethereum.eth.v1alpha1.PendingDeposit
 	(*PendingPartialWithdrawal)(nil),         // 27: ethereum.eth.v1alpha1.PendingPartialWithdrawal
 	(*PendingConsolidation)(nil),             // 28: ethereum.eth.v1alpha1.PendingConsolidation
 }
@@ -3359,7 +3358,7 @@ var file_proto_prysm_v1alpha1_beacon_state_proto_depIdxs = []int32{
 	10, // 66: ethereum.eth.v1alpha1.BeaconStateElectra.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	25, // 67: ethereum.eth.v1alpha1.BeaconStateElectra.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
 	17, // 68: ethereum.eth.v1alpha1.BeaconStateElectra.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
-	26, // 69: ethereum.eth.v1alpha1.BeaconStateElectra.pending_balance_deposits:type_name -> ethereum.eth.v1alpha1.PendingBalanceDeposit
+	26, // 69: ethereum.eth.v1alpha1.BeaconStateElectra.pending_deposits:type_name -> ethereum.eth.v1alpha1.PendingDeposit
 	27, // 70: ethereum.eth.v1alpha1.BeaconStateElectra.pending_partial_withdrawals:type_name -> ethereum.eth.v1alpha1.PendingPartialWithdrawal
 	28, // 71: ethereum.eth.v1alpha1.BeaconStateElectra.pending_consolidations:type_name -> ethereum.eth.v1alpha1.PendingConsolidation
 	72, // [72:72] is the sub-list for method output_type

proto/prysm/v1alpha1/beacon_state.proto

@@ -402,7 +402,7 @@ message BeaconStateElectra {
   uint64 earliest_exit_epoch = 12004 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Epoch"];
   uint64 consolidation_balance_to_consume = 12005 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Gwei"];
   uint64 earliest_consolidation_epoch = 12006 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Epoch"];
-  repeated PendingBalanceDeposit pending_balance_deposits = 12007 [(ethereum.eth.ext.ssz_max) = "pending_balance_deposits_limit"];
+  repeated PendingDeposit pending_deposits = 12007 [(ethereum.eth.ext.ssz_max) = "pending_deposits_limit"];
   repeated PendingPartialWithdrawal pending_partial_withdrawals = 12008 [(ethereum.eth.ext.ssz_max) = "pending_partial_withdrawals_limit"];
   repeated PendingConsolidation pending_consolidations = 12009 [(ethereum.eth.ext.ssz_max) = "pending_consolidations_limit"];
 }

proto/prysm/v1alpha1/cloners_test.go

@@ -1152,49 +1152,3 @@ func genConsolidationRequest() *enginev1.ConsolidationRequest {
 		TargetPubkey:  bytes(48),
 	}
 }
-
-func genPendingPartialWithdrawals(num int) []*v1alpha1.PendingPartialWithdrawal {
-	ppws := make([]*v1alpha1.PendingPartialWithdrawal, num)
-	for i := 0; i < num; i++ {
-		ppws[i] = genPendingPartialWithdrawal()
-	}
-	return ppws
-}
-
-func genPendingPartialWithdrawal() *v1alpha1.PendingPartialWithdrawal {
-	return &v1alpha1.PendingPartialWithdrawal{
-		Index:             123456,
-		Amount:            55555,
-		WithdrawableEpoch: 444444,
-	}
-}
-
-func genPendingConsolidations(num int) []*v1alpha1.PendingConsolidation {
-	pcs := make([]*v1alpha1.PendingConsolidation, num)
-	for i := 0; i < num; i++ {
-		pcs[i] = genPendingConsolidation()
-	}
-	return pcs
-}
-
-func genPendingConsolidation() *v1alpha1.PendingConsolidation {
-	return &v1alpha1.PendingConsolidation{
-		SourceIndex: 1,
-		TargetIndex: 2,
-	}
-}
-
-func genPendingBalanceDeposits(num int) []*v1alpha1.PendingBalanceDeposit {
-	pbds := make([]*v1alpha1.PendingBalanceDeposit, num)
-	for i := 0; i < num; i++ {
-		pbds[i] = genPendingBalanceDeposit()
-	}
-	return pbds
-}
-
-func genPendingBalanceDeposit() *v1alpha1.PendingBalanceDeposit {
-	return &v1alpha1.PendingBalanceDeposit{
-		Index:  123456,
-		Amount: 55555,
-	}
-}

proto/prysm/v1alpha1/eip_7251.pb.go

@@ -23,17 +23,20 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-type PendingBalanceDeposit struct {
+type PendingDeposit struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Index  github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"`
+	PublicKey             []byte                                                            `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty" spec-name:"pubkey" ssz-size:"48"`
-	Amount uint64                                                                      `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
+	WithdrawalCredentials []byte                                                            `protobuf:"bytes,2,opt,name=withdrawal_credentials,json=withdrawalCredentials,proto3" json:"withdrawal_credentials,omitempty" ssz-size:"32"`
+	Amount                uint64                                                            `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
+	Signature             []byte                                                            `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty" ssz-size:"96"`
+	Slot                  github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot `protobuf:"varint,5,opt,name=slot,proto3" json:"slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
 }
 
-func (x *PendingBalanceDeposit) Reset() {
+func (x *PendingDeposit) Reset() {
-	*x = PendingBalanceDeposit{}
+	*x = PendingDeposit{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_proto_prysm_v1alpha1_eip_7251_proto_msgTypes[0]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -41,13 +44,13 @@ func (x *PendingBalanceDeposit) Reset() {
 	}
 }
 
-func (x *PendingBalanceDeposit) String() string {
+func (x *PendingDeposit) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PendingBalanceDeposit) ProtoMessage() {}
+func (*PendingDeposit) ProtoMessage() {}
 
-func (x *PendingBalanceDeposit) ProtoReflect() protoreflect.Message {
+func (x *PendingDeposit) ProtoReflect() protoreflect.Message {
 	mi := &file_proto_prysm_v1alpha1_eip_7251_proto_msgTypes[0]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -59,25 +62,46 @@ func (x *PendingBalanceDeposit) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use PendingBalanceDeposit.ProtoReflect.Descriptor instead.
+// Deprecated: Use PendingDeposit.ProtoReflect.Descriptor instead.
-func (*PendingBalanceDeposit) Descriptor() ([]byte, []int) {
+func (*PendingDeposit) Descriptor() ([]byte, []int) {
 	return file_proto_prysm_v1alpha1_eip_7251_proto_rawDescGZIP(), []int{0}
 }
 
-func (x *PendingBalanceDeposit) GetIndex() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex {
+func (x *PendingDeposit) GetPublicKey() []byte {
 	if x != nil {
-		return x.Index
+		return x.PublicKey
 	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex(0)
+	return nil
 }
 
-func (x *PendingBalanceDeposit) GetAmount() uint64 {
+func (x *PendingDeposit) GetWithdrawalCredentials() []byte {
+	if x != nil {
+		return x.WithdrawalCredentials
+	}
+	return nil
+}
+
+func (x *PendingDeposit) GetAmount() uint64 {
 	if x != nil {
 		return x.Amount
 	}
 	return 0
 }
 
+func (x *PendingDeposit) GetSignature() []byte {
+	if x != nil {
+		return x.Signature
+	}
+	return nil
+}
+
+func (x *PendingDeposit) GetSlot() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot {
+	if x != nil {
+		return x.Slot
+	}
+	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
+}
+
 type PendingPartialWithdrawal struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -204,60 +228,68 @@ var file_proto_prysm_v1alpha1_eip_7251_proto_rawDesc = []byte{
 	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
 	0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x1b, 0x70, 0x72,
 	0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x65, 0x78, 0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x96, 0x01, 0x0a, 0x15, 0x50, 0x65,
+	0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x99, 0x02, 0x0a, 0x0e, 0x50, 0x65,
-	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x70, 0x6f,
+	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, 0x2f, 0x0a, 0x0a,
-	0x73, 0x69, 0x74, 0x12, 0x65, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
-	0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
+	0x42, 0x10, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x9a, 0xb5, 0x18, 0x06, 0x70, 0x75, 0x62, 0x6b,
-	0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73,
+	0x65, 0x79, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x3d, 0x0a,
-	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e,
+	0x16, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x5f, 0x63, 0x72, 0x65, 0x64,
-	0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74,
+	0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
-	0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e,
+	0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x15, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61,
-	0x64, 0x65, 0x78, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d,
+	0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x12, 0x16, 0x0a, 0x06,
-	0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75,
+	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d,
-	0x6e, 0x74, 0x22, 0x90, 0x02, 0x0a, 0x18, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61,
+	0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
-	0x72, 0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x12,
+	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x39, 0x36, 0x52,
-	0x65, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x4f,
+	0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x59, 0x0a, 0x04, 0x73, 0x6c,
-	0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70,
+	0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69,
-	0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79,
-	0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d,
-	0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73,
-	0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52,
-	0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x75,
-	0x0a, 0x12, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x65,
-	0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x46, 0x82, 0xb5, 0x18, 0x42,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
-	0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76,
-	0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65,
-	0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x45, 0x70, 0x6f,
-	0x63, 0x68, 0x52, 0x11, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x62, 0x6c, 0x65,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x22, 0xfe, 0x01, 0x0a, 0x14, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e,
-	0x67, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x72,
-	0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61,
-	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73,
-	0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d,
-	0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
-	0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x64,
-	0x65, 0x78, 0x12, 0x72, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x6e, 0x64,
-	0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69,
 	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74,
 	0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f,
 	0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f,
-	0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52,
-	0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65,
+	0x04, 0x73, 0x6c, 0x6f, 0x74, 0x22, 0x90, 0x02, 0x0a, 0x18, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e,
-	0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x97, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65,
+	0x67, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x61, 0x6c, 0x12, 0x65, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x70, 0x68, 0x61, 0x31, 0x42, 0x0c, 0x45, 0x49, 0x50, 0x37, 0x32, 0x35, 0x31, 0x50, 0x72, 0x6f,
+	0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
-	0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
+	0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f,
-	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70,
+	0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73,
-	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72,
+	0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69,
-	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68,
+	0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64,
-	0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e,
+	0x65, 0x78, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f,
-	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72,
+	0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
-	0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+	0x74, 0x12, 0x75, 0x0a, 0x12, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x62, 0x6c,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x65, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x46, 0x82,
+	0xb5, 0x18, 0x42, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72,
+	0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73,
+	0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74,
+	0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e,
+	0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x11, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61,
+	0x62, 0x6c, 0x65, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x22, 0xfe, 0x01, 0x0a, 0x14, 0x50, 0x65, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x72, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65,
+	0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69,
+	0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63,
+	0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70,
+	0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
+	0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x72, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f,
+	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18,
+	0x4b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73,
+	0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f,
+	0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70,
+	0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0b, 0x74, 0x61,
+	0x72, 0x67, 0x65, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x97, 0x01, 0x0a, 0x19, 0x6f, 0x72,
+	0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x0c, 0x45, 0x49, 0x50, 0x37, 0x32, 0x35, 0x31,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
+	0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62,
+	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b,
+	0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45,
+	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70,
+	0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -274,7 +306,7 @@ func file_proto_prysm_v1alpha1_eip_7251_proto_rawDescGZIP() []byte {
 
 var file_proto_prysm_v1alpha1_eip_7251_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
 var file_proto_prysm_v1alpha1_eip_7251_proto_goTypes = []interface{}{
-	(*PendingBalanceDeposit)(nil),    // 0: ethereum.eth.v1alpha1.PendingBalanceDeposit
+	(*PendingDeposit)(nil),           // 0: ethereum.eth.v1alpha1.PendingDeposit
 	(*PendingPartialWithdrawal)(nil), // 1: ethereum.eth.v1alpha1.PendingPartialWithdrawal
 	(*PendingConsolidation)(nil),     // 2: ethereum.eth.v1alpha1.PendingConsolidation
 }
@@ -293,7 +325,7 @@ func file_proto_prysm_v1alpha1_eip_7251_proto_init() {
 	}
 	if !protoimpl.UnsafeEnabled {
 		file_proto_prysm_v1alpha1_eip_7251_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PendingBalanceDeposit); i {
+			switch v := v.(*PendingDeposit); i {
 			case 0:
 				return &v.state
 			case 1:

proto/prysm/v1alpha1/eip_7251.proto

@@ -24,12 +24,18 @@ option java_outer_classname = "EIP7251Proto";
 option java_package = "org.ethereum.eth.v1alpha1";
 option php_namespace = "Ethereum\\Eth\\v1alpha1";
 
-message PendingBalanceDeposit {
+message PendingDeposit {
-    // Validator index for the deposit.
+    // 48 byte BLS public key of the validator.
-    uint64 index = 1 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"];
+    bytes public_key = 1 [(ethereum.eth.ext.ssz_size) = "48", (ethereum.eth.ext.spec_name) = "pubkey"];
+
+    // A 32 byte hash of the withdrawal address public key.
+    bytes withdrawal_credentials = 2 [(ethereum.eth.ext.ssz_size) = "32"];
 
     // The amount of the deposit (gwei).
-    uint64 amount = 2;
+    uint64 amount = 3;
+    // 96 byte BLS signature from the validator that produced this block.
+    bytes signature = 4 [(ethereum.eth.ext.ssz_size) = "96"];
+    uint64 slot = 5 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
 }
 
 message PendingPartialWithdrawal {

proto/prysm/v1alpha1/eip_7521.go

@@ -1,5 +1,21 @@
 package eth
 
+import "github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+
+// Copy --
+func (pd *PendingDeposit) Copy() *PendingDeposit {
+	if pd == nil {
+		return nil
+	}
+	return &PendingDeposit{
+		PublicKey:             bytesutil.SafeCopyBytes(pd.PublicKey),
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(pd.WithdrawalCredentials),
+		Amount:                pd.Amount,
+		Signature:             bytesutil.SafeCopyBytes(pd.Signature),
+		Slot:                  pd.Slot,
+	}
+}
+
 // Copy --
 func (pw *PendingPartialWithdrawal) Copy() *PendingPartialWithdrawal {
 	if pw == nil {

proto/prysm/v1alpha1/eip_7521_fuzz_test.go

@@ -7,6 +7,7 @@ import (
 )
 
 func TestCopyEip7521Types_Fuzz(t *testing.T) {
+	fuzzCopies(t, &eth.PendingDeposit{})
 	fuzzCopies(t, &eth.PendingPartialWithdrawal{})
 	fuzzCopies(t, &eth.PendingConsolidation{})
 }

proto/prysm/v1alpha1/electra.ssz.go

@@ -3083,9 +3083,9 @@ func (b *BeaconStateElectra) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	// Field (33) 'EarliestConsolidationEpoch'
 	dst = ssz.MarshalUint64(dst, uint64(b.EarliestConsolidationEpoch))
 
-	// Offset (34) 'PendingBalanceDeposits'
+	// Offset (34) 'PendingDeposits'
 	dst = ssz.WriteOffset(dst, offset)
-	offset += len(b.PendingBalanceDeposits) * 16
+	offset += len(b.PendingDeposits) * 192
 
 	// Offset (35) 'PendingPartialWithdrawals'
 	dst = ssz.WriteOffset(dst, offset)
@@ -3178,13 +3178,13 @@ func (b *BeaconStateElectra) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		}
 	}
 
-	// Field (34) 'PendingBalanceDeposits'
+	// Field (34) 'PendingDeposits'
-	if size := len(b.PendingBalanceDeposits); size > 134217728 {
+	if size := len(b.PendingDeposits); size > 134217728 {
-		err = ssz.ErrListTooBigFn("--.PendingBalanceDeposits", size, 134217728)
+		err = ssz.ErrListTooBigFn("--.PendingDeposits", size, 134217728)
 		return
 	}
-	for ii := 0; ii < len(b.PendingBalanceDeposits); ii++ {
+	for ii := 0; ii < len(b.PendingDeposits); ii++ {
-		if dst, err = b.PendingBalanceDeposits[ii].MarshalSSZTo(dst); err != nil {
+		if dst, err = b.PendingDeposits[ii].MarshalSSZTo(dst); err != nil {
 			return
 		}
 	}
@@ -3416,7 +3416,7 @@ func (b *BeaconStateElectra) UnmarshalSSZ(buf []byte) error {
 	// Field (33) 'EarliestConsolidationEpoch'
 	b.EarliestConsolidationEpoch = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736693:2736701]))
 
-	// Offset (34) 'PendingBalanceDeposits'
+	// Offset (34) 'PendingDeposits'
 	if o34 = ssz.ReadOffset(buf[2736701:2736705]); o34 > size || o27 > o34 {
 		return ssz.ErrOffset
 	}
@@ -3562,19 +3562,19 @@ func (b *BeaconStateElectra) UnmarshalSSZ(buf []byte) error {
 		}
 	}
 
-	// Field (34) 'PendingBalanceDeposits'
+	// Field (34) 'PendingDeposits'
 	{
 		buf = tail[o34:o35]
-		num, err := ssz.DivideInt2(len(buf), 16, 134217728)
+		num, err := ssz.DivideInt2(len(buf), 192, 134217728)
 		if err != nil {
 			return err
 		}
-		b.PendingBalanceDeposits = make([]*PendingBalanceDeposit, num)
+		b.PendingDeposits = make([]*PendingDeposit, num)
 		for ii := 0; ii < num; ii++ {
-			if b.PendingBalanceDeposits[ii] == nil {
+			if b.PendingDeposits[ii] == nil {
-				b.PendingBalanceDeposits[ii] = new(PendingBalanceDeposit)
+				b.PendingDeposits[ii] = new(PendingDeposit)
 			}
-			if err = b.PendingBalanceDeposits[ii].UnmarshalSSZ(buf[ii*16 : (ii+1)*16]); err != nil {
+			if err = b.PendingDeposits[ii].UnmarshalSSZ(buf[ii*192 : (ii+1)*192]); err != nil {
 				return err
 			}
 		}
@@ -3652,8 +3652,8 @@ func (b *BeaconStateElectra) SizeSSZ() (size int) {
 	// Field (27) 'HistoricalSummaries'
 	size += len(b.HistoricalSummaries) * 64
 
-	// Field (34) 'PendingBalanceDeposits'
+	// Field (34) 'PendingDeposits'
-	size += len(b.PendingBalanceDeposits) * 16
+	size += len(b.PendingDeposits) * 192
 
 	// Field (35) 'PendingPartialWithdrawals'
 	size += len(b.PendingPartialWithdrawals) * 24
@@ -3952,15 +3952,15 @@ func (b *BeaconStateElectra) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	// Field (33) 'EarliestConsolidationEpoch'
 	hh.PutUint64(uint64(b.EarliestConsolidationEpoch))
 
-	// Field (34) 'PendingBalanceDeposits'
+	// Field (34) 'PendingDeposits'
 	{
 		subIndx := hh.Index()
-		num := uint64(len(b.PendingBalanceDeposits))
+		num := uint64(len(b.PendingDeposits))
 		if num > 134217728 {
 			err = ssz.ErrIncorrectListSize
 			return
 		}
-		for _, elem := range b.PendingBalanceDeposits {
+		for _, elem := range b.PendingDeposits {
 			if err = elem.HashTreeRootWith(hh); err != nil {
 				return
 			}
@@ -4004,62 +4004,122 @@ func (b *BeaconStateElectra) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	return
 }
 
-// MarshalSSZ ssz marshals the PendingBalanceDeposit object
+// MarshalSSZ ssz marshals the PendingDeposit object
-func (p *PendingBalanceDeposit) MarshalSSZ() ([]byte, error) {
+func (p *PendingDeposit) MarshalSSZ() ([]byte, error) {
 	return ssz.MarshalSSZ(p)
 }
 
-// MarshalSSZTo ssz marshals the PendingBalanceDeposit object to a target array
+// MarshalSSZTo ssz marshals the PendingDeposit object to a target array
-func (p *PendingBalanceDeposit) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+func (p *PendingDeposit) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
 
-	// Field (0) 'Index'
+	// Field (0) 'PublicKey'
-	dst = ssz.MarshalUint64(dst, uint64(p.Index))
+	if size := len(p.PublicKey); size != 48 {
+		err = ssz.ErrBytesLengthFn("--.PublicKey", size, 48)
+		return
+	}
+	dst = append(dst, p.PublicKey...)
 
-	// Field (1) 'Amount'
+	// Field (1) 'WithdrawalCredentials'
+	if size := len(p.WithdrawalCredentials); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.WithdrawalCredentials", size, 32)
+		return
+	}
+	dst = append(dst, p.WithdrawalCredentials...)
+
+	// Field (2) 'Amount'
 	dst = ssz.MarshalUint64(dst, p.Amount)
 
+	// Field (3) 'Signature'
+	if size := len(p.Signature); size != 96 {
+		err = ssz.ErrBytesLengthFn("--.Signature", size, 96)
+		return
+	}
+	dst = append(dst, p.Signature...)
+
+	// Field (4) 'Slot'
+	dst = ssz.MarshalUint64(dst, uint64(p.Slot))
+
 	return
 }
 
-// UnmarshalSSZ ssz unmarshals the PendingBalanceDeposit object
+// UnmarshalSSZ ssz unmarshals the PendingDeposit object
-func (p *PendingBalanceDeposit) UnmarshalSSZ(buf []byte) error {
+func (p *PendingDeposit) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size != 16 {
+	if size != 192 {
 		return ssz.ErrSize
 	}
 
-	// Field (0) 'Index'
+	// Field (0) 'PublicKey'
-	p.Index = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	if cap(p.PublicKey) == 0 {
+		p.PublicKey = make([]byte, 0, len(buf[0:48]))
+	}
+	p.PublicKey = append(p.PublicKey, buf[0:48]...)
 
-	// Field (1) 'Amount'
+	// Field (1) 'WithdrawalCredentials'
-	p.Amount = ssz.UnmarshallUint64(buf[8:16])
+	if cap(p.WithdrawalCredentials) == 0 {
+		p.WithdrawalCredentials = make([]byte, 0, len(buf[48:80]))
+	}
+	p.WithdrawalCredentials = append(p.WithdrawalCredentials, buf[48:80]...)
+
+	// Field (2) 'Amount'
+	p.Amount = ssz.UnmarshallUint64(buf[80:88])
+
+	// Field (3) 'Signature'
+	if cap(p.Signature) == 0 {
+		p.Signature = make([]byte, 0, len(buf[88:184]))
+	}
+	p.Signature = append(p.Signature, buf[88:184]...)
+
+	// Field (4) 'Slot'
+	p.Slot = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[184:192]))
 
 	return err
 }
 
-// SizeSSZ returns the ssz encoded size in bytes for the PendingBalanceDeposit object
+// SizeSSZ returns the ssz encoded size in bytes for the PendingDeposit object
-func (p *PendingBalanceDeposit) SizeSSZ() (size int) {
+func (p *PendingDeposit) SizeSSZ() (size int) {
-	size = 16
+	size = 192
 	return
 }
 
-// HashTreeRoot ssz hashes the PendingBalanceDeposit object
+// HashTreeRoot ssz hashes the PendingDeposit object
-func (p *PendingBalanceDeposit) HashTreeRoot() ([32]byte, error) {
+func (p *PendingDeposit) HashTreeRoot() ([32]byte, error) {
 	return ssz.HashWithDefaultHasher(p)
 }
 
-// HashTreeRootWith ssz hashes the PendingBalanceDeposit object with a hasher
+// HashTreeRootWith ssz hashes the PendingDeposit object with a hasher
-func (p *PendingBalanceDeposit) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+func (p *PendingDeposit) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	indx := hh.Index()
 
-	// Field (0) 'Index'
+	// Field (0) 'PublicKey'
-	hh.PutUint64(uint64(p.Index))
+	if size := len(p.PublicKey); size != 48 {
+		err = ssz.ErrBytesLengthFn("--.PublicKey", size, 48)
+		return
+	}
+	hh.PutBytes(p.PublicKey)
 
-	// Field (1) 'Amount'
+	// Field (1) 'WithdrawalCredentials'
+	if size := len(p.WithdrawalCredentials); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.WithdrawalCredentials", size, 32)
+		return
+	}
+	hh.PutBytes(p.WithdrawalCredentials)
+
+	// Field (2) 'Amount'
 	hh.PutUint64(p.Amount)
 
+	// Field (3) 'Signature'
+	if size := len(p.Signature); size != 96 {
+		err = ssz.ErrBytesLengthFn("--.Signature", size, 96)
+		return
+	}
+	hh.PutBytes(p.Signature)
+
+	// Field (4) 'Slot'
+	hh.PutUint64(uint64(p.Slot))
+
 	hh.Merkleize(indx)
 	return
 }

proto/ssz_proto_library.bzl

@@ -32,7 +32,7 @@ mainnet = {
     "max_committees_per_slot.size": "64",
     "committee_bits.size": "8",
     "committee_bits.type": "github.com/prysmaticlabs/go-bitfield.Bitvector64",
-    "pending_balance_deposits_limit": "134217728",
+    "pending_deposits_limit": "134217728",
     "pending_partial_withdrawals_limit": "134217728",
     "pending_consolidations_limit": "262144",
     "max_consolidation_requests_per_payload.size": "1",
@@ -64,7 +64,7 @@ minimal = {
     "max_committees_per_slot.size": "4",
     "committee_bits.size": "1",
     "committee_bits.type": "github.com/prysmaticlabs/go-bitfield.Bitvector4",
-    "pending_balance_deposits_limit": "134217728",
+    "pending_deposits_limit": "134217728",
     "pending_partial_withdrawals_limit": "64",
     "pending_consolidations_limit": "64",
     "max_consolidation_requests_per_payload.size": "1",

testing/spectest/mainnet/electra/epoch_processing/BUILD.bazel

@@ -9,8 +9,8 @@ go_test(
         "inactivity_updates_test.go",
         "justification_and_finalization_test.go",
         "participation_flag_updates_test.go",
-        "pending_balance_updates_test.go",
         "pending_consolidations_test.go",
+        "pending_deposits_updates_test.go",
         "randao_mixes_reset_test.go",
         "registry_updates_test.go",
         "rewards_and_penalties_test.go",

testing/spectest/mainnet/electra/epoch_processing/pending_balance_updates_test.go

@@ -1,11 +0,0 @@
-package epoch_processing
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/epoch_processing"
-)
-
-func TestMainnet_Electra_EpochProcessing_PendingBalanceDeposits(t *testing.T) {
-	epoch_processing.RunPendingBalanceDepositsTests(t, "mainnet")
-}

testing/spectest/mainnet/electra/epoch_processing/pending_deposits_updates_test.go

@@ -0,0 +1,11 @@
+package epoch_processing
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/epoch_processing"
+)
+
+func TestMainnet_Electra_EpochProcessing_PendingDeposits(t *testing.T) {
+	epoch_processing.RunPendingDepositsTests(t, "mainnet")
+}

testing/spectest/minimal/electra/epoch_processing/BUILD.bazel

@@ -9,8 +9,8 @@ go_test(
         "inactivity_updates_test.go",
         "justification_and_finalization_test.go",
         "participation_flag_updates_test.go",
-        "pending_balance_updates_test.go",
         "pending_consolidations_test.go",
+        "pending_deposits_updates_test.go",
         "randao_mixes_reset_test.go",
         "registry_updates_test.go",
         "rewards_and_penalties_test.go",

testing/spectest/minimal/electra/epoch_processing/pending_balance_updates_test.go

@@ -1,11 +0,0 @@
-package epoch_processing
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/epoch_processing"
-)
-
-func TestMinimal_Electra_EpochProcessing_PendingBalanceDeposits(t *testing.T) {
-	epoch_processing.RunPendingBalanceDepositsTests(t, "minimal")
-}

testing/spectest/minimal/electra/epoch_processing/pending_deposits_updates_test.go

@@ -0,0 +1,11 @@
+package epoch_processing
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/epoch_processing"
+)
+
+func TestMinimal_Electra_EpochProcessing_PendingDeposits(t *testing.T) {
+	epoch_processing.RunPendingDepositsTests(t, "minimal")
+}

testing/spectest/shared/electra/epoch_processing/BUILD.bazel

@@ -11,8 +11,8 @@ go_library(
         "inactivity_updates.go",
         "justification_and_finalization.go",
         "participation_flag_updates.go",
-        "pending_balance_updates.go",
         "pending_consolidations.go",
+        "pending_deposit_updates.go",
         "randao_mixes_reset.go",
         "registry_updates.go",
         "rewards_and_penalties.go",

testing/spectest/shared/electra/epoch_processing/pending_deposit_updates.go

@@ -13,23 +13,23 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
 )
 
-func RunPendingBalanceDepositsTests(t *testing.T, config string) {
+func RunPendingDepositsTests(t *testing.T, config string) {
 	require.NoError(t, utils.SetConfig(t, config))
 
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "electra", "epoch_processing/pending_balance_deposits/pyspec_tests")
+	testFolders, testsFolderPath := utils.TestFolders(t, config, "electra", "epoch_processing/pending_deposits/pyspec_tests")
 	for _, folder := range testFolders {
 		t.Run(folder.Name(), func(t *testing.T) {
 			folderPath := path.Join(testsFolderPath, folder.Name())
-			RunEpochOperationTest(t, folderPath, processPendingBalanceDeposits)
+			RunEpochOperationTest(t, folderPath, processPendingDeposits)
 		})
 	}
 }
 
-func processPendingBalanceDeposits(t *testing.T, st state.BeaconState) (state.BeaconState, error) {
+func processPendingDeposits(t *testing.T, st state.BeaconState) (state.BeaconState, error) {
 	// The caller of this method would normally have the precompute balance values for total
 	// active balance for this epoch. For ease of test setup, we will compute total active
 	// balance from the given state.
 	tab, err := helpers.TotalActiveBalance(st)
 	require.NoError(t, err)
-	return st, electra.ProcessPendingBalanceDeposits(context.TODO(), st, primitives.Gwei(tab))
+	return st, electra.ProcessPendingDeposits(context.TODO(), st, primitives.Gwei(tab))
 }

testing/spectest/shared/electra/ssz_static/ssz_static.go

@@ -141,8 +141,8 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 		obj = &ethpb.BLSToExecutionChange{}
 	case "SignedBLSToExecutionChange":
 		obj = &ethpb.SignedBLSToExecutionChange{}
-	case "PendingBalanceDeposit":
+	case "PendingDeposit":
-		obj = &ethpb.PendingBalanceDeposit{}
+		obj = &ethpb.PendingDeposit{}
 	case "PendingPartialWithdrawal":
 		obj = &ethpb.PendingPartialWithdrawal{}
 	case "PendingConsolidation":

testing/util/electra_state.go

@@ -209,7 +209,7 @@ func buildGenesisBeaconStateElectra(genesisTime uint64, preState state.BeaconSta
 		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(primitives.Gwei(tab)),
 		EarliestConsolidationEpoch:    helpers.ActivationExitEpoch(slots.ToEpoch(preState.Slot())),
 		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(primitives.Gwei(tab)),
-		PendingBalanceDeposits:        make([]*ethpb.PendingBalanceDeposit, 0),
+		PendingDeposits:               make([]*ethpb.PendingDeposit, 0),
 		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
 		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
 	}