Add mekong testnet config

* fix endpoint

* changelog + gaz

* add to endpoints test

* Radek' review

* James' review

* fix duplication a bit

* fix changelog

CHANGELOG.md

@@ -4,7 +4,55 @@ All notable changes to this project will be documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
-## [Unreleased](https://github.com/prysmaticlabs/prysm/compare/v5.1.0...HEAD)
+## [Unreleased](https://github.com/prysmaticlabs/prysm/compare/v5.1.1...HEAD)
+
+### Added
+
+- Electra EIP6110: Queue deposit [pr](https://github.com/prysmaticlabs/prysm/pull/14430)
+- Add Bellatrix tests for light client functions.
+- Add Discovery Rebooter Feature.
+- Added GetBlockAttestationsV2 endpoint.
+- Light client support: Consensus types for Electra
+- Added SubmitPoolAttesterSlashingV2 endpoint.
+- Added SubmitAggregateAndProofsRequestV2 endpoint.
+
+### Changed
+
+- Electra EIP6110: Queue deposit requests changes from consensus spec pr #3818
+- reversed the boolean return on `BatchVerifyDepositsSignatures`, from need verification, to all keys successfully verified
+- Fix `engine_exchangeCapabilities` implementation.
+- Updated the default `scrape-interval` in `Client-stats` to 2 minutes to accommodate Beaconcha.in API rate limits.
+- Switch to compounding when consolidating with source==target.
+
+### Deprecated
+
+- `/eth/v1alpha1/validator/activation/stream` grpc wait for activation stream is deprecated. [pr](https://github.com/prysmaticlabs/prysm/pull/14514)
+
+### Removed
+
+- Removed finalized validator index cache, no longer needed.
+
+### Fixed
+
+- Fixed mesh size by appending `gParams.Dhi = gossipSubDhi`
+- Fix skipping partial withdrawals count.
+- recover from panics when writing the event stream [pr](https://github.com/prysmaticlabs/prysm/pull/14545)
+
+### Security
+
+
+## [v5.1.1](https://github.com/prysmaticlabs/prysm/compare/v5.1.0...v5.1.1) - 2024-10-15
+
+This release has a number of features and improvements. Most notably, the feature flag 
+`--enable-experimental-state` has been flipped to "opt out" via `--disable-experimental-state`. 
+The experimental state management design has shown significant improvements in memory usage at
+runtime. Updates to libp2p's gossipsub have some bandwidith stability improvements with support for
+IDONTWANT control messages. 
+
+The gRPC gateway has been deprecated from Prysm in this release. If you need JSON data, consider the
+standardized beacon-APIs. 
+
+Updating to this release is recommended at your convenience.
 
 ### Added
 
@@ -18,14 +66,13 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - 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.
+- `engine_newPayloadV4`,`engine_getPayloadV4` used for electra payload communication with execution client.  [pr](https://github.com/prysmaticlabs/prysm/pull/14492)
 - HTTP endpoint for PublishBlobs.
 - GetBlockV2, GetBlindedBlock, ProduceBlockV2, ProduceBlockV3: add Electra case.
 - Add Electra support and tests for light client functions.
 - fastssz version bump (better error messages).
 - SSE implementation that sheds stuck clients. [pr](https://github.com/prysmaticlabs/prysm/pull/14413)
-- Add Bellatrix tests for light client functions.
-- Add Discovery Rebooter Feature.
-- Added GetBlockAttestationsV2 endpoint.
+- Added GetPoolAttesterSlashingsV2 endpoint.
 
 ### Changed
 
@@ -55,6 +102,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Updated Sepolia bootnodes.
 - Make committee aware packing the default by deprecating `--enable-committee-aware-packing`.
 - Moved `ConvertKzgCommitmentToVersionedHash` to the `primitives` package.
+- Updated correlation penalty for EIP-7251. 
 
 ### Deprecated
 - `--disable-grpc-gateway` flag is deprecated due to grpc gateway removal.
@@ -62,9 +110,10 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 
 ### Removed
 
-- removed gRPC Gateway
-- Removed unused blobs bundle cache
+- Removed gRPC Gateway.
+- Removed unused blobs bundle cache.
 - Removed consolidation signing domain from params. The Electra design changed such that EL handles consolidation signature verification.
+- Remove engine_getPayloadBodiesBy{Hash|Range}V2
 
 ### Fixed
 
@@ -83,10 +132,11 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Light client support: fix light client attested header execution fields' wrong version bug.
 - Testing: added custom matcher for better push settings testing.
 - Registered `GetDepositSnapshot` Beacon API endpoint.
-- Fixed mesh size by appending `gParams.Dhi = gossipSubDhi`
 
 ### Security
 
+No notable security updates.
+
 ## [v5.1.0](https://github.com/prysmaticlabs/prysm/compare/v5.0.4...v5.1.0) - 2024-08-20
 
 This release contains 171 new changes and many of these are related to Electra! Along side the Electra changes, there

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.8"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-M7u/Ot/Vzorww+dFbHp0cxLyM2mezJjijCzq+LY3uvs=",
+    integrity = "sha256-BsGIbEyJuYrzhShGl0tHhR4lP5Qwno8R3k8a6YBR/DA=",
     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-DkdvhPP2KiqUOpwFXQIFDCWCwsUDIC/xhTBD+TZevm0=",
     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-vkZqV0HB8A2Uc56C1Us/p5G57iaHL+zw2No93Xt6M/4=",
     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-D/HPAW61lKqjoWwl7N0XvhdX+67dCEFAy8JxVzqBGtU=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -358,6 +358,22 @@ filegroup(
     url = "https://github.com/eth-clients/sepolia/archive/f2c219a93c4491cee3d90c18f2f8e82aed850eab.tar.gz",  # 2024-09-19
 )
 
+http_archive(
+    name = "mekong_testnet",
+    build_file_content = """
+filegroup(
+    name = "configs",
+    srcs = [
+        "network-configs/devnet-0/metadata/config.yaml",
+    ],
+    visibility = ["//visibility:public"],
+)
+""",
+    integrity = "sha256-y8id4VtAmk+geH52V77+UjR4NCTmGzXdtGpAUMkwvPM=",
+    strip_prefix = "mekong-devnets-c144c729c3cb898e1d6bb299d42eeb595809252c",
+    url = "https://github.com/ethpandaops/mekong-devnets/archive/c144c729c3cb898e1d6bb299d42eeb595809252c.tar.gz",  # 2024-11-07
+)
+
 http_archive(
     name = "com_google_protobuf",
     sha256 = "9bd87b8280ef720d3240514f884e56a712f2218f0d693b48050c836028940a42",

api/server/structs/conversions.go

@@ -1476,12 +1476,15 @@ func DepositSnapshotFromConsensus(ds *eth.DepositSnapshot) *DepositSnapshot {
 	}
 }
 
-func PendingBalanceDepositsFromConsensus(ds []*eth.PendingBalanceDeposit) []*PendingBalanceDeposit {
-	deposits := make([]*PendingBalanceDeposit, len(ds))
+func PendingDepositsFromConsensus(ds []*eth.PendingDeposit) []*PendingDeposit {
+	deposits := make([]*PendingDeposit, len(ds))
 	for i, d := range ds {
-		deposits[i] = &PendingBalanceDeposit{
-			Index:  fmt.Sprintf("%d", d.Index),
-			Amount: fmt.Sprintf("%d", d.Amount),
+		deposits[i] = &PendingDeposit{
+			Pubkey:                hexutil.Encode(d.PublicKey),
+			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/endpoints_beacon.go

@@ -176,7 +176,8 @@ type BLSToExecutionChangesPoolResponse struct {
 }
 
 type GetAttesterSlashingsResponse struct {
-	Data []*AttesterSlashing `json:"data"`
+	Version string          `json:"version,omitempty"`
+	Data    json.RawMessage `json:"data"` // Accepts both `[]*AttesterSlashing` and `[]*AttesterSlashingElectra` types
 }
 
 type GetProposerSlashingsResponse struct {

api/server/structs/endpoints_validator.go

@@ -15,7 +15,7 @@ type SubmitContributionAndProofsRequest struct {
 }
 
 type SubmitAggregateAndProofsRequest struct {
-	Data []*SignedAggregateAttestationAndProof `json:"data"`
+	Data []json.RawMessage `json:"data"`
 }
 
 type SubmitSyncCommitteeSubscriptionsRequest struct {

api/server/structs/other.go

@@ -257,9 +257,12 @@ type ConsolidationRequest struct {
 	TargetPubkey  string `json:"target_pubkey"`
 }
 
-type PendingBalanceDeposit struct {
-	Index  string `json:"index"`
-	Amount string `json:"amount"`
+type PendingDeposit struct {
+	Pubkey                string `json:"pubkey"`
+	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/blockchain/execution_engine.go

@@ -216,17 +216,25 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 	}
 
 	var lastValidHash []byte
+	var parentRoot *common.Hash
+	var versionedHashes []common.Hash
+	var requests *enginev1.ExecutionRequests
 	if blk.Version() >= version.Deneb {
-		var versionedHashes []common.Hash
 		versionedHashes, err = kzgCommitmentsToVersionedHashes(blk.Block().Body())
 		if err != nil {
 			return false, errors.Wrap(err, "could not get versioned hashes to feed the engine")
 		}
-		pr := common.Hash(blk.Block().ParentRoot())
-		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr)
-	} else {
-		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, []common.Hash{}, &common.Hash{} /*empty version hashes and root before Deneb*/)
+		prh := common.Hash(blk.Block().ParentRoot())
+		parentRoot = &prh
 	}
+	if blk.Version() >= version.Electra {
+		requests, err = blk.Block().Body().ExecutionRequests()
+		if err != nil {
+			return false, errors.Wrap(err, "could not get execution requests")
+		}
+	}
+	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests)
+
 	switch {
 	case err == nil:
 		newPayloadValidNodeCount.Inc()

beacon-chain/blockchain/receive_block.go

@@ -273,7 +273,6 @@ func (s *Service) reportPostBlockProcessing(
 func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {
 	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	go func() {
-		finalizedState.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
 		s.sendNewFinalizedEvent(ctx, finalizedState)
 	}()
 	depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)

beacon-chain/blockchain/service.go

@@ -329,8 +329,6 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
-	saved.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
-
 	return nil
 }
 

beacon-chain/core/altair/deposit.go

@@ -37,7 +37,7 @@ func ProcessDeposits(
 	beaconState state.BeaconState,
 	deposits []*ethpb.Deposit,
 ) (state.BeaconState, error) {
-	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -46,7 +46,7 @@ func ProcessDeposits(
 		if deposit == nil || deposit.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, err = ProcessDeposit(beaconState, deposit, batchVerified)
+		beaconState, err = ProcessDeposit(beaconState, deposit, allSignaturesVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
 		}
@@ -81,7 +81,7 @@ func ProcessDeposits(
 //	  amount=deposit.data.amount,
 //	  signature=deposit.data.signature,
 //	 )
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
 	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
@@ -92,7 +92,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 		return nil, err
 	}
 
-	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
+	return ApplyDeposit(beaconState, deposit.Data, allSignaturesVerified)
 }
 
 // ApplyDeposit
@@ -115,13 +115,13 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 //	    # Increase balance by deposit amount
 //	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
 //	    increase_balance(state, index, amount)
-func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSignaturesVerified bool) (state.BeaconState, error) {
 	pubKey := data.PublicKey
 	amount := data.Amount
 	withdrawalCredentials := data.WithdrawalCredentials
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
-		if verifySignature {
+		if !allSignaturesVerified {
 			valid, err := blocks.IsValidDepositSignature(data)
 			if err != nil {
 				return nil, err

beacon-chain/core/altair/deposit_test.go

@@ -199,7 +199,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessDeposit(beaconState, dep[0], true)
+	newState, err := altair.ProcessDeposit(beaconState, dep[0], false)
 	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
 
 	if newState.Eth1DepositIndex() != 1 {

beacon-chain/core/blocks/deposit.go

@@ -55,12 +55,26 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 		return false, err
 	}
 
-	verified := false
 	if err := verifyDepositDataWithDomain(ctx, deposits, domain); err != nil {
 		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
-		verified = true
+		return false, nil
 	}
-	return verified, nil
+	return true, 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
+	}
+
+	if err := verifyPendingDepositDataWithDomain(ctx, deposits, domain); err != nil {
+		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
+		return false, nil
+	}
+	return true, nil
 }
 
 // IsValidDepositSignature returns whether deposit_data is valid
@@ -159,3 +173,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/blocks/deposit_test.go

@@ -17,6 +17,41 @@ import (
 )
 
 func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             sk.PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+			Amount:                3000,
+		},
+	}
+	sr, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
+		PublicKey:             deposit.Data.PublicKey,
+		WithdrawalCredentials: deposit.Data.WithdrawalCredentials,
+		Amount:                3000,
+	}, domain)
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	deposit.Data.Signature = sig.Marshal()
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+	// We then create a merkle branch for the test.
+	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err, "Could not generate trie")
+	proof, err := depositTrie.MerkleProof(0)
+	require.NoError(t, err, "Could not generate proof")
+
+	deposit.Proof = proof
+	require.NoError(t, err)
+	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
+	require.NoError(t, err)
+	require.Equal(t, true, verified)
+}
+
+func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
 			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
@@ -34,9 +69,9 @@ func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	ok, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
-	require.Equal(t, true, ok)
+	require.Equal(t, false, verified)
 }
 
 func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
@@ -93,3 +128,54 @@ func TestIsValidDepositSignature_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, valid)
 }
+
+func TestBatchVerifyPendingDepositsSignatures_Ok(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	pendingDeposit := &ethpb.PendingDeposit{
+		PublicKey:             sk.PublicKey().Marshal(),
+		WithdrawalCredentials: make([]byte, 32),
+		Amount:                3000,
+	}
+	sr, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
+		PublicKey:             pendingDeposit.PublicKey,
+		WithdrawalCredentials: pendingDeposit.WithdrawalCredentials,
+		Amount:                3000,
+	}, domain)
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	pendingDeposit.Signature = sig.Marshal()
+
+	sk2, err := bls.RandKey()
+	require.NoError(t, err)
+	pendingDeposit2 := &ethpb.PendingDeposit{
+		PublicKey:             sk2.PublicKey().Marshal(),
+		WithdrawalCredentials: make([]byte, 32),
+		Amount:                4000,
+	}
+	sr2, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
+		PublicKey:             pendingDeposit2.PublicKey,
+		WithdrawalCredentials: pendingDeposit2.WithdrawalCredentials,
+		Amount:                4000,
+	}, domain)
+	require.NoError(t, err)
+	sig2 := sk2.Sign(sr2[:])
+	pendingDeposit2.Signature = sig2.Marshal()
+
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
+	require.NoError(t, err)
+	require.Equal(t, true, verified)
+}
+
+func TestBatchVerifyPendingDepositsSignatures_InvalidSignature(t *testing.T) {
+	pendingDeposit := &ethpb.PendingDeposit{
+		PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
+		WithdrawalCredentials: make([]byte, 32),
+		Signature:             make([]byte, 96),
+	}
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit})
+	require.NoError(t, err)
+	require.Equal(t, false, verified)
+}

beacon-chain/core/electra/BUILD.bazel

@@ -32,11 +32,13 @@ 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",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -52,24 +54,27 @@ go_test(
         "deposit_fuzz_test.go",
         "deposits_test.go",
         "effective_balance_updates_test.go",
+        "export_test.go",
         "registry_updates_test.go",
         "transition_test.go",
         "upgrade_test.go",
         "validator_test.go",
         "withdrawals_test.go",
     ],
+    embed = [":go_default_library"],
     deps = [
-        ":go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//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

@@ -15,6 +15,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/time/slots"
+	log "github.com/sirupsen/logrus"
 )
 
 // ProcessPendingConsolidations implements the spec definition below. This method makes mutating
@@ -22,25 +23,28 @@ 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):
-//	            break
+// def process_pending_consolidations(state: BeaconState) -> None:
 //
-//	        # Churn any target excess active balance of target and raise its max
-//	        switch_to_compounding_validator(state, pending_consolidation.target_index)
-//	        # Move active balance to target. Excess balance is withdrawable.
-//	        active_balance = get_active_balance(state, pending_consolidation.source_index)
-//	        decrease_balance(state, pending_consolidation.source_index, active_balance)
-//	        increase_balance(state, pending_consolidation.target_index, active_balance)
+//	next_epoch = Epoch(get_current_epoch(state) + 1)
+//	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 > 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()
@@ -51,12 +55,11 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 
 	nextEpoch := slots.ToEpoch(st.Slot()) + 1
 
-	var nextPendingConsolidation uint64
 	pendingConsolidations, err := st.PendingConsolidations()
 	if err != nil {
 		return err
 	}
-
+	var nextPendingConsolidation uint64
 	for _, pc := range pendingConsolidations {
 		sourceValidator, err := st.ValidatorAtIndex(pc.SourceIndex)
 		if err != nil {
@@ -70,18 +73,16 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			break
 		}
 
-		if err := SwitchToCompoundingValidator(st, pc.TargetIndex); err != nil {
-			return err
-		}
-
-		activeBalance, err := st.ActiveBalanceAtIndex(pc.SourceIndex)
+		validatorBalance, err := st.BalanceAtIndex(pc.SourceIndex)
 		if err != nil {
 			return err
 		}
-		if err := helpers.DecreaseBalance(st, pc.SourceIndex, activeBalance); err != nil {
+		b := min(validatorBalance, helpers.ValidatorMaxEffectiveBalance(sourceValidator))
+
+		if err := helpers.DecreaseBalance(st, pc.SourceIndex, b); err != nil {
 			return err
 		}
-		if err := helpers.IncreaseBalance(st, pc.TargetIndex, activeBalance); err != nil {
+		if err := helpers.IncreaseBalance(st, pc.TargetIndex, b); err != nil {
 			return err
 		}
 		nextPendingConsolidation++
@@ -101,6 +102,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 +132,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 +167,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 +184,44 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if ctx.Err() != nil {
 			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
 		}
+		if IsValidSwitchToCompoundingRequest(st, cr) {
+			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+			if !ok {
+				log.Error("failed to find source validator index")
+				continue
+			}
+			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
+				log.WithError(err).Error("failed to switch to compounding validator")
+			}
+			continue
+		}
+		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
+		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
+		if sourcePubkey == targetPubkey {
+			continue
+		}
+
 		if npc, err := st.NumPendingConsolidations(); err != nil {
 			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
 		} else if npc >= pcLimit {
 			return nil
 		}
 
-		srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
-		if !ok {
-			continue
+		activeBal, err := helpers.TotalActiveBalance(st)
+		if err != nil {
+			return err
 		}
-		tgtIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.TargetPubkey))
-		if !ok {
-			continue
+		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
+			return nil
 		}
 
-		if srcIdx == tgtIdx {
+		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
+		if !ok {
+			continue
+		}
+		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
+		if !ok {
 			continue
 		}
 
@@ -237,7 +261,8 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		// Initiate the exit of the source validator.
 		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
 		if err != nil {
-			return fmt.Errorf("failed to compute consolidaiton epoch: %w", err)
+			log.WithError(err).Error("failed to compute consolidation epoch")
+			continue
 		}
 		srcV.ExitEpoch = exitEpoch
 		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
@@ -248,7 +273,95 @@ 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 {
+				log.WithError(err).Error("failed to switch to compounding validator")
+				continue
+			}
+		}
 	}
 
 	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 has not been initiated
+//	if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	    return False
+//
+//	return True
+func IsValidSwitchToCompoundingRequest(st state.BeaconState, req *enginev1.ConsolidationRequest) bool {
+	if req.SourcePubkey == nil || req.TargetPubkey == nil {
+		return false
+	}
+
+	if !bytes.Equal(req.SourcePubkey, req.TargetPubkey) {
+		return false
+	}
+
+	srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.SourcePubkey))
+	if !ok {
+		return false
+	}
+	// As per the consensus specification, this error is not considered an assertion.
+	// Therefore, if the source_pubkey is not found in validator_pubkeys, we simply return false.
+	srcV, err := st.ValidatorAtIndexReadOnly(srcIdx)
+	if err != nil {
+		return false
+	}
+	sourceAddress := req.SourceAddress
+	withdrawalCreds := srcV.GetWithdrawalCredentials()
+	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
+		return false
+	}
+
+	if !helpers.HasETH1WithdrawalCredential(srcV) {
+		return false
+	}
+
+	curEpoch := slots.ToEpoch(st.Slot())
+	if !helpers.IsActiveValidatorUsingTrie(srcV, curEpoch) {
+		return false
+	}
+
+	if srcV.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
+		return false
+	}
+	return true
+}

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) {
@@ -80,10 +81,10 @@ func TestProcessPendingConsolidations(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, uint64(0), num)
 
-				// v1 is switched to compounding validator.
+				// v1 withdrawal credentials should not be updated.
 				v1, err := st.ValidatorAtIndex(1)
 				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, v1.WithdrawalCredentials[0])
+				require.Equal(t, params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, v1.WithdrawalCredentials[0])
 			},
 			wantErr: false,
 		},
@@ -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,87 @@ func TestProcessConsolidationRequests(t *testing.T) {
 		})
 	}
 }
+
+func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	t.Run("nil source pubkey", func(t *testing.T) {
+		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			SourcePubkey: nil,
+			TargetPubkey: []byte{'a'},
+		})
+		require.Equal(t, false, ok)
+	})
+	t.Run("nil target pubkey", func(t *testing.T) {
+		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			TargetPubkey: nil,
+			SourcePubkey: []byte{'a'},
+		})
+		require.Equal(t, false, ok)
+	})
+	t.Run("different source and target pubkey", func(t *testing.T) {
+		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			TargetPubkey: []byte{'a'},
+			SourcePubkey: []byte{'b'},
+		})
+		require.Equal(t, false, ok)
+	})
+	t.Run("source validator not found in state", func(t *testing.T) {
+		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			SourceAddress: make([]byte, 20),
+			TargetPubkey:  []byte{'a'},
+			SourcePubkey:  []byte{'a'},
+		})
+		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 := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			SourceAddress: make([]byte, 20),
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		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 := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			SourceAddress: wc[12:],
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		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 := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			SourceAddress: wc[12:],
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		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 := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+			SourceAddress: wc[12:],
+			TargetPubkey:  pubkey,
+			SourcePubkey:  pubkey,
+		})
+		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"
@@ -17,6 +16,7 @@ import (
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	log "github.com/sirupsen/logrus"
 )
@@ -38,7 +38,7 @@ func ProcessDeposits(
 	defer span.End()
 	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
 	// individual deposits with signature verification enabled.
-	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
 	}
@@ -47,7 +47,7 @@ func ProcessDeposits(
 		if d == nil || d.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, err = ProcessDeposit(beaconState, d, batchVerified)
+		beaconState, err = ProcessDeposit(beaconState, d, allSignaturesVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(d.Data.PublicKey))
 		}
@@ -82,7 +82,7 @@ func ProcessDeposits(
 //	  amount=deposit.data.amount,
 //	  signature=deposit.data.signature,
 //	 )
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
 	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
@@ -92,37 +92,49 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
 		return nil, err
 	}
-	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
+	return ApplyDeposit(beaconState, deposit.Data, allSignaturesVerified)
 }
 
-// ApplyDeposit
-// def apply_deposit(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> None:
-// validator_pubkeys = [v.pubkey for v in state.validators]
-// if pubkey not in validator_pubkeys:
+// ApplyDeposit adds the incoming deposit as a pending deposit on the state
 //
-//	# Verify the deposit signature (proof of possession) which is not checked by the deposit contract
-//	if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
-//	  add_validator_to_registry(state, pubkey, withdrawal_credentials, amount)
+// Spec pseudocode definition:
+// def apply_deposit(state: BeaconState,
 //
-// else:
-//
-//	# Increase balance by deposit amount
-//	index = ValidatorIndex(validator_pubkeys.index(pubkey))
-//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [Modified in Electra:EIP-7251]
-//	# Check if valid deposit switch to compounding credentials
-//
-// if ( is_compounding_withdrawal_credential(withdrawal_credentials) and has_eth1_withdrawal_credential(state.validators[index])
-//
-//	 and is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature)
-//	):
-//	 switch_to_compounding_validator(state, index)
-func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
+//	              pubkey: BLSPubkey,
+//	              withdrawal_credentials: Bytes32,
+//	              amount: uint64,
+//	              signature: BLSSignature) -> None:
+//	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
+//	    if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
+//	        add_validator_to_registry(state, pubkey, withdrawal_credentials, Gwei(0))  # [Modified in Electra:EIP7251]
+//	        # [New in Electra:EIP7251]
+//	        state.pending_deposits.append(PendingDeposit(
+//	            pubkey=pubkey,
+//	            withdrawal_credentials=withdrawal_credentials,
+//	            amount=amount,
+//	            signature=signature,
+//	            slot=GENESIS_SLOT,  # Use GENESIS_SLOT to distinguish from a pending deposit request
+//	        ))
+//	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  # Use GENESIS_SLOT to distinguish from a pending deposit request
+//	    ))
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSignaturesVerified 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 {
+		if !allSignaturesVerified {
 			valid, err := IsValidDepositSignature(data)
 			if err != nil {
 				return nil, errors.Wrap(err, "could not verify deposit signature")
@@ -131,32 +143,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 := 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
-		if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
-			return nil, err
-		}
-		val, err := beaconState.ValidatorAtIndex(index)
-		if err != nil {
-			return nil, err
-		}
-		if helpers.IsCompoundingWithdrawalCredential(withdrawalCredentials) && helpers.HasETH1WithdrawalCredential(val) {
-			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")
-			}
-		}
+	}
+	// no validation on top-ups (phase0 feature). no validation before state change
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
+		PublicKey:             pubKey,
+		WithdrawalCredentials: withdrawalCredentials,
+		Amount:                amount,
+		Signature:             signature,
+		Slot:                  params.BeaconConfig().GenesisSlot,
+	}); err != nil {
+		return nil, err
 	}
 	return beaconState, nil
 }
@@ -185,152 +185,364 @@ 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:
-//	    available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
-//	    processed_amount = 0
-//	    next_deposit_index = 0
-//	    deposits_to_postpone = []
+// def process_pending_deposits(state: BeaconState) -> None:
 //
-//	    for deposit in state.pending_balance_deposits:
-//	        validator = state.validators[deposit.index]
+//	next_epoch = Epoch(get_current_epoch(state) + 1)
+//	available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
+//	processed_amount = 0
+//	next_deposit_index = 0
+//	deposits_to_postpone = []
+//	is_churn_limit_reached = False
+//	finalized_slot = compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)
+//
+//	for deposit in state.pending_deposits:
+//	    # Do not process deposit requests if Eth1 bridge deposits are not yet applied.
+//	    if (
+//	        # Is deposit request
+//	        deposit.slot > GENESIS_SLOT and
+//	        # There are pending Eth1 bridge deposits
+//	        state.eth1_deposit_index < state.deposit_requests_start_index
+//	    ):
+//	        break
+//
+//	    # Check if deposit has been finalized, otherwise, stop processing.
+//	    if deposit.slot > finalized_slot:
+//	        break
+//
+//	    # Check if number of processed deposits has not reached the limit, otherwise, stop processing.
+//	    if next_deposit_index >= MAX_PENDING_DEPOSITS_PER_EPOCH:
+//	        break
+//
+//	    # Read validator state
+//	    is_validator_exited = False
+//	    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 < next_epoch
+//
+//	    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
-//	        if validator.exit_epoch < FAR_FUTURE_EPOCH:
-//	            if get_current_epoch(state) <= validator.withdrawable_epoch:
-//	                deposits_to_postpone.append(deposit)
-//	            # Deposited balance will never become active. Increase balance but do not consume churn
-//	            else:
-//	                increase_balance(state, deposit.index, deposit.amount)
-//	        # 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:]
-//
-//	    if len(state.pending_balance_deposits) == 0:
-//	        state.deposit_balance_to_consume = Gwei(0)
+//	        deposits_to_postpone.append(deposit)
 //	    else:
-//	        state.deposit_balance_to_consume = available_for_processing - processed_amount
+//	        # 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
 //
-//	    state.pending_balance_deposits += deposits_to_postpone
-func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, activeBalance primitives.Gwei) error {
-	_, span := trace.StartSpan(ctx, "electra.ProcessPendingBalanceDeposits")
+//	        # 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:] + deposits_to_postpone
+//
+//	# 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)
+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() {
 		return errors.New("nil state")
 	}
 
+	// constants & initializations
+	nextEpoch := slots.ToEpoch(st.Slot()) + 1
+	processedAmount := uint64(0)
+	nextDepositIndex := uint64(0)
+	isChurnLimitReached := false
+
+	var pendingDepositsToBatchVerify []*ethpb.PendingDeposit
+	var pendingDepositsToPostpone []*eth.PendingDeposit
+
 	depBalToConsume, err := st.DepositBalanceToConsume()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not get deposit balance to consume")
 	}
 	availableForProcessing := depBalToConsume + helpers.ActivationExitChurnLimit(activeBalance)
-	processedAmount := uint64(0)
-	nextDepositIndex := 0
-	var depositsToPostpone []*eth.PendingBalanceDeposit
 
-	deposits, err := st.PendingBalanceDeposits()
+	finalizedSlot, err := slots.EpochStart(st.FinalizedCheckpoint().Epoch)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized slot")
+	}
+
+	startIndex, err := st.DepositRequestsStartIndex()
+	if err != nil {
+		return errors.Wrap(err, "could not get starting pendingDeposit index")
+	}
+
+	pendingDeposits, err := st.PendingDeposits()
 	if err != nil {
 		return err
 	}
-
-	// constants
-	ffe := params.BeaconConfig().FarFutureEpoch
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
-
-	for _, balanceDeposit := range deposits {
-		v, err := st.ValidatorAtIndexReadOnly(balanceDeposit.Index)
-		if err != nil {
-			return fmt.Errorf("failed to fetch validator at index: %w", err)
+	for _, pendingDeposit := range pendingDeposits {
+		// Do not process pendingDeposit requests if Eth1 bridge deposits are not yet applied.
+		if pendingDeposit.Slot > params.BeaconConfig().GenesisSlot && st.Eth1DepositIndex() < startIndex {
+			break
 		}
 
-		// If the validator is currently exiting, postpone the deposit until after the withdrawable
-		// epoch.
-		if v.ExitEpoch() < ffe {
-			if nextEpoch <= v.WithdrawableEpoch() {
-				depositsToPostpone = append(depositsToPostpone, balanceDeposit)
-			} else {
-				// The deposited balance will never become active. Therefore, we increase the balance but do
-				// not consume the churn.
-				if err := helpers.IncreaseBalance(st, balanceDeposit.Index, balanceDeposit.Amount); err != nil {
-					return err
-				}
+		// Check if pendingDeposit has been finalized, otherwise, stop processing.
+		if pendingDeposit.Slot > finalizedSlot {
+			break
+		}
+
+		// 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() < params.BeaconConfig().FarFutureEpoch
+			isValidatorWithdrawn = val.WithdrawableEpoch() < nextEpoch
+		}
+
+		if isValidatorWithdrawn {
+			// note: the validator will never be active, just increase the balance
+			if err := helpers.IncreaseBalance(st, index, pendingDeposit.Amount); err != nil {
+				return errors.Wrap(err, "could not increase balance")
+			}
+		} else if isValidatorExited {
+			pendingDepositsToPostpone = append(pendingDepositsToPostpone, pendingDeposit)
 		} else {
-			// Validator is not exiting, attempt to process deposit.
-			if primitives.Gwei(processedAmount+balanceDeposit.Amount) > availableForProcessing {
+			isChurnLimitReached = primitives.Gwei(processedAmount+pendingDeposit.Amount) > availableForProcessing
+			if isChurnLimitReached {
 				break
 			}
-			// Deposit fits in churn, process it. Increase balance and consume churn.
-			if err := helpers.IncreaseBalance(st, balanceDeposit.Index, balanceDeposit.Amount); err != nil {
-				return err
+			processedAmount += pendingDeposit.Amount
+
+			// note: the following code deviates from the spec in order to perform batch signature verification
+			if found {
+				if err := helpers.IncreaseBalance(st, index, pendingDeposit.Amount); err != nil {
+					return errors.Wrap(err, "could not increase balance")
+				}
+			} else {
+				// Collect deposit for batch signature verification
+				pendingDepositsToBatchVerify = append(pendingDepositsToBatchVerify, 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++
 	}
 
+	// Perform batch signature verification on pending deposits that require validator registration
+	if err = batchProcessNewPendingDeposits(ctx, st, pendingDepositsToBatchVerify); err != nil {
+		return errors.Wrap(err, "could not process pending deposits with new public keys")
+	}
+
 	// Combined operation:
-	// - state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:]
-	// - state.pending_balance_deposits += deposits_to_postpone
-	// However, the number of remaining deposits must be maintained to properly update the deposit
+	// - state.pending_deposits = state.pending_deposits[next_deposit_index:]
+	// - state.pending_deposits += deposits_to_postpone
+	// However, the number of remaining deposits must be maintained to properly update the pendingDeposit
 	// balance to consume.
-	numRemainingDeposits := len(deposits[nextDepositIndex:])
-	deposits = append(deposits[nextDepositIndex:], depositsToPostpone...)
-	if err := st.SetPendingBalanceDeposits(deposits); err != nil {
+	pendingDeposits = append(pendingDeposits[nextDepositIndex:], pendingDepositsToPostpone...)
+	if err := st.SetPendingDeposits(pendingDeposits); 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)
+}
+
+// batchProcessNewPendingDeposits should only be used to process new deposits that require validator registration
+func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState, pendingDeposits []*ethpb.PendingDeposit) error {
+	// Return early if there are no deposits to process
+	if len(pendingDeposits) == 0 {
+		return nil
+	}
+
+	// Try batch verification of all deposit signatures
+	allSignaturesVerified, err := blocks.BatchVerifyPendingDepositsSignatures(ctx, pendingDeposits)
+	if err != nil {
+		return errors.Wrap(err, "batch signature verification failed")
+	}
+
+	// Process each deposit individually
+	for _, pendingDeposit := range pendingDeposits {
+		validSignature := allSignaturesVerified
+
+		// If batch verification failed, check the individual deposit signature
+		if !allSignaturesVerified {
+			validSignature, err = blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
+				PublicKey:             bytesutil.SafeCopyBytes(pendingDeposit.PublicKey),
+				WithdrawalCredentials: bytesutil.SafeCopyBytes(pendingDeposit.WithdrawalCredentials),
+				Amount:                pendingDeposit.Amount,
+				Signature:             bytesutil.SafeCopyBytes(pendingDeposit.Signature),
+			})
+			if err != nil {
+				return errors.Wrap(err, "individual deposit signature verification failed")
+			}
+		}
+
+		// Add validator to the registry if the signature is valid
+		if validSignature {
+			err = AddValidatorToRegistry(state, pendingDeposit.PublicKey, pendingDeposit.WithdrawalCredentials, pendingDeposit.Amount)
+			if err != nil {
+				return errors.Wrap(err, "failed to add validator to registry")
+			}
+		}
+	}
+
+	return nil
+}
+
+// ApplyPendingDeposit implements the spec definition below.
+// Note : This function is NOT used by ProcessPendingDeposits due to simplified logic for more readable batch processing
+//
+// 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) error {
+	_, span := trace.StartSpan(ctx, "electra.ApplyPendingDeposit")
+	defer span.End()
+	index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(deposit.PublicKey))
+	if !ok {
+		verified, 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 verified {
+			if err := 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)
+}
+
+// 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, amount)  # [Modified in Electra:EIP7251]
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, amount)
+//	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))
+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
 	}
 
-	if numRemainingDeposits == 0 {
-		return st.SetDepositBalanceToConsume(0)
-	} else {
-		return st.SetDepositBalanceToConsume(availableForProcessing - primitives.Gwei(processedAmount))
+	// 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:
+//
+//	validator = 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=Gwei(0),
+//	)
+//
+//	# [Modified in Electra:EIP7251]
+//	max_effective_balance = get_max_effective_balance(validator)
+//	validator.effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, max_effective_balance)
+//
+//	return validator
+func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
+	validator := &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           0,
+	}
+	maxEffectiveBalance := helpers.ValidatorMaxEffectiveBalance(validator)
+	validator.EffectiveBalance = min(amount-(amount%params.BeaconConfig().EffectiveBalanceIncrement), maxEffectiveBalance)
+	return validator
 }
 
 // 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)
-	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")
-	}
+	var err error
 	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")
 		}
@@ -342,30 +554,38 @@ func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState,
 // def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
 //
 //	# Set deposit request start index
-//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUEST_START_INDEX:
+//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUESTS_START_INDEX:
 //	    state.deposit_requests_start_index = deposit_request.index
 //
-//	apply_deposit(
-//	    state=state,
+//	# Create pending deposit
+//	state.pending_deposits.append(PendingDeposit(
 //	    pubkey=deposit_request.pubkey,
 //	    withdrawal_credentials=deposit_request.withdrawal_credentials,
 //	    amount=deposit_request.amount,
 //	    signature=deposit_request.signature,
-//	)
-func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest, verifySignature bool) (state.BeaconState, error) {
+//	    slot=state.slot,
+//	))
+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)
-				for i := 0; i < len(deps); i += 1 {
-					deps[i] = &eth.PendingBalanceDeposit{
-						Amount: uint64(amountAvailForProcessing) / 10,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
+				depositAmount := uint64(amountAvailForProcessing) / 10
+				st := stateWithPendingDeposits(t, 1_000, 20, depositAmount)
+				require.NoError(t, st.SetDepositBalanceToConsume(100))
 				return st
 			}(),
 			check: func(t *testing.T, st state.BeaconState) {
@@ -74,25 +69,45 @@ 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))
 			},
 		},
+		{
+			name: "withdrawn validators should not consume churn",
+			state: func() state.BeaconState {
+				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
+				depositAmount := uint64(amountAvailForProcessing)
+				// set the pending deposits to the maximum churn limit
+				st := stateWithPendingDeposits(t, 1_000, 2, depositAmount)
+				vals := st.Validators()
+				vals[1].WithdrawableEpoch = 0
+				require.NoError(t, st.SetValidators(vals))
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
+				// Validators 0..9 should have their balance increased
+				for i := primitives.ValidatorIndex(0); i < 2; i++ {
+					b, err := st.BalanceAtIndex(i)
+					require.NoError(t, err)
+					require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(amountAvailForProcessing), b)
+				}
+
+				// All pending deposits should have been processed
+				remaining, err := st.PendingDeposits()
+				require.NoError(t, err)
+				require.Equal(t, 0, len(remaining))
+			},
+		},
 		{
 			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)
-				for i := 0; i < len(deps); i += 1 {
-					deps[i] = &eth.PendingBalanceDeposit{
-						Amount: uint64(amountAvailForProcessing) / 5,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
+				depositAmount := uint64(amountAvailForProcessing) / 5
+				st := stateWithPendingDeposits(t, 1_000, 5, depositAmount)
+				require.NoError(t, st.SetDepositBalanceToConsume(0))
 				return st
 			}(),
 			check: func(t *testing.T, st state.BeaconState) {
@@ -108,7 +123,73 @@ 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))
+				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 +197,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)
-				for i := 0; i < len(deps); i += 1 {
-					deps[i] = &eth.PendingBalanceDeposit{
-						Amount: uint64(amountAvailForProcessing) / 5,
-						Index:  primitives.ValidatorIndex(i),
-					}
-				}
-				require.NoError(t, st.SetPendingBalanceDeposits(deps))
+				depositAmount := uint64(amountAvailForProcessing) / 5
+				st := stateWithPendingDeposits(t, 1_000, 5, depositAmount)
+				require.NoError(t, st.SetDepositBalanceToConsume(0))
 				v, err := st.ValidatorAtIndex(0)
 				require.NoError(t, err)
 				v.ExitEpoch = 10
@@ -148,7 +222,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 +230,7 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 		{
 			name: "exited validator balance increased",
 			state: func() state.BeaconState {
-				st := stateWithActiveBalanceETH(t, 1_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))
+				st := stateWithPendingDeposits(t, 1_000, 1, 1_000_000)
 				v, err := st.ValidatorAtIndex(0)
 				require.NoError(t, err)
 				v.ExitEpoch = 2
@@ -182,7 +248,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 +265,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)
@@ -208,6 +274,27 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 	}
 }
 
+func TestBatchProcessNewPendingDeposits(t *testing.T) {
+	t.Run("invalid batch initiates correct individual validation", func(t *testing.T) {
+		st := stateWithActiveBalanceETH(t, 0)
+		require.Equal(t, 0, len(st.Validators()))
+		require.Equal(t, 0, len(st.Balances()))
+		sk, err := bls.RandKey()
+		require.NoError(t, err)
+		wc := make([]byte, 32)
+		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		wc[31] = byte(0)
+		validDep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
+		invalidDep := &eth.PendingDeposit{}
+		// have a combination of valid and invalid deposits
+		deps := []*eth.PendingDeposit{validDep, invalidDep}
+		require.NoError(t, electra.BatchProcessNewPendingDeposits(context.Background(), st, deps))
+		// successfully added to register
+		require.Equal(t, 1, len(st.Validators()))
+		require.Equal(t, 1, len(st.Balances()))
+	})
+}
+
 func TestProcessDepositRequests(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateElectra(t, 1)
 	sk, err := bls.RandKey()
@@ -220,7 +307,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 +317,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 +342,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 +372,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))
@@ -322,7 +408,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := electra.ProcessDeposit(beaconState, dep[0], true)
+	newState, err := electra.ProcessDeposit(beaconState, dep[0], false)
 	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
 
 	if newState.Eth1DepositIndex() != 1 {
@@ -359,42 +445,128 @@ func TestApplyDeposit_TopUps_WithBadSignature(t *testing.T) {
 	vals[0].PublicKey = sk.PublicKey().Marshal()
 	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 	require.NoError(t, st.SetValidators(vals))
-	adSt, err := electra.ApplyDeposit(st, depositData, true)
+	adSt, err := electra.ApplyDeposit(st, depositData, false)
 	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) {
-	st, _ := util.DeterministicGenesisStateElectra(t, 3)
+// stateWithActiveBalanceETH generates a mock beacon state given a balance in eth
+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))
+	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)
-	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-	depositData := &eth.Deposit_Data{
-		PublicKey:             sk.PublicKey().Marshal(),
-		Amount:                1000,
-		WithdrawalCredentials: withdrawalCred,
-		Signature:             make([]byte, fieldparams.BLSSignatureLength),
-	}
-	vals := st.Validators()
-	vals[0].PublicKey = sk.PublicKey().Marshal()
-	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-	require.NoError(t, st.SetValidators(vals))
-	bals := st.Balances()
-	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
-	require.NoError(t, st.SetBalances(bals))
-	sr, err := signing.ComputeSigningRoot(depositData, bytesutil.ToBytes(3, 32))
+	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))
+
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
+
+	b, err := st.BalanceAtIndex(0)
 	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	depositData.Signature = sig.Marshal()
-	adSt, err := electra.ApplyDeposit(st, depositData, false)
-	require.NoError(t, err)
-	pbd, err := adSt.PendingBalanceDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 2, len(pbd))
-	require.Equal(t, uint64(1000), pbd[0].Amount)
-	require.Equal(t, uint64(2000), pbd[1].Amount)
+	require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(excessBalance), b)
+}
+
+func TestApplyPendingDeposit_UnknownKey(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 := 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))
+	// 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))
+	// no validator added
+	require.Equal(t, 0, len(st.Validators()))
+	// no topup either
+	require.Equal(t, 0, len(st.Balances()))
 }

beacon-chain/core/electra/export_test.go

@@ -0,0 +1,3 @@
+package electra
+
+var BatchProcessNewPendingDeposits = batchProcessNewPendingDeposits

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{
-			Amount: uint64(amountAvailForProcessing) / 10,
-			Index:  primitives.ValidatorIndex(i),
+		deps[i] = &ethpb.PendingDeposit{
+			PublicKey:             validators[i].PublicKey,
+			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, uint64(1000), pendingBalanceDeposits[1].Amount)
+	require.Equal(t, 2, len(pendingDeposits))
+	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,22 @@ 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:]
-//		    queue_excess_active_balance(state, index)
+// def switch_to_compounding_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//
+//	validator = state.validators[index]
+//	validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
+//	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 +27,32 @@ 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
-		if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
-			return err
-		}
-		return QueueExcessActiveBalance(s, idx)
+
+	v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
+		return err
 	}
-	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:
-//	    balance = state.balances[index]
-//	    if balance > MIN_ACTIVATION_BALANCE:
-//	        excess_balance = balance - MIN_ACTIVATION_BALANCE
-//	        state.balances[index] = MIN_ACTIVATION_BALANCE
-//	        state.pending_balance_deposits.append(
-//	            PendingBalanceDeposit(index=index, amount=excess_balance)
-//	        )
+// def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
+//
+//	balance = state.balances[index]
+//	if balance > MIN_ACTIVATION_BALANCE:
+//		excess_balance = balance - MIN_ACTIVATION_BALANCE
+//		state.balances[index] = MIN_ACTIVATION_BALANCE
+//		validator = state.validators[index]
+//	 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 +60,21 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 	}
 
 	if bal > params.BeaconConfig().MinActivationBalance {
-		excessBalance := bal - params.BeaconConfig().MinActivationBalance
 		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
 			return err
 		}
-		return s.AppendPendingBalanceDeposit(idx, excessBalance)
+		excessBalance := bal - params.BeaconConfig().MinActivationBalance
+		val, err := s.ValidatorAtIndex(idx)
+		if err != nil {
+			return err
+		}
+		return s.AppendPendingDeposit(&ethpb.PendingDeposit{
+			PublicKey:             val.PublicKey,
+			WithdrawalCredentials: val.WithdrawalCredentials,
+			Amount:                excessBalance,
+			Signature:             common.InfiniteSignature[:],
+			Slot:                  params.BeaconConfig().GenesisSlot,
+		})
 	}
 	return nil
 }
@@ -134,15 +83,21 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 //
 // Spec definition:
 //
-//	def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
-//	    balance = state.balances[index]
-//	    state.balances[index] = 0
-//	    validator = state.validators[index]
-//	    validator.effective_balance = 0
-//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
-//	    state.pending_balance_deposits.append(
-//	        PendingBalanceDeposit(index=index, amount=balance)
-//	    )
+// def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//
+//		balance = state.balances[index]
+//		state.balances[index] = 0
+//		validator = state.validators[index]
+//		validator.effective_balance = 0
+//		validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
+//		state.pending_deposits.append(PendingDeposit(
+//	  		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 +121,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/core/epoch/epoch_processing.go

@@ -147,11 +147,17 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 //	  epoch = get_current_epoch(state)
 //	  total_balance = get_total_active_balance(state)
 //	  adjusted_total_slashing_balance = min(sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER, total_balance)
+//	  if state.version == electra:
+//		 increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from total balance to avoid uint64 overflow
+//	  penalty_per_effective_balance_increment = adjusted_total_slashing_balance // (total_balance // increment)
 //	  for index, validator in enumerate(state.validators):
 //	      if validator.slashed and epoch + EPOCHS_PER_SLASHINGS_VECTOR // 2 == validator.withdrawable_epoch:
 //	          increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from penalty numerator to avoid uint64 overflow
 //	          penalty_numerator = validator.effective_balance // increment * adjusted_total_slashing_balance
 //	          penalty = penalty_numerator // total_balance * increment
+//	          if state.version == electra:
+//	            effective_balance_increments = validator.effective_balance // increment
+//	            penalty = penalty_per_effective_balance_increment * effective_balance_increments
 //	          decrease_balance(state, ValidatorIndex(index), penalty)
 func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error) {
 	currentEpoch := time.CurrentEpoch(st)
@@ -177,13 +183,26 @@ func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.Be
 	// below equally.
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
 	minSlashing := math.Min(totalSlashing*slashingMultiplier, totalBalance)
+
+	// Modified in Electra:EIP7251
+	var penaltyPerEffectiveBalanceIncrement uint64
+	if st.Version() >= version.Electra {
+		penaltyPerEffectiveBalanceIncrement = minSlashing / (totalBalance / increment)
+	}
+
 	bals := st.Balances()
 	changed := false
 	err = st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		correctEpoch := (currentEpoch + exitLength/2) == val.WithdrawableEpoch()
 		if val.Slashed() && correctEpoch {
-			penaltyNumerator := val.EffectiveBalance() / increment * minSlashing
-			penalty := penaltyNumerator / totalBalance * increment
+			var penalty uint64
+			if st.Version() >= version.Electra {
+				effectiveBalanceIncrements := val.EffectiveBalance() / increment
+				penalty = penaltyPerEffectiveBalanceIncrement * effectiveBalanceIncrements
+			} else {
+				penaltyNumerator := val.EffectiveBalance() / increment * minSlashing
+				penalty = penaltyNumerator / totalBalance * increment
+			}
 			bals[idx] = helpers.DecreaseBalanceWithVal(bals[idx], penalty)
 			changed = true
 		}

beacon-chain/core/epoch/epoch_processing_test.go

@@ -448,3 +448,75 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 		})
 	}
 }
+
+func TestProcessSlashings_SlashedElectra(t *testing.T) {
+	tests := []struct {
+		state *ethpb.BeaconStateElectra
+		want  uint64
+	}{
+		{
+			state: &ethpb.BeaconStateElectra{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
+				Slashings: []uint64{0, 1e9},
+			},
+			want: uint64(29000000000),
+		},
+		{
+			state: &ethpb.BeaconStateElectra{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+				},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
+				Slashings: []uint64{0, 1e9},
+			},
+			want: uint64(30500000000),
+		},
+		{
+			state: &ethpb.BeaconStateElectra{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+				},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance * 10, params.BeaconConfig().MaxEffectiveBalance * 20},
+				Slashings: []uint64{0, 2 * 1e9},
+			},
+			want: uint64(317000001536),
+		},
+		{
+			state: &ethpb.BeaconStateElectra{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement}},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement},
+				Slashings: []uint64{0, 1e9},
+			},
+			want: uint64(2044000000727),
+		},
+	}
+
+	for i, tt := range tests {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
+			original := proto.Clone(tt.state)
+			s, err := state_native.InitializeFromProtoElectra(tt.state)
+			require.NoError(t, err)
+			helpers.ClearCache()
+			newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierBellatrix)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
+		})
+	}
+}

beacon-chain/core/helpers/BUILD.bazel

@@ -63,6 +63,7 @@ go_test(
         "validators_test.go",
         "weak_subjectivity_test.go",
     ],
+    data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     shard_count = 2,
     tags = ["CI_race_detection"],

beacon-chain/execution/engine_client.go

@@ -44,8 +44,6 @@ var (
 		GetPayloadMethodV4,
 		GetPayloadBodiesByHashV1,
 		GetPayloadBodiesByRangeV1,
-		GetPayloadBodiesByHashV2,
-		GetPayloadBodiesByRangeV2,
 	}
 )
 
@@ -77,12 +75,8 @@ const (
 	BlockByNumberMethod = "eth_getBlockByNumber"
 	// GetPayloadBodiesByHashV1 is the engine_getPayloadBodiesByHashX JSON-RPC method for pre-Electra payloads.
 	GetPayloadBodiesByHashV1 = "engine_getPayloadBodiesByHashV1"
-	// GetPayloadBodiesByHashV2 is the engine_getPayloadBodiesByHashX JSON-RPC method introduced by Electra.
-	GetPayloadBodiesByHashV2 = "engine_getPayloadBodiesByHashV2"
 	// GetPayloadBodiesByRangeV1 is the engine_getPayloadBodiesByRangeX JSON-RPC method for pre-Electra payloads.
 	GetPayloadBodiesByRangeV1 = "engine_getPayloadBodiesByRangeV1"
-	// GetPayloadBodiesByRangeV2 is the engine_getPayloadBodiesByRangeX JSON-RPC method introduced by Electra.
-	GetPayloadBodiesByRangeV2 = "engine_getPayloadBodiesByRangeV2"
 	// ExchangeCapabilities request string for JSON-RPC.
 	ExchangeCapabilities = "engine_exchangeCapabilities"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
@@ -114,7 +108,7 @@ type PayloadReconstructor interface {
 // EngineCaller defines a client that can interact with an Ethereum
 // execution node's engine service via JSON-RPC.
 type EngineCaller interface {
-	NewPayload(ctx context.Context, payload interfaces.ExecutionData, versionedHashes []common.Hash, parentBlockRoot *common.Hash) ([]byte, error)
+	NewPayload(ctx context.Context, payload interfaces.ExecutionData, versionedHashes []common.Hash, parentBlockRoot *common.Hash, executionRequests *pb.ExecutionRequests) ([]byte, error)
 	ForkchoiceUpdated(
 		ctx context.Context, state *pb.ForkchoiceState, attrs payloadattribute.Attributer,
 	) (*pb.PayloadIDBytes, []byte, error)
@@ -125,8 +119,8 @@ type EngineCaller interface {
 
 var ErrEmptyBlockHash = errors.New("Block hash is empty 0x0000...")
 
-// NewPayload calls the engine_newPayloadVX method via JSON-RPC.
-func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionData, versionedHashes []common.Hash, parentBlockRoot *common.Hash) ([]byte, error) {
+// NewPayload request calls the engine_newPayloadVX method via JSON-RPC.
+func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionData, versionedHashes []common.Hash, parentBlockRoot *common.Hash, executionRequests *pb.ExecutionRequests) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.NewPayload")
 	defer span.End()
 	start := time.Now()
@@ -163,9 +157,20 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 		if !ok {
 			return nil, errors.New("execution data must be a Deneb execution payload")
 		}
-		err := s.rpcClient.CallContext(ctx, result, NewPayloadMethodV3, payloadPb, versionedHashes, parentBlockRoot)
-		if err != nil {
-			return nil, handleRPCError(err)
+		if executionRequests == nil {
+			err := s.rpcClient.CallContext(ctx, result, NewPayloadMethodV3, payloadPb, versionedHashes, parentBlockRoot)
+			if err != nil {
+				return nil, handleRPCError(err)
+			}
+		} else {
+			flattenedRequests, err := pb.EncodeExecutionRequests(executionRequests)
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to encode execution requests")
+			}
+			err = s.rpcClient.CallContext(ctx, result, NewPayloadMethodV4, payloadPb, versionedHashes, parentBlockRoot, flattenedRequests)
+			if err != nil {
+				return nil, handleRPCError(err)
+			}
 		}
 	default:
 		return nil, errors.New("unknown execution data type")
@@ -259,6 +264,9 @@ func (s *Service) ForkchoiceUpdated(
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
 	pe := slots.ToEpoch(slot)
+	if pe >= params.BeaconConfig().ElectraForkEpoch {
+		return GetPayloadMethodV4, &pb.ExecutionBundleElectra{}
+	}
 	if pe >= params.BeaconConfig().DenebForkEpoch {
 		return GetPayloadMethodV3, &pb.ExecutionPayloadDenebWithValueAndBlobsBundle{}
 	}
@@ -297,13 +305,16 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExchangeCapabilities")
 	defer span.End()
 
-	result := &pb.ExchangeCapabilities{}
+	var result []string
 	err := s.rpcClient.CallContext(ctx, &result, ExchangeCapabilities, supportedEngineEndpoints)
+	if err != nil {
+		return nil, handleRPCError(err)
+	}
 
 	var unsupported []string
 	for _, s1 := range supportedEngineEndpoints {
 		supported := false
-		for _, s2 := range result.SupportedMethods {
+		for _, s2 := range result {
 			if s1 == s2 {
 				supported = true
 				break
@@ -316,7 +327,7 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	if len(unsupported) != 0 {
 		log.Warnf("Please update client, detected the following unsupported engine methods: %s", unsupported)
 	}
-	return result.SupportedMethods, handleRPCError(err)
+	return result, handleRPCError(err)
 }
 
 // GetTerminalBlockHash returns the valid terminal block hash based on total difficulty.

beacon-chain/execution/engine_client_test.go

@@ -123,7 +123,7 @@ func TestClient_IPC(t *testing.T) {
 		require.Equal(t, true, ok)
 		wrappedPayload, err := blocks.WrappedExecutionPayload(req)
 		require.NoError(t, err)
-		latestValidHash, err := srv.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		latestValidHash, err := srv.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.NoError(t, err)
 		require.DeepEqual(t, bytesutil.ToBytes32(want.LatestValidHash), bytesutil.ToBytes32(latestValidHash))
 	})
@@ -134,7 +134,7 @@ func TestClient_IPC(t *testing.T) {
 		require.Equal(t, true, ok)
 		wrappedPayload, err := blocks.WrappedExecutionPayloadCapella(req)
 		require.NoError(t, err)
-		latestValidHash, err := srv.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		latestValidHash, err := srv.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.NoError(t, err)
 		require.DeepEqual(t, bytesutil.ToBytes32(want.LatestValidHash), bytesutil.ToBytes32(latestValidHash))
 	})
@@ -163,7 +163,7 @@ func TestClient_HTTP(t *testing.T) {
 	cfg := params.BeaconConfig().Copy()
 	cfg.CapellaForkEpoch = 1
 	cfg.DenebForkEpoch = 2
-	cfg.ElectraForkEpoch = 2
+	cfg.ElectraForkEpoch = 3
 	params.OverrideBeaconConfig(cfg)
 
 	t.Run(GetPayloadMethod, func(t *testing.T) {
@@ -320,6 +320,89 @@ func TestClient_HTTP(t *testing.T) {
 		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
 		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
 	})
+	t.Run(GetPayloadMethodV4, func(t *testing.T) {
+		payloadId := [8]byte{1}
+		want, ok := fix["ExecutionBundleElectra"].(*pb.GetPayloadV4ResponseJson)
+		require.Equal(t, true, ok)
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			enc, err := io.ReadAll(r.Body)
+			require.NoError(t, err)
+			jsonRequestString := string(enc)
+
+			reqArg, err := json.Marshal(pb.PayloadIDBytes(payloadId))
+			require.NoError(t, err)
+
+			// We expect the JSON string RPC request contains the right arguments.
+			require.Equal(t, true, strings.Contains(
+				jsonRequestString, string(reqArg),
+			))
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  want,
+			}
+			err = json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		defer srv.Close()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+		defer rpcClient.Close()
+
+		client := &Service{}
+		client.rpcClient = rpcClient
+
+		// We call the RPC method via HTTP and expect a proper result.
+		resp, err := client.GetPayload(ctx, payloadId, 3*params.BeaconConfig().SlotsPerEpoch)
+		require.NoError(t, err)
+		require.Equal(t, true, resp.OverrideBuilder)
+		g, err := resp.ExecutionData.ExcessBlobGas()
+		require.NoError(t, err)
+		require.DeepEqual(t, uint64(3), g)
+		g, err = resp.ExecutionData.BlobGasUsed()
+		require.NoError(t, err)
+		require.DeepEqual(t, uint64(2), g)
+
+		commitments := [][]byte{bytesutil.PadTo([]byte("commitment1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("commitment2"), fieldparams.BLSPubkeyLength)}
+		require.DeepEqual(t, commitments, resp.BlobsBundle.KzgCommitments)
+		proofs := [][]byte{bytesutil.PadTo([]byte("proof1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("proof2"), fieldparams.BLSPubkeyLength)}
+		require.DeepEqual(t, proofs, resp.BlobsBundle.Proofs)
+		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
+		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
+		requests := &pb.ExecutionRequests{
+			Deposits: []*pb.DepositRequest{
+				{
+					Pubkey:                bytesutil.PadTo([]byte{byte('a')}, fieldparams.BLSPubkeyLength),
+					WithdrawalCredentials: bytesutil.PadTo([]byte{byte('b')}, fieldparams.RootLength),
+					Amount:                params.BeaconConfig().MinActivationBalance,
+					Signature:             bytesutil.PadTo([]byte{byte('c')}, fieldparams.BLSSignatureLength),
+					Index:                 0,
+				},
+			},
+			Withdrawals: []*pb.WithdrawalRequest{
+				{
+					SourceAddress:   bytesutil.PadTo([]byte{byte('d')}, common.AddressLength),
+					ValidatorPubkey: bytesutil.PadTo([]byte{byte('e')}, fieldparams.BLSPubkeyLength),
+					Amount:          params.BeaconConfig().MinActivationBalance,
+				},
+			},
+			Consolidations: []*pb.ConsolidationRequest{
+				{
+					SourceAddress: bytesutil.PadTo([]byte{byte('f')}, common.AddressLength),
+					SourcePubkey:  bytesutil.PadTo([]byte{byte('g')}, fieldparams.BLSPubkeyLength),
+					TargetPubkey:  bytesutil.PadTo([]byte{byte('h')}, fieldparams.BLSPubkeyLength),
+				},
+			},
+		}
+
+		require.DeepEqual(t, requests, resp.ExecutionRequests)
+	})
+
 	t.Run(ForkchoiceUpdatedMethod+" VALID status", func(t *testing.T) {
 		forkChoiceState := &pb.ForkchoiceState{
 			HeadBlockHash:      []byte("head"),
@@ -470,7 +553,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayload(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.NoError(t, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
@@ -484,7 +567,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadCapella(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.NoError(t, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
@@ -498,7 +581,46 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, nil)
+		require.NoError(t, err)
+		require.DeepEqual(t, want.LatestValidHash, resp)
+	})
+	t.Run(NewPayloadMethodV4+" VALID status", func(t *testing.T) {
+		execPayload, ok := fix["ExecutionPayloadDeneb"].(*pb.ExecutionPayloadDeneb)
+		require.Equal(t, true, ok)
+		want, ok := fix["ValidPayloadStatus"].(*pb.PayloadStatus)
+		require.Equal(t, true, ok)
+
+		// We call the RPC method via HTTP and expect a proper result.
+		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
+		require.NoError(t, err)
+		requests := &pb.ExecutionRequests{
+			Deposits: []*pb.DepositRequest{
+				{
+					Pubkey:                bytesutil.PadTo([]byte{byte('a')}, fieldparams.BLSPubkeyLength),
+					WithdrawalCredentials: bytesutil.PadTo([]byte{byte('b')}, fieldparams.RootLength),
+					Amount:                params.BeaconConfig().MinActivationBalance,
+					Signature:             bytesutil.PadTo([]byte{byte('c')}, fieldparams.BLSSignatureLength),
+					Index:                 0,
+				},
+			},
+			Withdrawals: []*pb.WithdrawalRequest{
+				{
+					SourceAddress:   bytesutil.PadTo([]byte{byte('d')}, common.AddressLength),
+					ValidatorPubkey: bytesutil.PadTo([]byte{byte('e')}, fieldparams.BLSPubkeyLength),
+					Amount:          params.BeaconConfig().MinActivationBalance,
+				},
+			},
+			Consolidations: []*pb.ConsolidationRequest{
+				{
+					SourceAddress: bytesutil.PadTo([]byte{byte('f')}, common.AddressLength),
+					SourcePubkey:  bytesutil.PadTo([]byte{byte('g')}, fieldparams.BLSPubkeyLength),
+					TargetPubkey:  bytesutil.PadTo([]byte{byte('h')}, fieldparams.BLSPubkeyLength),
+				},
+			},
+		}
+		client := newPayloadV4Setup(t, want, execPayload, requests)
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, requests)
 		require.NoError(t, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
@@ -512,7 +634,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayload(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrAcceptedSyncingPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -526,7 +648,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadCapella(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrAcceptedSyncingPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -540,7 +662,46 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, nil)
+		require.ErrorIs(t, ErrAcceptedSyncingPayloadStatus, err)
+		require.DeepEqual(t, []uint8(nil), resp)
+	})
+	t.Run(NewPayloadMethodV4+" SYNCING status", func(t *testing.T) {
+		execPayload, ok := fix["ExecutionPayloadDeneb"].(*pb.ExecutionPayloadDeneb)
+		require.Equal(t, true, ok)
+		want, ok := fix["SyncingStatus"].(*pb.PayloadStatus)
+		require.Equal(t, true, ok)
+
+		// We call the RPC method via HTTP and expect a proper result.
+		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
+		require.NoError(t, err)
+		requests := &pb.ExecutionRequests{
+			Deposits: []*pb.DepositRequest{
+				{
+					Pubkey:                bytesutil.PadTo([]byte{byte('a')}, fieldparams.BLSPubkeyLength),
+					WithdrawalCredentials: bytesutil.PadTo([]byte{byte('b')}, fieldparams.RootLength),
+					Amount:                params.BeaconConfig().MinActivationBalance,
+					Signature:             bytesutil.PadTo([]byte{byte('c')}, fieldparams.BLSSignatureLength),
+					Index:                 0,
+				},
+			},
+			Withdrawals: []*pb.WithdrawalRequest{
+				{
+					SourceAddress:   bytesutil.PadTo([]byte{byte('d')}, common.AddressLength),
+					ValidatorPubkey: bytesutil.PadTo([]byte{byte('e')}, fieldparams.BLSPubkeyLength),
+					Amount:          params.BeaconConfig().MinActivationBalance,
+				},
+			},
+			Consolidations: []*pb.ConsolidationRequest{
+				{
+					SourceAddress: bytesutil.PadTo([]byte{byte('f')}, common.AddressLength),
+					SourcePubkey:  bytesutil.PadTo([]byte{byte('g')}, fieldparams.BLSPubkeyLength),
+					TargetPubkey:  bytesutil.PadTo([]byte{byte('h')}, fieldparams.BLSPubkeyLength),
+				},
+			},
+		}
+		client := newPayloadV4Setup(t, want, execPayload, requests)
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, requests)
 		require.ErrorIs(t, ErrAcceptedSyncingPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -554,7 +715,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayload(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrInvalidBlockHashPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -568,7 +729,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadCapella(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrInvalidBlockHashPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -582,7 +743,45 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, nil)
+		require.ErrorIs(t, ErrInvalidBlockHashPayloadStatus, err)
+		require.DeepEqual(t, []uint8(nil), resp)
+	})
+	t.Run(NewPayloadMethodV4+" INVALID_BLOCK_HASH status", func(t *testing.T) {
+		execPayload, ok := fix["ExecutionPayloadDeneb"].(*pb.ExecutionPayloadDeneb)
+		require.Equal(t, true, ok)
+		want, ok := fix["InvalidBlockHashStatus"].(*pb.PayloadStatus)
+		require.Equal(t, true, ok)
+		// We call the RPC method via HTTP and expect a proper result.
+		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
+		require.NoError(t, err)
+		requests := &pb.ExecutionRequests{
+			Deposits: []*pb.DepositRequest{
+				{
+					Pubkey:                bytesutil.PadTo([]byte{byte('a')}, fieldparams.BLSPubkeyLength),
+					WithdrawalCredentials: bytesutil.PadTo([]byte{byte('b')}, fieldparams.RootLength),
+					Amount:                params.BeaconConfig().MinActivationBalance,
+					Signature:             bytesutil.PadTo([]byte{byte('c')}, fieldparams.BLSSignatureLength),
+					Index:                 0,
+				},
+			},
+			Withdrawals: []*pb.WithdrawalRequest{
+				{
+					SourceAddress:   bytesutil.PadTo([]byte{byte('d')}, common.AddressLength),
+					ValidatorPubkey: bytesutil.PadTo([]byte{byte('e')}, fieldparams.BLSPubkeyLength),
+					Amount:          params.BeaconConfig().MinActivationBalance,
+				},
+			},
+			Consolidations: []*pb.ConsolidationRequest{
+				{
+					SourceAddress: bytesutil.PadTo([]byte{byte('f')}, common.AddressLength),
+					SourcePubkey:  bytesutil.PadTo([]byte{byte('g')}, fieldparams.BLSPubkeyLength),
+					TargetPubkey:  bytesutil.PadTo([]byte{byte('h')}, fieldparams.BLSPubkeyLength),
+				},
+			},
+		}
+		client := newPayloadV4Setup(t, want, execPayload, requests)
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, requests)
 		require.ErrorIs(t, ErrInvalidBlockHashPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -596,7 +795,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayload(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrInvalidPayloadStatus, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
@@ -610,7 +809,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadCapella(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrInvalidPayloadStatus, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
@@ -624,7 +823,46 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, nil)
+		require.ErrorIs(t, ErrInvalidPayloadStatus, err)
+		require.DeepEqual(t, want.LatestValidHash, resp)
+	})
+	t.Run(NewPayloadMethodV4+" INVALID status", func(t *testing.T) {
+		execPayload, ok := fix["ExecutionPayloadDeneb"].(*pb.ExecutionPayloadDeneb)
+		require.Equal(t, true, ok)
+		want, ok := fix["InvalidStatus"].(*pb.PayloadStatus)
+		require.Equal(t, true, ok)
+
+		// We call the RPC method via HTTP and expect a proper result.
+		wrappedPayload, err := blocks.WrappedExecutionPayloadDeneb(execPayload)
+		require.NoError(t, err)
+		requests := &pb.ExecutionRequests{
+			Deposits: []*pb.DepositRequest{
+				{
+					Pubkey:                bytesutil.PadTo([]byte{byte('a')}, fieldparams.BLSPubkeyLength),
+					WithdrawalCredentials: bytesutil.PadTo([]byte{byte('b')}, fieldparams.RootLength),
+					Amount:                params.BeaconConfig().MinActivationBalance,
+					Signature:             bytesutil.PadTo([]byte{byte('c')}, fieldparams.BLSSignatureLength),
+					Index:                 0,
+				},
+			},
+			Withdrawals: []*pb.WithdrawalRequest{
+				{
+					SourceAddress:   bytesutil.PadTo([]byte{byte('d')}, common.AddressLength),
+					ValidatorPubkey: bytesutil.PadTo([]byte{byte('e')}, fieldparams.BLSPubkeyLength),
+					Amount:          params.BeaconConfig().MinActivationBalance,
+				},
+			},
+			Consolidations: []*pb.ConsolidationRequest{
+				{
+					SourceAddress: bytesutil.PadTo([]byte{byte('f')}, common.AddressLength),
+					SourcePubkey:  bytesutil.PadTo([]byte{byte('g')}, fieldparams.BLSPubkeyLength),
+					TargetPubkey:  bytesutil.PadTo([]byte{byte('h')}, fieldparams.BLSPubkeyLength),
+				},
+			},
+		}
+		client := newPayloadV4Setup(t, want, execPayload, requests)
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'}, requests)
 		require.ErrorIs(t, ErrInvalidPayloadStatus, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
@@ -638,7 +876,7 @@ func TestClient_HTTP(t *testing.T) {
 		// We call the RPC method via HTTP and expect a proper result.
 		wrappedPayload, err := blocks.WrappedExecutionPayload(execPayload)
 		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{})
+		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
 		require.ErrorIs(t, ErrUnknownPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
@@ -1297,6 +1535,7 @@ func fixtures() map[string]interface{} {
 		"ExecutionPayloadDeneb":             s.ExecutionPayloadDeneb,
 		"ExecutionPayloadCapellaWithValue":  s.ExecutionPayloadWithValueCapella,
 		"ExecutionPayloadDenebWithValue":    s.ExecutionPayloadWithValueDeneb,
+		"ExecutionBundleElectra":            s.ExecutionBundleElectra,
 		"ValidPayloadStatus":                s.ValidPayloadStatus,
 		"InvalidBlockHashStatus":            s.InvalidBlockHashStatus,
 		"AcceptedStatus":                    s.AcceptedStatus,
@@ -1483,6 +1722,53 @@ func fixturesStruct() *payloadFixtures {
 			Blobs:       []hexutil.Bytes{{'a'}, {'b'}},
 		},
 	}
+
+	depositRequestBytes, err := hexutil.Decode("0x610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
+		"620000000000000000000000000000000000000000000000000000000000000000" +
+		"4059730700000063000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
+		"00000000000000000000000000000000000000000000000000000000000000000000000000000000")
+	if err != nil {
+		panic("failed to decode deposit request")
+	}
+	withdrawalRequestBytes, err := hexutil.Decode("0x6400000000000000000000000000000000000000" +
+		"6500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040597307000000")
+	if err != nil {
+		panic("failed to decode withdrawal request")
+	}
+	consolidationRequestBytes, err := hexutil.Decode("0x6600000000000000000000000000000000000000" +
+		"670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
+		"680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+	if err != nil {
+		panic("failed to decode consolidation request")
+	}
+	executionBundleFixtureElectra := &pb.GetPayloadV4ResponseJson{
+		ShouldOverrideBuilder: true,
+		ExecutionPayload: &pb.ExecutionPayloadDenebJSON{
+			ParentHash:    &common.Hash{'a'},
+			FeeRecipient:  &common.Address{'b'},
+			StateRoot:     &common.Hash{'c'},
+			ReceiptsRoot:  &common.Hash{'d'},
+			LogsBloom:     &hexutil.Bytes{'e'},
+			PrevRandao:    &common.Hash{'f'},
+			BaseFeePerGas: "0x123",
+			BlockHash:     &common.Hash{'g'},
+			Transactions:  []hexutil.Bytes{{'h'}},
+			Withdrawals:   []*pb.Withdrawal{},
+			BlockNumber:   &hexUint,
+			GasLimit:      &hexUint,
+			GasUsed:       &hexUint,
+			Timestamp:     &hexUint,
+			BlobGasUsed:   &bgu,
+			ExcessBlobGas: &ebg,
+		},
+		BlockValue: "0x11fffffffff",
+		BlobsBundle: &pb.BlobBundleJSON{
+			Commitments: []hexutil.Bytes{[]byte("commitment1"), []byte("commitment2")},
+			Proofs:      []hexutil.Bytes{[]byte("proof1"), []byte("proof2")},
+			Blobs:       []hexutil.Bytes{{'a'}, {'b'}},
+		},
+		ExecutionRequests: []hexutil.Bytes{depositRequestBytes, withdrawalRequestBytes, consolidationRequestBytes},
+	}
 	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
 	sha3Uncles := bytesutil.PadTo([]byte("sha3Uncles"), fieldparams.RootLength)
 	miner := bytesutil.PadTo([]byte("miner"), fieldparams.FeeRecipientLength)
@@ -1576,6 +1862,7 @@ func fixturesStruct() *payloadFixtures {
 		EmptyExecutionPayloadDeneb:        emptyExecutionPayloadDeneb,
 		ExecutionPayloadWithValueCapella:  executionPayloadWithValueFixtureCapella,
 		ExecutionPayloadWithValueDeneb:    executionPayloadWithValueFixtureDeneb,
+		ExecutionBundleElectra:            executionBundleFixtureElectra,
 		ValidPayloadStatus:                validStatus,
 		InvalidBlockHashStatus:            inValidBlockHashStatus,
 		AcceptedStatus:                    acceptedStatus,
@@ -1599,6 +1886,7 @@ type payloadFixtures struct {
 	ExecutionPayloadDeneb             *pb.ExecutionPayloadDeneb
 	ExecutionPayloadWithValueCapella  *pb.GetPayloadV2ResponseJson
 	ExecutionPayloadWithValueDeneb    *pb.GetPayloadV3ResponseJson
+	ExecutionBundleElectra            *pb.GetPayloadV4ResponseJson
 	ValidPayloadStatus                *pb.PayloadStatus
 	InvalidBlockHashStatus            *pb.PayloadStatus
 	AcceptedStatus                    *pb.PayloadStatus
@@ -1957,6 +2245,54 @@ func newPayloadV3Setup(t *testing.T, status *pb.PayloadStatus, payload *pb.Execu
 	return service
 }
 
+func newPayloadV4Setup(t *testing.T, status *pb.PayloadStatus, payload *pb.ExecutionPayloadDeneb, requests *pb.ExecutionRequests) *Service {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		defer func() {
+			require.NoError(t, r.Body.Close())
+		}()
+		enc, err := io.ReadAll(r.Body)
+		require.NoError(t, err)
+		jsonRequestString := string(enc)
+		require.Equal(t, true, strings.Contains(
+			jsonRequestString, string("engine_newPayloadV4"),
+		))
+
+		reqPayload, err := json.Marshal(payload)
+		require.NoError(t, err)
+
+		// We expect the JSON string RPC request contains the right arguments.
+		require.Equal(t, true, strings.Contains(
+			jsonRequestString, string(reqPayload),
+		))
+
+		reqRequests, err := pb.EncodeExecutionRequests(requests)
+		require.NoError(t, err)
+
+		jsonRequests, err := json.Marshal(reqRequests)
+		require.NoError(t, err)
+
+		require.Equal(t, true, strings.Contains(
+			jsonRequestString, string(jsonRequests),
+		))
+
+		resp := map[string]interface{}{
+			"jsonrpc": "2.0",
+			"id":      1,
+			"result":  status,
+		}
+		err = json.NewEncoder(w).Encode(resp)
+		require.NoError(t, err)
+	}))
+
+	rpcClient, err := rpc.DialHTTP(srv.URL)
+	require.NoError(t, err)
+
+	service := &Service{}
+	service.rpcClient = rpcClient
+	return service
+}
+
 func TestReconstructBlindedBlockBatch(t *testing.T) {
 	t.Run("empty response works", func(t *testing.T) {
 		ctx := context.Background()
@@ -1996,11 +2332,10 @@ func Test_ExchangeCapabilities(t *testing.T) {
 			defer func() {
 				require.NoError(t, r.Body.Close())
 			}()
-			exchangeCapabilities := &pb.ExchangeCapabilities{}
 			resp := map[string]interface{}{
 				"jsonrpc": "2.0",
 				"id":      1,
-				"result":  exchangeCapabilities,
+				"result":  []string{},
 			}
 			err := json.NewEncoder(w).Encode(resp)
 			require.NoError(t, err)
@@ -2029,14 +2364,11 @@ func Test_ExchangeCapabilities(t *testing.T) {
 			defer func() {
 				require.NoError(t, r.Body.Close())
 			}()
-			exchangeCapabilities := &pb.ExchangeCapabilities{
-				SupportedMethods: []string{"A", "B", "C"},
-			}
 
 			resp := map[string]interface{}{
 				"jsonrpc": "2.0",
 				"id":      1,
-				"result":  exchangeCapabilities,
+				"result":  []string{"A", "B", "C"},
 			}
 			err := json.NewEncoder(w).Encode(resp)
 			require.NoError(t, err)

beacon-chain/execution/mock_test.go

@@ -3,7 +3,6 @@ package execution
 import (
 	"context"
 	"encoding/json"
-	"math"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -131,21 +130,10 @@ func TestParseRequest(t *testing.T) {
 				strToHexBytes(t, "0x66756c6c00000000000000000000000000000000000000000000000000000000"),
 			},
 		},
-		{
-			method: GetPayloadBodiesByHashV2,
-			byteArgs: []hexutil.Bytes{
-				strToHexBytes(t, "0x656d707479000000000000000000000000000000000000000000000000000000"),
-				strToHexBytes(t, "0x66756c6c00000000000000000000000000000000000000000000000000000000"),
-			},
-		},
 		{
 			method:  GetPayloadBodiesByRangeV1,
 			hexArgs: []string{hexutil.EncodeUint64(0), hexutil.EncodeUint64(1)},
 		},
-		{
-			method:  GetPayloadBodiesByRangeV2,
-			hexArgs: []string{hexutil.EncodeUint64(math.MaxUint64), hexutil.EncodeUint64(1)},
-		},
 	}
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {
@@ -191,9 +179,7 @@ func TestParseRequest(t *testing.T) {
 func TestCallCount(t *testing.T) {
 	methods := []string{
 		GetPayloadBodiesByHashV1,
-		GetPayloadBodiesByHashV2,
 		GetPayloadBodiesByRangeV1,
-		GetPayloadBodiesByRangeV2,
 	}
 	cases := []struct {
 		method string
@@ -201,10 +187,8 @@ func TestCallCount(t *testing.T) {
 	}{
 		{method: GetPayloadBodiesByHashV1, count: 1},
 		{method: GetPayloadBodiesByHashV1, count: 2},
-		{method: GetPayloadBodiesByHashV2, count: 1},
 		{method: GetPayloadBodiesByRangeV1, count: 1},
 		{method: GetPayloadBodiesByRangeV1, count: 2},
-		{method: GetPayloadBodiesByRangeV2, count: 1},
 	}
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {

beacon-chain/execution/payload_body.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -87,10 +86,7 @@ func (r *blindedBlockReconstructor) addToBatch(b interfaces.ReadOnlySignedBeacon
 	return nil
 }
 
-func payloadBodyMethodForBlock(b interface{ Version() int }) string {
-	if b.Version() > version.Deneb {
-		return GetPayloadBodiesByHashV2
-	}
+func payloadBodyMethodForBlock(_ interface{ Version() int }) string {
 	return GetPayloadBodiesByHashV1
 }
 
@@ -243,9 +239,6 @@ func (r *blindedBlockReconstructor) unblinded() ([]interfaces.SignedBeaconBlock,
 	return unblinded, nil
 }
 
-func rangeMethodForHashMethod(method string) string {
-	if method == GetPayloadBodiesByHashV2 {
-		return GetPayloadBodiesByRangeV2
-	}
+func rangeMethodForHashMethod(_ string) string {
 	return GetPayloadBodiesByRangeV1
 }

beacon-chain/execution/payload_body_test.go

@@ -25,33 +25,6 @@ func (v versioner) Version() int {
 	return v.version
 }
 
-func TestPayloadBodyMethodForBlock(t *testing.T) {
-	cases := []struct {
-		versions []int
-		want     string
-	}{
-		{
-			versions: []int{version.Phase0, version.Altair, version.Bellatrix, version.Capella, version.Deneb},
-			want:     GetPayloadBodiesByHashV1,
-		},
-		{
-			versions: []int{version.Electra},
-			want:     GetPayloadBodiesByHashV2,
-		},
-	}
-	for _, c := range cases {
-		for _, v := range c.versions {
-			t.Run(version.String(v), func(t *testing.T) {
-				v := versioner{version: v}
-				require.Equal(t, c.want, payloadBodyMethodForBlock(v))
-			})
-		}
-	}
-	t.Run("post-electra", func(t *testing.T) {
-		require.Equal(t, GetPayloadBodiesByHashV2, payloadBodyMethodForBlock(versioner{version: version.Electra + 1}))
-	})
-}
-
 func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPayloadBody {
 	body := &pb.ExecutionPayloadBody{}
 	txs, err := ed.Transactions()
@@ -347,22 +320,6 @@ func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
 			}
 			mockWriteResult(t, w, msg, executionPayloadBodies)
 		})
-		// separate methods for the electra block
-		srv.register(GetPayloadBodiesByHashV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil}
-			mockWriteResult(t, w, msg, executionPayloadBodies)
-		})
-		srv.register(GetPayloadBodiesByRangeV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			p := mockParseUintList(t, msg.Params)
-			require.Equal(t, 2, len(p))
-			start, count := p[0], p[1]
-			require.Equal(t, fx.electra.blinded.header.BlockNumber(), start)
-			require.Equal(t, uint64(1), count)
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{
-				payloadToBody(t, fx.electra.blinded.header),
-			}
-			mockWriteResult(t, w, msg, executionPayloadBodies)
-		})
 		blind := []interfaces.ReadOnlySignedBeaconBlock{
 			fx.denebBlock.blinded.block,
 			fx.emptyDenebBlock.blinded.block,
@@ -381,13 +338,8 @@ func TestReconstructBlindedBlockBatchDenebAndElectra(t *testing.T) {
 	t.Run("deneb and electra", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
 		fx := testBlindedBlockFixtures(t)
-		// The reconstructed should make separate calls for the deneb (v1) and electra (v2) blocks.
 		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header)}
-			mockWriteResult(t, w, msg, executionPayloadBodies)
-		})
-		srv.register(GetPayloadBodiesByHashV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.electra.blinded.header)}
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header), payloadToBody(t, fx.electra.blinded.header)}
 			mockWriteResult(t, w, msg, executionPayloadBodies)
 		})
 		blinded := []interfaces.ReadOnlySignedBeaconBlock{

beacon-chain/execution/testing/mock_engine_client.go

@@ -39,7 +39,7 @@ type EngineClient struct {
 }
 
 // NewPayload --
-func (e *EngineClient) NewPayload(_ context.Context, _ interfaces.ExecutionData, _ []common.Hash, _ *common.Hash) ([]byte, error) {
+func (e *EngineClient) NewPayload(_ context.Context, _ interfaces.ExecutionData, _ []common.Hash, _ *common.Hash, _ *pb.ExecutionRequests) ([]byte, error) {
 	return e.NewPayloadResp, e.ErrNewPayload
 }
 
@@ -54,7 +54,7 @@ func (e *EngineClient) ForkchoiceUpdated(
 }
 
 // GetPayload --
-func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, s primitives.Slot) (*blocks.GetPayloadResponse, error) {
+func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, _ primitives.Slot) (*blocks.GetPayloadResponse, error) {
 	return e.GetPayloadResponse, e.ErrGetPayload
 }
 

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 {
-	return &ethpb.PendingBalanceDeposit{}
+func (PendingDepositCreator) Create() MarshalerProtoMessage {
+	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/endpoints.go

@@ -219,6 +219,16 @@ func (s *Service) validatorEndpoints(
 			handler: server.SubmitAggregateAndProofs,
 			methods: []string{http.MethodPost},
 		},
+		{
+			template: "/eth/v2/validator/aggregate_and_proofs",
+			name:     namespace + ".SubmitAggregateAndProofsV2",
+			middleware: []middleware.Middleware{
+				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.SubmitAggregateAndProofsV2,
+			methods: []string{http.MethodPost},
+		},
 		{
 			template: "/eth/v1/validator/sync_committee_contribution",
 			name:     namespace + ".ProduceSyncCommitteeContribution",
@@ -688,14 +698,33 @@ func (s *Service) beaconEndpoints(
 			handler: server.GetAttesterSlashings,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/eth/v2/beacon/pool/attester_slashings",
+			name:     namespace + ".GetAttesterSlashingsV2",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetAttesterSlashingsV2,
+			methods: []string{http.MethodGet},
+		},
 		{
 			template: "/eth/v1/beacon/pool/attester_slashings",
-			name:     namespace + ".SubmitAttesterSlashing",
+			name:     namespace + ".SubmitAttesterSlashings",
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
-			handler: server.SubmitAttesterSlashing,
+			handler: server.SubmitAttesterSlashings,
+			methods: []string{http.MethodPost},
+		},
+		{
+			template: "/eth/v2/beacon/pool/attester_slashings",
+			name:     namespace + ".SubmitAttesterSlashingsV2",
+			middleware: []middleware.Middleware{
+				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.SubmitAttesterSlashingsV2,
 			methods: []string{http.MethodPost},
 		},
 		{

beacon-chain/rpc/endpoints_test.go

@@ -42,6 +42,7 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/beacon/blinded_blocks/{block_id}":                   {http.MethodGet},
 		"/eth/v1/beacon/pool/attestations":                           {http.MethodGet, http.MethodPost},
 		"/eth/v1/beacon/pool/attester_slashings":                     {http.MethodGet, http.MethodPost},
+		"/eth/v2/beacon/pool/attester_slashings":                     {http.MethodGet, http.MethodPost},
 		"/eth/v1/beacon/pool/proposer_slashings":                     {http.MethodGet, http.MethodPost},
 		"/eth/v1/beacon/pool/sync_committees":                        {http.MethodPost},
 		"/eth/v1/beacon/pool/voluntary_exits":                        {http.MethodGet, http.MethodPost},
@@ -100,6 +101,7 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/validator/attestation_data":               {http.MethodGet},
 		"/eth/v1/validator/aggregate_attestation":          {http.MethodGet},
 		"/eth/v1/validator/aggregate_and_proofs":           {http.MethodPost},
+		"/eth/v2/validator/aggregate_and_proofs":           {http.MethodPost},
 		"/eth/v1/validator/beacon_committee_subscriptions": {http.MethodPost},
 		"/eth/v1/validator/sync_committee_subscriptions":   {http.MethodPost},
 		"/eth/v1/validator/beacon_committee_selections":    {http.MethodPost},

beacon-chain/rpc/eth/beacon/handlers_pool.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
@@ -467,25 +468,71 @@ func (s *Server) GetAttesterSlashings(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	sourceSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, headState, true /* return unlimited slashings */)
-	ss := make([]*eth.AttesterSlashing, 0, len(sourceSlashings))
-	for _, slashing := range sourceSlashings {
-		s, ok := slashing.(*eth.AttesterSlashing)
-		if ok {
-			ss = append(ss, s)
-		} else {
-			httputil.HandleError(w, fmt.Sprintf("unable to convert slashing of type %T", slashing), http.StatusInternalServerError)
+	slashings := make([]*structs.AttesterSlashing, len(sourceSlashings))
+	for i, slashing := range sourceSlashings {
+		as, ok := slashing.(*eth.AttesterSlashing)
+		if !ok {
+			httputil.HandleError(w, fmt.Sprintf("Unable to convert slashing of type %T", slashing), http.StatusInternalServerError)
 			return
 		}
+		slashings[i] = structs.AttesterSlashingFromConsensus(as)
 	}
-	slashings := structs.AttesterSlashingsFromConsensus(ss)
-
-	httputil.WriteJson(w, &structs.GetAttesterSlashingsResponse{Data: slashings})
+	attBytes, err := json.Marshal(slashings)
+	if err != nil {
+		httputil.HandleError(w, fmt.Sprintf("Failed to marshal slashings: %v", err), http.StatusInternalServerError)
+		return
+	}
+	httputil.WriteJson(w, &structs.GetAttesterSlashingsResponse{Data: attBytes})
 }
 
-// SubmitAttesterSlashing submits an attester slashing object to node's pool and
+// GetAttesterSlashingsV2 retrieves attester slashings known by the node but
+// not necessarily incorporated into any block, supporting both AttesterSlashing and AttesterSlashingElectra.
+func (s *Server) GetAttesterSlashingsV2(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetAttesterSlashingsV2")
+	defer span.End()
+
+	headState, err := s.ChainInfoFetcher.HeadStateReadOnly(ctx)
+	if err != nil {
+		httputil.HandleError(w, "Could not get head state: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	var attStructs []interface{}
+	sourceSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, headState, true /* return unlimited slashings */)
+	for _, slashing := range sourceSlashings {
+		if slashing.Version() >= version.Electra {
+			a, ok := slashing.(*eth.AttesterSlashingElectra)
+			if !ok {
+				httputil.HandleError(w, fmt.Sprintf("Unable to convert electra slashing of type %T to an Electra slashing", slashing), http.StatusInternalServerError)
+				return
+			}
+			attStruct := structs.AttesterSlashingElectraFromConsensus(a)
+			attStructs = append(attStructs, attStruct)
+		} else {
+			a, ok := slashing.(*eth.AttesterSlashing)
+			if !ok {
+				httputil.HandleError(w, fmt.Sprintf("Unable to convert slashing of type %T to a Phase0 slashing", slashing), http.StatusInternalServerError)
+				return
+			}
+			attStruct := structs.AttesterSlashingFromConsensus(a)
+			attStructs = append(attStructs, attStruct)
+		}
+	}
+	attBytes, err := json.Marshal(attStructs)
+	if err != nil {
+		httputil.HandleError(w, fmt.Sprintf("Failed to marshal slashing: %v", err), http.StatusInternalServerError)
+		return
+	}
+	resp := &structs.GetAttesterSlashingsResponse{
+		Version: version.String(sourceSlashings[0].Version()),
+		Data:    attBytes,
+	}
+	httputil.WriteJson(w, resp)
+}
+
+// SubmitAttesterSlashings submits an attester slashing object to node's pool and
 // if passes validation node MUST broadcast it to network.
-func (s *Server) SubmitAttesterSlashing(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "beacon.SubmitAttesterSlashing")
+func (s *Server) SubmitAttesterSlashings(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.SubmitAttesterSlashings")
 	defer span.End()
 
 	var req structs.AttesterSlashing
@@ -504,16 +551,80 @@ func (s *Server) SubmitAttesterSlashing(w http.ResponseWriter, r *http.Request)
 		httputil.HandleError(w, "Could not convert request slashing to consensus slashing: "+err.Error(), http.StatusBadRequest)
 		return
 	}
+	s.submitAttesterSlashing(w, ctx, slashing)
+}
+
+// SubmitAttesterSlashingsV2 submits an attester slashing object to node's pool and
+// if passes validation node MUST broadcast it to network.
+func (s *Server) SubmitAttesterSlashingsV2(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.SubmitAttesterSlashingsV2")
+	defer span.End()
+
+	versionHeader := r.Header.Get(api.VersionHeader)
+	if versionHeader == "" {
+		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
+	}
+	v, err := version.FromString(versionHeader)
+	if err != nil {
+		httputil.HandleError(w, "Invalid version: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if v >= version.Electra {
+		var req structs.AttesterSlashingElectra
+		err := json.NewDecoder(r.Body).Decode(&req)
+		switch {
+		case errors.Is(err, io.EOF):
+			httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
+			return
+		case err != nil:
+			httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		slashing, err := req.ToConsensus()
+		if err != nil {
+			httputil.HandleError(w, "Could not convert request slashing to consensus slashing: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		s.submitAttesterSlashing(w, ctx, slashing)
+	} else {
+		var req structs.AttesterSlashing
+		err := json.NewDecoder(r.Body).Decode(&req)
+		switch {
+		case errors.Is(err, io.EOF):
+			httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
+			return
+		case err != nil:
+			httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		slashing, err := req.ToConsensus()
+		if err != nil {
+			httputil.HandleError(w, "Could not convert request slashing to consensus slashing: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		s.submitAttesterSlashing(w, ctx, slashing)
+	}
+}
+
+func (s *Server) submitAttesterSlashing(
+	w http.ResponseWriter,
+	ctx context.Context,
+	slashing eth.AttSlashing,
+) {
 	headState, err := s.ChainInfoFetcher.HeadState(ctx)
 	if err != nil {
 		httputil.HandleError(w, "Could not get head state: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	headState, err = transition.ProcessSlotsIfPossible(ctx, headState, slashing.Attestation_1.Data.Slot)
+	headState, err = transition.ProcessSlotsIfPossible(ctx, headState, slashing.FirstAttestation().GetData().Slot)
 	if err != nil {
 		httputil.HandleError(w, "Could not process slots: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
+
 	err = blocks.VerifyAttesterSlashing(ctx, headState, slashing)
 	if err != nil {
 		httputil.HandleError(w, "Invalid attester slashing: "+err.Error(), http.StatusBadRequest)

beacon-chain/rpc/eth/beacon/handlers_pool_test.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	blockchainmock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
@@ -37,6 +38,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbv1alpha1 "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -983,9 +985,7 @@ func TestSubmitSignedBLSToExecutionChanges_Failures(t *testing.T) {
 }
 
 func TestGetAttesterSlashings(t *testing.T) {
-	bs, err := util.NewBeaconState()
-	require.NoError(t, err)
-	slashing1 := &ethpbv1alpha1.AttesterSlashing{
+	slashing1PreElectra := &ethpbv1alpha1.AttesterSlashing{
 		Attestation_1: &ethpbv1alpha1.IndexedAttestation{
 			AttestingIndices: []uint64{1, 10},
 			Data: &ethpbv1alpha1.AttestationData{
@@ -1021,7 +1021,7 @@ func TestGetAttesterSlashings(t *testing.T) {
 			Signature: bytesutil.PadTo([]byte("signature2"), 96),
 		},
 	}
-	slashing2 := &ethpbv1alpha1.AttesterSlashing{
+	slashing2PreElectra := &ethpbv1alpha1.AttesterSlashing{
 		Attestation_1: &ethpbv1alpha1.IndexedAttestation{
 			AttestingIndices: []uint64{3, 30},
 			Data: &ethpbv1alpha1.AttestationData{
@@ -1057,23 +1057,168 @@ func TestGetAttesterSlashings(t *testing.T) {
 			Signature: bytesutil.PadTo([]byte("signature4"), 96),
 		},
 	}
-
-	s := &Server{
-		ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
-		SlashingsPool:    &slashingsmock.PoolMock{PendingAttSlashings: []ethpbv1alpha1.AttSlashing{slashing1, slashing2}},
+	slashing1PostElectra := &ethpbv1alpha1.AttesterSlashingElectra{
+		Attestation_1: &ethpbv1alpha1.IndexedAttestationElectra{
+			AttestingIndices: []uint64{1, 10},
+			Data: &ethpbv1alpha1.AttestationData{
+				Slot:            1,
+				CommitteeIndex:  1,
+				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot1"), 32),
+				Source: &ethpbv1alpha1.Checkpoint{
+					Epoch: 1,
+					Root:  bytesutil.PadTo([]byte("sourceroot1"), 32),
+				},
+				Target: &ethpbv1alpha1.Checkpoint{
+					Epoch: 10,
+					Root:  bytesutil.PadTo([]byte("targetroot1"), 32),
+				},
+			},
+			Signature: bytesutil.PadTo([]byte("signature1"), 96),
+		},
+		Attestation_2: &ethpbv1alpha1.IndexedAttestationElectra{
+			AttestingIndices: []uint64{2, 20},
+			Data: &ethpbv1alpha1.AttestationData{
+				Slot:            2,
+				CommitteeIndex:  2,
+				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot2"), 32),
+				Source: &ethpbv1alpha1.Checkpoint{
+					Epoch: 2,
+					Root:  bytesutil.PadTo([]byte("sourceroot2"), 32),
+				},
+				Target: &ethpbv1alpha1.Checkpoint{
+					Epoch: 20,
+					Root:  bytesutil.PadTo([]byte("targetroot2"), 32),
+				},
+			},
+			Signature: bytesutil.PadTo([]byte("signature2"), 96),
+		},
+	}
+	slashing2PostElectra := &ethpbv1alpha1.AttesterSlashingElectra{
+		Attestation_1: &ethpbv1alpha1.IndexedAttestationElectra{
+			AttestingIndices: []uint64{3, 30},
+			Data: &ethpbv1alpha1.AttestationData{
+				Slot:            3,
+				CommitteeIndex:  3,
+				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot3"), 32),
+				Source: &ethpbv1alpha1.Checkpoint{
+					Epoch: 3,
+					Root:  bytesutil.PadTo([]byte("sourceroot3"), 32),
+				},
+				Target: &ethpbv1alpha1.Checkpoint{
+					Epoch: 30,
+					Root:  bytesutil.PadTo([]byte("targetroot3"), 32),
+				},
+			},
+			Signature: bytesutil.PadTo([]byte("signature3"), 96),
+		},
+		Attestation_2: &ethpbv1alpha1.IndexedAttestationElectra{
+			AttestingIndices: []uint64{4, 40},
+			Data: &ethpbv1alpha1.AttestationData{
+				Slot:            4,
+				CommitteeIndex:  4,
+				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot4"), 32),
+				Source: &ethpbv1alpha1.Checkpoint{
+					Epoch: 4,
+					Root:  bytesutil.PadTo([]byte("sourceroot4"), 32),
+				},
+				Target: &ethpbv1alpha1.Checkpoint{
+					Epoch: 40,
+					Root:  bytesutil.PadTo([]byte("targetroot4"), 32),
+				},
+			},
+			Signature: bytesutil.PadTo([]byte("signature4"), 96),
+		},
 	}
 
-	request := httptest.NewRequest(http.MethodGet, "http://example.com/beacon/pool/attester_slashings", nil)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
+	t.Run("V1", func(t *testing.T) {
+		bs, err := util.NewBeaconState()
+		require.NoError(t, err)
 
-	s.GetAttesterSlashings(writer, request)
-	require.Equal(t, http.StatusOK, writer.Code)
-	resp := &structs.GetAttesterSlashingsResponse{}
-	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-	require.NotNil(t, resp)
-	require.NotNil(t, resp.Data)
-	assert.Equal(t, 2, len(resp.Data))
+		s := &Server{
+			ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
+			SlashingsPool:    &slashingsmock.PoolMock{PendingAttSlashings: []ethpbv1alpha1.AttSlashing{slashing1PreElectra, slashing2PreElectra}},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/pool/attester_slashings", nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAttesterSlashings(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetAttesterSlashingsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.NotNil(t, resp)
+		require.NotNil(t, resp.Data)
+
+		var slashings []*structs.AttesterSlashing
+		require.NoError(t, json.Unmarshal(resp.Data, &slashings))
+
+		ss, err := structs.AttesterSlashingsToConsensus(slashings)
+		require.NoError(t, err)
+
+		require.DeepEqual(t, slashing1PreElectra, ss[0])
+		require.DeepEqual(t, slashing2PreElectra, ss[1])
+	})
+	t.Run("V2-post-electra", func(t *testing.T) {
+		bs, err := util.NewBeaconStateElectra()
+		require.NoError(t, err)
+
+		s := &Server{
+			ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
+			SlashingsPool:    &slashingsmock.PoolMock{PendingAttSlashings: []ethpbv1alpha1.AttSlashing{slashing1PostElectra, slashing2PostElectra}},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/beacon/pool/attester_slashings", nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAttesterSlashingsV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetAttesterSlashingsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.NotNil(t, resp)
+		require.NotNil(t, resp.Data)
+		assert.Equal(t, "electra", resp.Version)
+
+		// Unmarshal resp.Data into a slice of slashings
+		var slashings []*structs.AttesterSlashingElectra
+		require.NoError(t, json.Unmarshal(resp.Data, &slashings))
+
+		ss, err := structs.AttesterSlashingsElectraToConsensus(slashings)
+		require.NoError(t, err)
+
+		require.DeepEqual(t, slashing1PostElectra, ss[0])
+		require.DeepEqual(t, slashing2PostElectra, ss[1])
+	})
+	t.Run("V2-pre-electra", func(t *testing.T) {
+		bs, err := util.NewBeaconState()
+		require.NoError(t, err)
+
+		s := &Server{
+			ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
+			SlashingsPool:    &slashingsmock.PoolMock{PendingAttSlashings: []ethpbv1alpha1.AttSlashing{slashing1PreElectra, slashing2PreElectra}},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/pool/attester_slashings", nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAttesterSlashingsV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetAttesterSlashingsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.NotNil(t, resp)
+		require.NotNil(t, resp.Data)
+
+		var slashings []*structs.AttesterSlashing
+		require.NoError(t, json.Unmarshal(resp.Data, &slashings))
+
+		ss, err := structs.AttesterSlashingsToConsensus(slashings)
+		require.NoError(t, err)
+
+		require.DeepEqual(t, slashing1PreElectra, ss[0])
+		require.DeepEqual(t, slashing2PreElectra, ss[1])
+	})
 }
 
 func TestGetProposerSlashings(t *testing.T) {
@@ -1142,383 +1287,350 @@ func TestGetProposerSlashings(t *testing.T) {
 	assert.Equal(t, 2, len(resp.Data))
 }
 
-func TestSubmitAttesterSlashing_Ok(t *testing.T) {
+func TestSubmitAttesterSlashings(t *testing.T) {
 	ctx := context.Background()
 
 	transition.SkipSlotCache.Disable()
 	defer transition.SkipSlotCache.Enable()
 
-	_, keys, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	validator := &ethpbv1alpha1.Validator{
-		PublicKey: keys[0].PublicKey().Marshal(),
+	attestationData1 := &ethpbv1alpha1.AttestationData{
+		CommitteeIndex:  1,
+		BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot1"), 32),
+		Source: &ethpbv1alpha1.Checkpoint{
+			Epoch: 1,
+			Root:  bytesutil.PadTo([]byte("sourceroot1"), 32),
+		},
+		Target: &ethpbv1alpha1.Checkpoint{
+			Epoch: 10,
+			Root:  bytesutil.PadTo([]byte("targetroot1"), 32),
+		},
 	}
-	bs, err := util.NewBeaconState(func(state *ethpbv1alpha1.BeaconState) error {
-		state.Validators = []*ethpbv1alpha1.Validator{validator}
-		return nil
+	attestationData2 := &ethpbv1alpha1.AttestationData{
+		CommitteeIndex:  1,
+		BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot2"), 32),
+		Source: &ethpbv1alpha1.Checkpoint{
+			Epoch: 1,
+			Root:  bytesutil.PadTo([]byte("sourceroot2"), 32),
+		},
+		Target: &ethpbv1alpha1.Checkpoint{
+			Epoch: 10,
+			Root:  bytesutil.PadTo([]byte("targetroot2"), 32),
+		},
+	}
+
+	t.Run("V1", func(t *testing.T) {
+		t.Run("ok", func(t *testing.T) {
+			attestationData1.Slot = 1
+			attestationData2.Slot = 1
+			slashing := &ethpbv1alpha1.AttesterSlashing{
+				Attestation_1: &ethpbv1alpha1.IndexedAttestation{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData1,
+					Signature:        make([]byte, 96),
+				},
+				Attestation_2: &ethpbv1alpha1.IndexedAttestation{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData2,
+					Signature:        make([]byte, 96),
+				},
+			}
+
+			_, keys, err := util.DeterministicDepositsAndKeys(1)
+			require.NoError(t, err)
+			validator := &ethpbv1alpha1.Validator{
+				PublicKey: keys[0].PublicKey().Marshal(),
+			}
+
+			bs, err := util.NewBeaconState(func(state *ethpbv1alpha1.BeaconState) error {
+				state.Validators = []*ethpbv1alpha1.Validator{validator}
+				return nil
+			})
+			require.NoError(t, err)
+
+			for _, att := range []*ethpbv1alpha1.IndexedAttestation{slashing.Attestation_1, slashing.Attestation_2} {
+				sb, err := signing.ComputeDomainAndSign(bs, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, keys[0])
+				require.NoError(t, err)
+				sig, err := bls.SignatureFromBytes(sb)
+				require.NoError(t, err)
+				att.Signature = sig.Marshal()
+			}
+
+			chainmock := &blockchainmock.ChainService{State: bs}
+			broadcaster := &p2pMock.MockBroadcaster{}
+			s := &Server{
+				ChainInfoFetcher:  chainmock,
+				SlashingsPool:     &slashingsmock.PoolMock{},
+				Broadcaster:       broadcaster,
+				OperationNotifier: chainmock.OperationNotifier(),
+			}
+
+			toSubmit := structs.AttesterSlashingsFromConsensus([]*ethpbv1alpha1.AttesterSlashing{slashing})
+			b, err := json.Marshal(toSubmit[0])
+			require.NoError(t, err)
+			var body bytes.Buffer
+			_, err = body.Write(b)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAttesterSlashings(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			pendingSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, bs, true)
+			require.Equal(t, 1, len(pendingSlashings))
+			assert.DeepEqual(t, slashing, pendingSlashings[0])
+			require.Equal(t, 1, broadcaster.NumMessages())
+			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
+			_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashing)
+			assert.Equal(t, true, ok)
+		})
+		t.Run("accross-fork", func(t *testing.T) {
+			attestationData1.Slot = params.BeaconConfig().SlotsPerEpoch
+			attestationData2.Slot = params.BeaconConfig().SlotsPerEpoch
+			slashing := &ethpbv1alpha1.AttesterSlashing{
+				Attestation_1: &ethpbv1alpha1.IndexedAttestation{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData1,
+					Signature:        make([]byte, 96),
+				},
+				Attestation_2: &ethpbv1alpha1.IndexedAttestation{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData2,
+					Signature:        make([]byte, 96),
+				},
+			}
+
+			params.SetupTestConfigCleanup(t)
+			config := params.BeaconConfig()
+			config.AltairForkEpoch = 1
+			params.OverrideBeaconConfig(config)
+
+			bs, keys := util.DeterministicGenesisState(t, 1)
+			newBs := bs.Copy()
+			newBs, err := transition.ProcessSlots(ctx, newBs, params.BeaconConfig().SlotsPerEpoch)
+			require.NoError(t, err)
+
+			for _, att := range []*ethpbv1alpha1.IndexedAttestation{slashing.Attestation_1, slashing.Attestation_2} {
+				sb, err := signing.ComputeDomainAndSign(newBs, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, keys[0])
+				require.NoError(t, err)
+				sig, err := bls.SignatureFromBytes(sb)
+				require.NoError(t, err)
+				att.Signature = sig.Marshal()
+			}
+
+			broadcaster := &p2pMock.MockBroadcaster{}
+			chainmock := &blockchainmock.ChainService{State: bs}
+			s := &Server{
+				ChainInfoFetcher:  chainmock,
+				SlashingsPool:     &slashingsmock.PoolMock{},
+				Broadcaster:       broadcaster,
+				OperationNotifier: chainmock.OperationNotifier(),
+			}
+
+			toSubmit := structs.AttesterSlashingsFromConsensus([]*ethpbv1alpha1.AttesterSlashing{slashing})
+			b, err := json.Marshal(toSubmit[0])
+			require.NoError(t, err)
+			var body bytes.Buffer
+			_, err = body.Write(b)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAttesterSlashings(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			pendingSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, bs, true)
+			require.Equal(t, 1, len(pendingSlashings))
+			assert.DeepEqual(t, slashing, pendingSlashings[0])
+			require.Equal(t, 1, broadcaster.NumMessages())
+			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
+			_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashing)
+			assert.Equal(t, true, ok)
+		})
+		t.Run("invalid-slashing", func(t *testing.T) {
+			bs, err := util.NewBeaconState()
+			require.NoError(t, err)
+
+			broadcaster := &p2pMock.MockBroadcaster{}
+			s := &Server{
+				ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
+				SlashingsPool:    &slashingsmock.PoolMock{},
+				Broadcaster:      broadcaster,
+			}
+
+			var body bytes.Buffer
+			_, err = body.WriteString(invalidAttesterSlashing)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAttesterSlashings(writer, request)
+			require.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.StringContains(t, "Invalid attester slashing", e.Message)
+		})
 	})
-	require.NoError(t, err)
-
-	slashing := &ethpbv1alpha1.AttesterSlashing{
-		Attestation_1: &ethpbv1alpha1.IndexedAttestation{
-			AttestingIndices: []uint64{0},
-			Data: &ethpbv1alpha1.AttestationData{
-				Slot:            1,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot1"), 32),
-				Source: &ethpbv1alpha1.Checkpoint{
-					Epoch: 1,
-					Root:  bytesutil.PadTo([]byte("sourceroot1"), 32),
+	t.Run("V2", func(t *testing.T) {
+		t.Run("ok", func(t *testing.T) {
+			attestationData1.Slot = 1
+			attestationData2.Slot = 1
+			electraSlashing := &ethpbv1alpha1.AttesterSlashingElectra{
+				Attestation_1: &ethpbv1alpha1.IndexedAttestationElectra{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData1,
+					Signature:        make([]byte, 96),
 				},
-				Target: &ethpbv1alpha1.Checkpoint{
-					Epoch: 10,
-					Root:  bytesutil.PadTo([]byte("targetroot1"), 32),
+				Attestation_2: &ethpbv1alpha1.IndexedAttestationElectra{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData2,
+					Signature:        make([]byte, 96),
 				},
-			},
-			Signature: make([]byte, 96),
-		},
-		Attestation_2: &ethpbv1alpha1.IndexedAttestation{
-			AttestingIndices: []uint64{0},
-			Data: &ethpbv1alpha1.AttestationData{
-				Slot:            1,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot2"), 32),
-				Source: &ethpbv1alpha1.Checkpoint{
-					Epoch: 1,
-					Root:  bytesutil.PadTo([]byte("sourceroot2"), 32),
+			}
+
+			_, keys, err := util.DeterministicDepositsAndKeys(1)
+			require.NoError(t, err)
+			validator := &ethpbv1alpha1.Validator{
+				PublicKey: keys[0].PublicKey().Marshal(),
+			}
+
+			ebs, err := util.NewBeaconStateElectra(func(state *ethpbv1alpha1.BeaconStateElectra) error {
+				state.Validators = []*ethpbv1alpha1.Validator{validator}
+				return nil
+			})
+			require.NoError(t, err)
+
+			for _, att := range []*ethpbv1alpha1.IndexedAttestationElectra{electraSlashing.Attestation_1, electraSlashing.Attestation_2} {
+				sb, err := signing.ComputeDomainAndSign(ebs, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, keys[0])
+				require.NoError(t, err)
+				sig, err := bls.SignatureFromBytes(sb)
+				require.NoError(t, err)
+				att.Signature = sig.Marshal()
+			}
+
+			chainmock := &blockchainmock.ChainService{State: ebs}
+			broadcaster := &p2pMock.MockBroadcaster{}
+			s := &Server{
+				ChainInfoFetcher:  chainmock,
+				SlashingsPool:     &slashingsmock.PoolMock{},
+				Broadcaster:       broadcaster,
+				OperationNotifier: chainmock.OperationNotifier(),
+			}
+
+			toSubmit := structs.AttesterSlashingsElectraFromConsensus([]*ethpbv1alpha1.AttesterSlashingElectra{electraSlashing})
+			b, err := json.Marshal(toSubmit[0])
+			require.NoError(t, err)
+			var body bytes.Buffer
+			_, err = body.Write(b)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_electras", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAttesterSlashingsV2(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			pendingSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, ebs, true)
+			require.Equal(t, 1, len(pendingSlashings))
+			require.Equal(t, 1, broadcaster.NumMessages())
+			assert.DeepEqual(t, electraSlashing, pendingSlashings[0])
+			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
+			_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashingElectra)
+			assert.Equal(t, true, ok)
+		})
+		t.Run("accross-fork", func(t *testing.T) {
+			attestationData1.Slot = params.BeaconConfig().SlotsPerEpoch
+			attestationData2.Slot = params.BeaconConfig().SlotsPerEpoch
+			slashing := &ethpbv1alpha1.AttesterSlashingElectra{
+				Attestation_1: &ethpbv1alpha1.IndexedAttestationElectra{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData1,
+					Signature:        make([]byte, 96),
 				},
-				Target: &ethpbv1alpha1.Checkpoint{
-					Epoch: 10,
-					Root:  bytesutil.PadTo([]byte("targetroot2"), 32),
+				Attestation_2: &ethpbv1alpha1.IndexedAttestationElectra{
+					AttestingIndices: []uint64{0},
+					Data:             attestationData2,
+					Signature:        make([]byte, 96),
 				},
-			},
-			Signature: make([]byte, 96),
-		},
-	}
+			}
 
-	for _, att := range []*ethpbv1alpha1.IndexedAttestation{slashing.Attestation_1, slashing.Attestation_2} {
-		sb, err := signing.ComputeDomainAndSign(bs, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, keys[0])
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		att.Signature = sig.Marshal()
-	}
+			params.SetupTestConfigCleanup(t)
+			config := params.BeaconConfig()
+			config.AltairForkEpoch = 1
+			params.OverrideBeaconConfig(config)
 
-	broadcaster := &p2pMock.MockBroadcaster{}
-	chainmock := &blockchainmock.ChainService{State: bs}
-	s := &Server{
-		ChainInfoFetcher:  chainmock,
-		SlashingsPool:     &slashingsmock.PoolMock{},
-		Broadcaster:       broadcaster,
-		OperationNotifier: chainmock.OperationNotifier(),
-	}
+			bs, keys := util.DeterministicGenesisState(t, 1)
+			newBs := bs.Copy()
+			newBs, err := transition.ProcessSlots(ctx, newBs, params.BeaconConfig().SlotsPerEpoch)
+			require.NoError(t, err)
 
-	toSubmit := structs.AttesterSlashingsFromConsensus([]*ethpbv1alpha1.AttesterSlashing{slashing})
-	b, err := json.Marshal(toSubmit[0])
-	require.NoError(t, err)
-	var body bytes.Buffer
-	_, err = body.Write(b)
-	require.NoError(t, err)
-	request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
+			for _, att := range []*ethpbv1alpha1.IndexedAttestationElectra{slashing.Attestation_1, slashing.Attestation_2} {
+				sb, err := signing.ComputeDomainAndSign(newBs, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, keys[0])
+				require.NoError(t, err)
+				sig, err := bls.SignatureFromBytes(sb)
+				require.NoError(t, err)
+				att.Signature = sig.Marshal()
+			}
 
-	s.SubmitAttesterSlashing(writer, request)
-	require.Equal(t, http.StatusOK, writer.Code)
-	pendingSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, bs, true)
-	require.Equal(t, 1, len(pendingSlashings))
-	assert.DeepEqual(t, slashing, pendingSlashings[0])
-	assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
-	require.Equal(t, 1, broadcaster.NumMessages())
-	_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashing)
-	assert.Equal(t, true, ok)
-}
+			broadcaster := &p2pMock.MockBroadcaster{}
+			chainmock := &blockchainmock.ChainService{State: bs}
+			s := &Server{
+				ChainInfoFetcher:  chainmock,
+				SlashingsPool:     &slashingsmock.PoolMock{},
+				Broadcaster:       broadcaster,
+				OperationNotifier: chainmock.OperationNotifier(),
+			}
 
-func TestSubmitAttesterSlashing_AcrossFork(t *testing.T) {
-	ctx := context.Background()
+			toSubmit := structs.AttesterSlashingsElectraFromConsensus([]*ethpbv1alpha1.AttesterSlashingElectra{slashing})
+			b, err := json.Marshal(toSubmit[0])
+			require.NoError(t, err)
+			var body bytes.Buffer
+			_, err = body.Write(b)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
 
-	transition.SkipSlotCache.Disable()
-	defer transition.SkipSlotCache.Enable()
-
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.AltairForkEpoch = 1
-	params.OverrideBeaconConfig(config)
-
-	bs, keys := util.DeterministicGenesisState(t, 1)
-
-	slashing := &ethpbv1alpha1.AttesterSlashing{
-		Attestation_1: &ethpbv1alpha1.IndexedAttestation{
-			AttestingIndices: []uint64{0},
-			Data: &ethpbv1alpha1.AttestationData{
-				Slot:            params.BeaconConfig().SlotsPerEpoch,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot1"), 32),
-				Source: &ethpbv1alpha1.Checkpoint{
-					Epoch: 1,
-					Root:  bytesutil.PadTo([]byte("sourceroot1"), 32),
-				},
-				Target: &ethpbv1alpha1.Checkpoint{
-					Epoch: 10,
-					Root:  bytesutil.PadTo([]byte("targetroot1"), 32),
-				},
-			},
-			Signature: make([]byte, 96),
-		},
-		Attestation_2: &ethpbv1alpha1.IndexedAttestation{
-			AttestingIndices: []uint64{0},
-			Data: &ethpbv1alpha1.AttestationData{
-				Slot:            params.BeaconConfig().SlotsPerEpoch,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot2"), 32),
-				Source: &ethpbv1alpha1.Checkpoint{
-					Epoch: 1,
-					Root:  bytesutil.PadTo([]byte("sourceroot2"), 32),
-				},
-				Target: &ethpbv1alpha1.Checkpoint{
-					Epoch: 10,
-					Root:  bytesutil.PadTo([]byte("targetroot2"), 32),
-				},
-			},
-			Signature: make([]byte, 96),
-		},
-	}
-
-	newBs := bs.Copy()
-	newBs, err := transition.ProcessSlots(ctx, newBs, params.BeaconConfig().SlotsPerEpoch)
-	require.NoError(t, err)
-
-	for _, att := range []*ethpbv1alpha1.IndexedAttestation{slashing.Attestation_1, slashing.Attestation_2} {
-		sb, err := signing.ComputeDomainAndSign(newBs, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, keys[0])
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		att.Signature = sig.Marshal()
-	}
-
-	broadcaster := &p2pMock.MockBroadcaster{}
-	chainmock := &blockchainmock.ChainService{State: bs}
-	s := &Server{
-		ChainInfoFetcher:  chainmock,
-		SlashingsPool:     &slashingsmock.PoolMock{},
-		Broadcaster:       broadcaster,
-		OperationNotifier: chainmock.OperationNotifier(),
-	}
-
-	toSubmit := structs.AttesterSlashingsFromConsensus([]*ethpbv1alpha1.AttesterSlashing{slashing})
-	b, err := json.Marshal(toSubmit[0])
-	require.NoError(t, err)
-	var body bytes.Buffer
-	_, err = body.Write(b)
-	require.NoError(t, err)
-	request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
-
-	s.SubmitAttesterSlashing(writer, request)
-	require.Equal(t, http.StatusOK, writer.Code)
-	pendingSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, bs, true)
-	require.Equal(t, 1, len(pendingSlashings))
-	assert.DeepEqual(t, slashing, pendingSlashings[0])
-	assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
-	require.Equal(t, 1, broadcaster.NumMessages())
-	_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashing)
-	assert.Equal(t, true, ok)
-}
-
-func TestSubmitAttesterSlashing_InvalidSlashing(t *testing.T) {
-	bs, err := util.NewBeaconState()
-	require.NoError(t, err)
-
-	broadcaster := &p2pMock.MockBroadcaster{}
-	s := &Server{
-		ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
-		SlashingsPool:    &slashingsmock.PoolMock{},
-		Broadcaster:      broadcaster,
-	}
-
-	var body bytes.Buffer
-	_, err = body.WriteString(invalidAttesterSlashing)
-	require.NoError(t, err)
-	request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
-
-	s.SubmitAttesterSlashing(writer, request)
-	require.Equal(t, http.StatusBadRequest, writer.Code)
-	e := &httputil.DefaultJsonError{}
-	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-	assert.Equal(t, http.StatusBadRequest, e.Code)
-	assert.StringContains(t, "Invalid attester slashing", e.Message)
-}
-
-func TestSubmitProposerSlashing_Ok(t *testing.T) {
-	ctx := context.Background()
-
-	transition.SkipSlotCache.Disable()
-	defer transition.SkipSlotCache.Enable()
-
-	_, keys, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	validator := &ethpbv1alpha1.Validator{
-		PublicKey:         keys[0].PublicKey().Marshal(),
-		WithdrawableEpoch: primitives.Epoch(1),
-	}
-	bs, err := util.NewBeaconState(func(state *ethpbv1alpha1.BeaconState) error {
-		state.Validators = []*ethpbv1alpha1.Validator{validator}
-		return nil
+			s.SubmitAttesterSlashingsV2(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			pendingSlashings := s.SlashingsPool.PendingAttesterSlashings(ctx, bs, true)
+			require.Equal(t, 1, len(pendingSlashings))
+			assert.DeepEqual(t, slashing, pendingSlashings[0])
+			require.Equal(t, 1, broadcaster.NumMessages())
+			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
+			_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashingElectra)
+			assert.Equal(t, true, ok)
+		})
 	})
-	require.NoError(t, err)
-
-	slashing := &ethpbv1alpha1.ProposerSlashing{
-		Header_1: &ethpbv1alpha1.SignedBeaconBlockHeader{
-			Header: &ethpbv1alpha1.BeaconBlockHeader{
-				Slot:          1,
-				ProposerIndex: 0,
-				ParentRoot:    bytesutil.PadTo([]byte("parentroot1"), 32),
-				StateRoot:     bytesutil.PadTo([]byte("stateroot1"), 32),
-				BodyRoot:      bytesutil.PadTo([]byte("bodyroot1"), 32),
-			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpbv1alpha1.SignedBeaconBlockHeader{
-			Header: &ethpbv1alpha1.BeaconBlockHeader{
-				Slot:          1,
-				ProposerIndex: 0,
-				ParentRoot:    bytesutil.PadTo([]byte("parentroot2"), 32),
-				StateRoot:     bytesutil.PadTo([]byte("stateroot2"), 32),
-				BodyRoot:      bytesutil.PadTo([]byte("bodyroot2"), 32),
-			},
-			Signature: make([]byte, 96),
-		},
-	}
-
-	for _, h := range []*ethpbv1alpha1.SignedBeaconBlockHeader{slashing.Header_1, slashing.Header_2} {
-		sb, err := signing.ComputeDomainAndSign(
-			bs,
-			slots.ToEpoch(h.Header.Slot),
-			h.Header,
-			params.BeaconConfig().DomainBeaconProposer,
-			keys[0],
-		)
+	t.Run("invalid-slashing", func(t *testing.T) {
+		bs, err := util.NewBeaconStateElectra()
 		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
+
+		broadcaster := &p2pMock.MockBroadcaster{}
+		s := &Server{
+			ChainInfoFetcher: &blockchainmock.ChainService{State: bs},
+			SlashingsPool:    &slashingsmock.PoolMock{},
+			Broadcaster:      broadcaster,
+		}
+
+		var body bytes.Buffer
+		_, err = body.WriteString(invalidAttesterSlashing)
 		require.NoError(t, err)
-		h.Signature = sig.Marshal()
-	}
+		request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/attester_slashings", &body)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
 
-	broadcaster := &p2pMock.MockBroadcaster{}
-	chainmock := &blockchainmock.ChainService{State: bs}
-	s := &Server{
-		ChainInfoFetcher:  chainmock,
-		SlashingsPool:     &slashingsmock.PoolMock{},
-		Broadcaster:       broadcaster,
-		OperationNotifier: chainmock.OperationNotifier(),
-	}
-
-	toSubmit := structs.ProposerSlashingsFromConsensus([]*ethpbv1alpha1.ProposerSlashing{slashing})
-	b, err := json.Marshal(toSubmit[0])
-	require.NoError(t, err)
-	var body bytes.Buffer
-	_, err = body.Write(b)
-	require.NoError(t, err)
-	request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/proposer_slashings", &body)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
-
-	s.SubmitProposerSlashing(writer, request)
-	require.Equal(t, http.StatusOK, writer.Code)
-	pendingSlashings := s.SlashingsPool.PendingProposerSlashings(ctx, bs, true)
-	require.Equal(t, 1, len(pendingSlashings))
-	assert.DeepEqual(t, slashing, pendingSlashings[0])
-	assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
-	require.Equal(t, 1, broadcaster.NumMessages())
-	_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.ProposerSlashing)
-	assert.Equal(t, true, ok)
-}
-
-func TestSubmitProposerSlashing_AcrossFork(t *testing.T) {
-	ctx := context.Background()
-
-	transition.SkipSlotCache.Disable()
-	defer transition.SkipSlotCache.Enable()
-
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.AltairForkEpoch = 1
-	params.OverrideBeaconConfig(config)
-
-	bs, keys := util.DeterministicGenesisState(t, 1)
-
-	slashing := &ethpbv1alpha1.ProposerSlashing{
-		Header_1: &ethpbv1alpha1.SignedBeaconBlockHeader{
-			Header: &ethpbv1alpha1.BeaconBlockHeader{
-				Slot:          params.BeaconConfig().SlotsPerEpoch,
-				ProposerIndex: 0,
-				ParentRoot:    bytesutil.PadTo([]byte("parentroot1"), 32),
-				StateRoot:     bytesutil.PadTo([]byte("stateroot1"), 32),
-				BodyRoot:      bytesutil.PadTo([]byte("bodyroot1"), 32),
-			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpbv1alpha1.SignedBeaconBlockHeader{
-			Header: &ethpbv1alpha1.BeaconBlockHeader{
-				Slot:          params.BeaconConfig().SlotsPerEpoch,
-				ProposerIndex: 0,
-				ParentRoot:    bytesutil.PadTo([]byte("parentroot2"), 32),
-				StateRoot:     bytesutil.PadTo([]byte("stateroot2"), 32),
-				BodyRoot:      bytesutil.PadTo([]byte("bodyroot2"), 32),
-			},
-			Signature: make([]byte, 96),
-		},
-	}
-
-	newBs := bs.Copy()
-	newBs, err := transition.ProcessSlots(ctx, newBs, params.BeaconConfig().SlotsPerEpoch)
-	require.NoError(t, err)
-
-	for _, h := range []*ethpbv1alpha1.SignedBeaconBlockHeader{slashing.Header_1, slashing.Header_2} {
-		sb, err := signing.ComputeDomainAndSign(
-			newBs,
-			slots.ToEpoch(h.Header.Slot),
-			h.Header,
-			params.BeaconConfig().DomainBeaconProposer,
-			keys[0],
-		)
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		h.Signature = sig.Marshal()
-	}
-
-	broadcaster := &p2pMock.MockBroadcaster{}
-	chainmock := &blockchainmock.ChainService{State: bs}
-	s := &Server{
-		ChainInfoFetcher:  chainmock,
-		SlashingsPool:     &slashingsmock.PoolMock{},
-		Broadcaster:       broadcaster,
-		OperationNotifier: chainmock.OperationNotifier(),
-	}
-
-	toSubmit := structs.ProposerSlashingsFromConsensus([]*ethpbv1alpha1.ProposerSlashing{slashing})
-	b, err := json.Marshal(toSubmit[0])
-	require.NoError(t, err)
-	var body bytes.Buffer
-	_, err = body.Write(b)
-	require.NoError(t, err)
-	request := httptest.NewRequest(http.MethodPost, "http://example.com/beacon/pool/proposer_slashings", &body)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
-
-	s.SubmitProposerSlashing(writer, request)
-	require.Equal(t, http.StatusOK, writer.Code)
-	pendingSlashings := s.SlashingsPool.PendingProposerSlashings(ctx, bs, true)
-	require.Equal(t, 1, len(pendingSlashings))
-	assert.DeepEqual(t, slashing, pendingSlashings[0])
-	assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
-	require.Equal(t, 1, broadcaster.NumMessages())
-	_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.ProposerSlashing)
-	assert.Equal(t, true, ok)
+		s.SubmitAttesterSlashingsV2(writer, request)
+		require.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "Invalid attester slashing", e.Message)
+	})
 }
 
 func TestSubmitProposerSlashing_InvalidSlashing(t *testing.T) {

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'})
@@ -188,7 +189,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 154, len(data))
+	assert.Equal(t, 155, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -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/rpc/eth/events/events.go

@@ -71,6 +71,7 @@ var (
 	errSlowReader         = errors.New("client failed to read fast enough to keep outgoing buffer below threshold")
 	errNotRequested       = errors.New("event not requested by client")
 	errUnhandledEventData = errors.New("unable to represent event data in the event stream")
+	errWriterUnusable     = errors.New("http response writer is unusable")
 )
 
 // StreamingResponseWriter defines a type that can be used by the eventStreamer.
@@ -309,10 +310,21 @@ func (es *eventStreamer) outboxWriteLoop(ctx context.Context, cancel context.Can
 	}
 }
 
+func writeLazyReaderWithRecover(w StreamingResponseWriter, lr lazyReader) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.WithField("panic", r).Error("Recovered from panic while writing event to client.")
+			err = errWriterUnusable
+		}
+	}()
+	_, err = io.Copy(w, lr())
+	return err
+}
+
 func (es *eventStreamer) writeOutbox(ctx context.Context, w StreamingResponseWriter, first lazyReader) error {
 	needKeepAlive := true
 	if first != nil {
-		if _, err := io.Copy(w, first()); err != nil {
+		if err := writeLazyReaderWithRecover(w, first); err != nil {
 			return err
 		}
 		needKeepAlive = false
@@ -325,13 +337,13 @@ func (es *eventStreamer) writeOutbox(ctx context.Context, w StreamingResponseWri
 		case <-ctx.Done():
 			return ctx.Err()
 		case rf := <-es.outbox:
-			if _, err := io.Copy(w, rf()); err != nil {
+			if err := writeLazyReaderWithRecover(w, rf); err != nil {
 				return err
 			}
 			needKeepAlive = false
 		default:
 			if needKeepAlive {
-				if _, err := io.Copy(w, newlineReader()); err != nil {
+				if err := writeLazyReaderWithRecover(w, newlineReader); err != nil {
 					return err
 				}
 			}

beacon-chain/rpc/eth/validator/BUILD.bazel

@@ -85,6 +85,7 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/mock:go_default_library",
         "//testing/require:go_default_library",

beacon-chain/rpc/eth/validator/handlers.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
@@ -31,6 +32,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/grpc/codes"
@@ -118,30 +120,34 @@ func (s *Server) SubmitContributionAndProofs(w http.ResponseWriter, r *http.Requ
 	ctx, span := trace.StartSpan(r.Context(), "validator.SubmitContributionAndProofs")
 	defer span.End()
 
-	var req structs.SubmitContributionAndProofsRequest
-	err := json.NewDecoder(r.Body).Decode(&req.Data)
-	switch {
-	case errors.Is(err, io.EOF):
-		httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
-		return
-	case err != nil:
-		httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
+	var reqData []json.RawMessage
+	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
+		if errors.Is(err, io.EOF) {
+			httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
+		} else {
+			httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
+		}
 		return
 	}
-	if len(req.Data) == 0 {
+	if len(reqData) == 0 {
 		httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
 		return
 	}
 
-	for _, item := range req.Data {
-		consensusItem, err := item.ToConsensus()
-		if err != nil {
-			httputil.HandleError(w, "Could not convert request contribution to consensus contribution: "+err.Error(), http.StatusBadRequest)
+	for _, item := range reqData {
+		var contribution structs.SignedContributionAndProof
+		if err := json.Unmarshal(item, &contribution); err != nil {
+			httputil.HandleError(w, "Could not decode item: "+err.Error(), http.StatusBadRequest)
 			return
 		}
-		rpcError := s.CoreService.SubmitSignedContributionAndProof(ctx, consensusItem)
-		if rpcError != nil {
+		consensusItem, err := contribution.ToConsensus()
+		if err != nil {
+			httputil.HandleError(w, "Could not convert contribution to consensus format: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		if rpcError := s.CoreService.SubmitSignedContributionAndProof(ctx, consensusItem); rpcError != nil {
 			httputil.HandleError(w, rpcError.Err.Error(), core.ErrorReasonToHTTP(rpcError.Reason))
+			return
 		}
 	}
 }
@@ -168,7 +174,13 @@ func (s *Server) SubmitAggregateAndProofs(w http.ResponseWriter, r *http.Request
 
 	broadcastFailed := false
 	for _, item := range req.Data {
-		consensusItem, err := item.ToConsensus()
+		var signedAggregate structs.SignedAggregateAttestationAndProof
+		err := json.Unmarshal(item, &signedAggregate)
+		if err != nil {
+			httputil.HandleError(w, "Could not decode item: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		consensusItem, err := signedAggregate.ToConsensus()
 		if err != nil {
 			httputil.HandleError(w, "Could not convert request aggregate to consensus aggregate: "+err.Error(), http.StatusBadRequest)
 			return
@@ -191,6 +203,81 @@ func (s *Server) SubmitAggregateAndProofs(w http.ResponseWriter, r *http.Request
 	}
 }
 
+// SubmitAggregateAndProofsV2 verifies given aggregate and proofs and publishes them on appropriate gossipsub topic.
+func (s *Server) SubmitAggregateAndProofsV2(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "validator.SubmitAggregateAndProofsV2")
+	defer span.End()
+
+	var reqData []json.RawMessage
+	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
+		if errors.Is(err, io.EOF) {
+			httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
+		} else {
+			httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
+		}
+		return
+	}
+	if len(reqData) == 0 {
+		httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
+		return
+	}
+
+	versionHeader := r.Header.Get(api.VersionHeader)
+	if versionHeader == "" {
+		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
+	}
+	v, err := version.FromString(versionHeader)
+	if err != nil {
+		httputil.HandleError(w, "Invalid version: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	broadcastFailed := false
+	var rpcError *core.RpcError
+	for _, raw := range reqData {
+		if v >= version.Electra {
+			var signedAggregate structs.SignedAggregateAttestationAndProofElectra
+			err = json.Unmarshal(raw, &signedAggregate)
+			if err != nil {
+				httputil.HandleError(w, "Failed to parse aggregate attestation and proof: "+err.Error(), http.StatusBadRequest)
+				return
+			}
+			consensusItem, err := signedAggregate.ToConsensus()
+			if err != nil {
+				httputil.HandleError(w, "Could not convert request aggregate to consensus aggregate: "+err.Error(), http.StatusBadRequest)
+				return
+			}
+			rpcError = s.CoreService.SubmitSignedAggregateSelectionProof(ctx, consensusItem)
+		} else {
+			var signedAggregate structs.SignedAggregateAttestationAndProof
+			err = json.Unmarshal(raw, &signedAggregate)
+			if err != nil {
+				httputil.HandleError(w, "Failed to parse aggregate attestation and proof: "+err.Error(), http.StatusBadRequest)
+				return
+			}
+			consensusItem, err := signedAggregate.ToConsensus()
+			if err != nil {
+				httputil.HandleError(w, "Could not convert request aggregate to consensus aggregate: "+err.Error(), http.StatusBadRequest)
+				return
+			}
+			rpcError = s.CoreService.SubmitSignedAggregateSelectionProof(ctx, consensusItem)
+		}
+
+		if rpcError != nil {
+			var aggregateBroadcastFailedError *core.AggregateBroadcastFailedError
+			if errors.As(rpcError.Err, &aggregateBroadcastFailedError) {
+				broadcastFailed = true
+			} else {
+				httputil.HandleError(w, rpcError.Err.Error(), core.ErrorReasonToHTTP(rpcError.Reason))
+				return
+			}
+		}
+	}
+	if broadcastFailed {
+		httputil.HandleError(w, "Could not broadcast one or more signed aggregated attestations", http.StatusInternalServerError)
+	}
+}
+
 // SubmitSyncCommitteeSubscription subscribe to a number of sync committee subnets.
 //
 // Subscribing to sync committee subnets is an action performed by VC to enable

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

@@ -14,6 +14,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	mockChain "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	builderTest "github.com/prysmaticlabs/prysm/v5/beacon-chain/builder/testing"
@@ -37,6 +38,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -427,85 +429,238 @@ func TestSubmitContributionAndProofs(t *testing.T) {
 }
 
 func TestSubmitAggregateAndProofs(t *testing.T) {
-	c := &core.Service{
-		GenesisTimeFetcher: &mockChain.ChainService{},
-	}
-
 	s := &Server{
-		CoreService: c,
+		CoreService: &core.Service{GenesisTimeFetcher: &mockChain.ChainService{}},
 	}
+	t.Run("V1", func(t *testing.T) {
+		t.Run("single", func(t *testing.T) {
+			broadcaster := &p2pmock.MockBroadcaster{}
+			s.CoreService.Broadcaster = broadcaster
 
-	t.Run("single", func(t *testing.T) {
-		broadcaster := &p2pmock.MockBroadcaster{}
-		c.Broadcaster = broadcaster
+			var body bytes.Buffer
+			_, err := body.WriteString(singleAggregate)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
 
-		var body bytes.Buffer
-		_, err := body.WriteString(singleAggregate)
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
+			s.SubmitAggregateAndProofs(writer, request)
+			assert.Equal(t, http.StatusOK, writer.Code)
+			assert.Equal(t, 1, len(broadcaster.BroadcastMessages))
+		})
+		t.Run("multiple", func(t *testing.T) {
+			broadcaster := &p2pmock.MockBroadcaster{}
+			s.CoreService.Broadcaster = broadcaster
+			s.CoreService.SyncCommitteePool = synccommittee.NewStore()
 
-		s.SubmitAggregateAndProofs(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		assert.Equal(t, 1, len(broadcaster.BroadcastMessages))
+			var body bytes.Buffer
+			_, err := body.WriteString(multipleAggregates)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofs(writer, request)
+			assert.Equal(t, http.StatusOK, writer.Code)
+			assert.Equal(t, 2, len(broadcaster.BroadcastMessages))
+		})
+		t.Run("no body", func(t *testing.T) {
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", nil)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofs(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
+		})
+		t.Run("empty", func(t *testing.T) {
+			var body bytes.Buffer
+			_, err := body.WriteString("[]")
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofs(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
+		})
+		t.Run("invalid", func(t *testing.T) {
+			var body bytes.Buffer
+			_, err := body.WriteString(invalidAggregate)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofs(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+		})
 	})
-	t.Run("multiple", func(t *testing.T) {
-		broadcaster := &p2pmock.MockBroadcaster{}
-		c.Broadcaster = broadcaster
-		c.SyncCommitteePool = synccommittee.NewStore()
+	t.Run("V2", func(t *testing.T) {
+		t.Run("single", func(t *testing.T) {
+			broadcaster := &p2pmock.MockBroadcaster{}
+			s.CoreService.Broadcaster = broadcaster
 
-		var body bytes.Buffer
-		_, err := body.WriteString(multipleAggregates)
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
+			var body bytes.Buffer
+			_, err := body.WriteString(singleAggregateElectra)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
 
-		s.SubmitAggregateAndProofs(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		assert.Equal(t, 2, len(broadcaster.BroadcastMessages))
-	})
-	t.Run("no body", func(t *testing.T) {
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusOK, writer.Code)
+			assert.Equal(t, 1, len(broadcaster.BroadcastMessages))
+		})
+		t.Run("single-pre-electra", func(t *testing.T) {
+			broadcaster := &p2pmock.MockBroadcaster{}
+			s.CoreService.Broadcaster = broadcaster
 
-		s.SubmitAggregateAndProofs(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &httputil.DefaultJsonError{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
-	})
-	t.Run("empty", func(t *testing.T) {
-		var body bytes.Buffer
-		_, err := body.WriteString("[]")
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
+			var body bytes.Buffer
+			_, err := body.WriteString(singleAggregate)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Phase0))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
 
-		s.SubmitAggregateAndProofs(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &httputil.DefaultJsonError{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
-	})
-	t.Run("invalid", func(t *testing.T) {
-		var body bytes.Buffer
-		_, err := body.WriteString(invalidAggregate)
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusOK, writer.Code)
+			assert.Equal(t, 1, len(broadcaster.BroadcastMessages))
+		})
+		t.Run("multiple", func(t *testing.T) {
+			broadcaster := &p2pmock.MockBroadcaster{}
+			s.CoreService.Broadcaster = broadcaster
+			s.CoreService.SyncCommitteePool = synccommittee.NewStore()
 
-		s.SubmitAggregateAndProofs(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &httputil.DefaultJsonError{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
+			var body bytes.Buffer
+			_, err := body.WriteString(multipleAggregatesElectra)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusOK, writer.Code)
+			assert.Equal(t, 2, len(broadcaster.BroadcastMessages))
+		})
+		t.Run("multiple-pre-electra", func(t *testing.T) {
+			broadcaster := &p2pmock.MockBroadcaster{}
+			s.CoreService.Broadcaster = broadcaster
+			s.CoreService.SyncCommitteePool = synccommittee.NewStore()
+
+			var body bytes.Buffer
+			_, err := body.WriteString(multipleAggregates)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Phase0))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusOK, writer.Code)
+			assert.Equal(t, 2, len(broadcaster.BroadcastMessages))
+		})
+		t.Run("no body", func(t *testing.T) {
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", nil)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
+		})
+		t.Run("no body-pre-electra", func(t *testing.T) {
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", nil)
+			request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
+		})
+		t.Run("empty", func(t *testing.T) {
+			var body bytes.Buffer
+			_, err := body.WriteString("[]")
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
+		})
+		t.Run("empty-pre-electra", func(t *testing.T) {
+			var body bytes.Buffer
+			_, err := body.WriteString("[]")
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Altair))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+			assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
+		})
+		t.Run("invalid", func(t *testing.T) {
+			var body bytes.Buffer
+			_, err := body.WriteString(invalidAggregateElectra)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Electra))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+		})
+		t.Run("invalid-pre-electra", func(t *testing.T) {
+			var body bytes.Buffer
+			_, err := body.WriteString(invalidAggregate)
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
+			request.Header.Set(api.VersionHeader, version.String(version.Deneb))
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.SubmitAggregateAndProofsV2(writer, request)
+			assert.Equal(t, http.StatusBadRequest, writer.Code)
+			e := &httputil.DefaultJsonError{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+			assert.Equal(t, http.StatusBadRequest, e.Code)
+		})
 	})
 }
 
@@ -2766,6 +2921,115 @@ var (
     "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
   }
 ]`
+
+	singleAggregateElectra = `[
+  {
+    "message": {
+      "aggregator_index": "1",
+      "aggregate": {
+        "aggregation_bits": "0x01",
+        "committee_bits": "0x01",
+        "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+        "data": {
+          "slot": "1",
+          "index": "1",
+          "beacon_block_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+          "source": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          },
+          "target": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          }
+        }
+      },
+      "selection_proof": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  }
+]`
+	multipleAggregatesElectra = `[
+  {
+    "message": {
+      "aggregator_index": "1",
+      "aggregate": {
+        "aggregation_bits": "0x01",
+		"committee_bits": "0x01",
+        "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+        "data": {
+          "slot": "1",
+          "index": "1",
+          "beacon_block_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+          "source": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          },
+          "target": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          }
+        }
+      },
+      "selection_proof": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  },
+{
+    "message": {
+      "aggregator_index": "1",
+      "aggregate": {
+        "aggregation_bits": "0x01",
+		"committee_bits": "0x01",
+        "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+        "data": {
+          "slot": "1",
+          "index": "1",
+          "beacon_block_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+          "source": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          },
+          "target": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          }
+        }
+      },
+      "selection_proof": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  }
+]
+`
+	// aggregator_index is invalid
+	invalidAggregateElectra = `[
+  {
+    "message": {
+      "aggregator_index": "foo",
+      "aggregate": {
+        "aggregation_bits": "0x01",
+		"committee_bits": "0x01",
+        "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+        "data": {
+          "slot": "1",
+          "index": "1",
+          "beacon_block_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+          "source": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          },
+          "target": {
+            "epoch": "1",
+            "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+          }
+        }
+      },
+      "selection_proof": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  }
+]`
 	singleSyncCommitteeSubscription = `[
   {
     "validator_index": "1",

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go

@@ -77,6 +77,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 		log.WithError(err).Warn("Proposer: failed to retrieve header from BuilderBid")
 		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 	}
+	//TODO: add builder execution requests here.
 	if bid.Version() >= version.Deneb {
 		builderKzgCommitments, err = bid.BlobKzgCommitments()
 		if err != nil {
@@ -353,12 +354,19 @@ func setLocalExecution(blk interfaces.SignedBeaconBlock, local *blocks.GetPayloa
 	if local.BlobsBundle != nil {
 		kzgCommitments = local.BlobsBundle.KzgCommitments
 	}
+	if local.ExecutionRequests != nil {
+		if err := blk.SetExecutionRequests(local.ExecutionRequests); err != nil {
+			return errors.Wrap(err, "could not set execution requests")
+		}
+	}
+
 	return setExecution(blk, local.ExecutionData, false, kzgCommitments)
 }
 
 // setBuilderExecution sets the execution context for a builder's beacon block.
 // It delegates to setExecution for the actual work.
 func setBuilderExecution(blk interfaces.SignedBeaconBlock, execution interfaces.ExecutionData, builderKzgCommitments [][]byte) error {
+	// TODO #14344: add execution requests for electra
 	return setExecution(blk, execution, true, builderKzgCommitments)
 }
 

beacon-chain/rpc/prysm/v1alpha1/validator/server.go

@@ -83,6 +83,7 @@ type Server struct {
 // WaitForActivation checks if a validator public key exists in the active validator registry of the current
 // beacon state, if not, then it creates a stream which listens for canonical states which contain
 // the validator with the public key as an active validator record.
+// Deprecated: do not use, just poll validator status every epoch.
 func (vs *Server) WaitForActivation(req *ethpb.ValidatorActivationRequest, stream ethpb.BeaconNodeValidator_WaitForActivationServer) error {
 	activeValidatorExists, validatorStatuses, err := vs.activationStatus(stream.Context(), req.PublicKeys)
 	if err != nil {

beacon-chain/state/interfaces.go

@@ -105,7 +105,6 @@ type WriteOnlyBeaconState interface {
 	AppendHistoricalRoots(root [32]byte) error
 	AppendHistoricalSummaries(*ethpb.HistoricalSummary) error
 	SetLatestExecutionPayloadHeader(payload interfaces.ExecutionData) error
-	SaveValidatorIndices()
 }
 
 // ReadOnlyValidator defines a struct which only has read access to validator methods.
@@ -225,7 +224,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 +330,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",
@@ -46,7 +46,6 @@ go_library(
         "ssz.go",
         "state_trie.go",
         "types.go",
-        "validator_index_cache.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native",
     visibility = ["//visibility:public"],
@@ -91,11 +90,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 +106,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",
@@ -121,7 +120,6 @@ go_test(
         "state_test.go",
         "state_trie_test.go",
         "types_test.go",
-        "validator_index_cache_test.go",
     ],
     data = glob(["testdata/**"]) + [
         "@consensus_spec_tests_mainnet//:test_data",

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]
 
@@ -76,7 +76,6 @@ type BeaconState struct {
 	stateFieldLeaves      map[types.FieldIndex]*fieldtrie.FieldTrie
 	rebuildTrie           map[types.FieldIndex]bool
 	valMapHandler         *stateutil.ValidatorMapHandler
-	validatorIndexCache   *finalizedValidatorIndexCache
 	merkleLayers          [][][]byte
 	sharedFieldReferences map[types.FieldIndex]*stateutil.Reference
 }
@@ -121,7 +120,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 +189,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 {
-	if b.pendingBalanceDeposits == nil {
+func (b *BeaconState) pendingDepositsVal() []*ethpb.PendingDeposit {
+	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{
-			{Index: 1, Amount: 2},
-			{Index: 3, Amount: 4},
+		PendingDeposits: []*eth.PendingDeposit{
+			{
+				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_validator.go

@@ -180,10 +180,6 @@ func (b *BeaconState) ValidatorIndexByPubkey(key [fieldparams.BLSPubkeyLength]by
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if b.Version() >= version.Electra {
-		return b.getValidatorIndex(key)
-	}
-
 	var numOfVals int
 	if features.Get().EnableExperimentalState {
 		numOfVals = b.validatorsMultiValue.Len(b)

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.
-		pbdRoot, err := stateutil.PendingBalanceDepositsRoot(state.pendingBalanceDeposits)
+		// PendingDeposits root.
+		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/readonly_validator.go

@@ -70,11 +70,6 @@ func (v readOnlyValidator) PublicKey() [fieldparams.BLSPubkeyLength]byte {
 	return pubkey
 }
 
-// publicKeySlice returns the public key in the slice form for the read only validator.
-func (v readOnlyValidator) publicKeySlice() []byte {
-	return v.validator.PublicKey
-}
-
 // WithdrawalCredentials returns the withdrawal credentials of the
 // read only validator.
 func (v readOnlyValidator) GetWithdrawalCredentials() []byte {

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.PendingBalanceDeposits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingDeposits].MinusRef()
+	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.rebuildTrie[types.PendingBalanceDeposits] = true
+	b.markFieldAsDirty(types.PendingDeposits)
+	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.PendingBalanceDeposits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingDeposits].MinusRef()
+	b.sharedFieldReferences[types.PendingDeposits] = stateutil.NewRef(1)
 
-	b.pendingBalanceDeposits = val
+	b.pendingDeposits = val
 
-	b.markFieldAsDirty(types.PendingBalanceDeposits)
-	b.rebuildTrie[types.PendingBalanceDeposits] = true
+	b.markFieldAsDirty(types.PendingDeposits)
+	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))
-	pbd, err = s.PendingBalanceDeposits()
+	creds := []byte{0xFA, 0xCC}
+	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{{}, {}, {}}))
-	pbd, err = s.PendingBalanceDeposits()
+	require.NoError(t, s.SetPendingDeposits([]*eth.PendingDeposit{{}, {}, {}}))
+	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/setters_misc.go

@@ -107,22 +107,6 @@ func (b *BeaconState) SetHistoricalRoots(val [][]byte) error {
 	return nil
 }
 
-// SaveValidatorIndices save validator indices of beacon chain to cache
-func (b *BeaconState) SaveValidatorIndices() {
-	if b.Version() < version.Electra {
-		return
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.validatorIndexCache == nil {
-		b.validatorIndexCache = newFinalizedValidatorIndexCache()
-	}
-
-	b.saveValidatorIndices()
-}
-
 // AppendHistoricalRoots for the beacon state. Appends the new value
 // to the end of list.
 func (b *BeaconState) AppendHistoricalRoots(root [32]byte) error {

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,
 )
@@ -189,12 +189,11 @@ func InitializeFromProtoUnsafePhase0(st *ethpb.BeaconState) (state.BeaconState,
 
 		id: types.Enumerator.Inc(),
 
-		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves:    make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:         make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:       stateutil.NewValMapHandler(st.Validators),
-		validatorIndexCache: newFinalizedValidatorIndexCache(),
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -296,12 +295,11 @@ func InitializeFromProtoUnsafeAltair(st *ethpb.BeaconStateAltair) (state.BeaconS
 
 		id: types.Enumerator.Inc(),
 
-		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves:    make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:         make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:       stateutil.NewValMapHandler(st.Validators),
-		validatorIndexCache: newFinalizedValidatorIndexCache(),
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -407,12 +405,11 @@ func InitializeFromProtoUnsafeBellatrix(st *ethpb.BeaconStateBellatrix) (state.B
 
 		id: types.Enumerator.Inc(),
 
-		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves:    make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:         make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:       stateutil.NewValMapHandler(st.Validators),
-		validatorIndexCache: newFinalizedValidatorIndexCache(),
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -522,12 +519,11 @@ func InitializeFromProtoUnsafeCapella(st *ethpb.BeaconStateCapella) (state.Beaco
 
 		id: types.Enumerator.Inc(),
 
-		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves:    make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:         make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:       stateutil.NewValMapHandler(st.Validators),
-		validatorIndexCache: newFinalizedValidatorIndexCache(),
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -636,12 +632,11 @@ func InitializeFromProtoUnsafeDeneb(st *ethpb.BeaconStateDeneb) (state.BeaconSta
 		nextWithdrawalValidatorIndex:      st.NextWithdrawalValidatorIndex,
 		historicalSummaries:               st.HistoricalSummaries,
 
-		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves:    make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:         make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:       stateutil.NewValMapHandler(st.Validators),
-		validatorIndexCache: newFinalizedValidatorIndexCache(),
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -755,16 +750,15 @@ 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,
 
-		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves:    make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:         make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:       stateutil.NewValMapHandler(st.Validators),
-		validatorIndexCache: newFinalizedValidatorIndexCache(), //only used in post-electra and only populates when finalizing, otherwise it falls back to processing the full validator set
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -820,7 +814,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 +892,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,
 
@@ -925,8 +919,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
 
 		// Share the reference to validator index map.
-		valMapHandler:       b.valMapHandler,
-		validatorIndexCache: b.validatorIndexCache,
+		valMapHandler: b.valMapHandler,
 	}
 
 	if features.Get().EnableExperimentalState {
@@ -1301,8 +1294,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:
-		return stateutil.PendingBalanceDepositsRoot(b.pendingBalanceDeposits)
+	case types.PendingDeposits:
+		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:
-		return "pendingBalanceDeposits"
+	case PendingDeposits:
+		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/state-native/validator_index_cache.go

@@ -1,96 +0,0 @@
-package state_native
-
-import (
-	"bytes"
-	"sync"
-
-	"github.com/prysmaticlabs/prysm/v5/config/features"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-)
-
-// finalizedValidatorIndexCache maintains a mapping from validator public keys to their indices within the beacon state.
-// It includes a lastFinalizedIndex to track updates up to the last finalized validator index,
-// and uses a mutex for concurrent read/write access to the cache.
-type finalizedValidatorIndexCache struct {
-	indexMap map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex // Maps finalized BLS public keys to validator indices.
-	sync.RWMutex
-}
-
-// newFinalizedValidatorIndexCache initializes a new validator index cache with an empty index map.
-func newFinalizedValidatorIndexCache() *finalizedValidatorIndexCache {
-	return &finalizedValidatorIndexCache{
-		indexMap: make(map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex),
-	}
-}
-
-// getValidatorIndex retrieves the validator index for a given public key from the cache.
-// If the public key is not found in the cache, it searches through the state starting from the last finalized index.
-func (b *BeaconState) getValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (primitives.ValidatorIndex, bool) {
-	b.validatorIndexCache.RLock()
-	defer b.validatorIndexCache.RUnlock()
-	index, found := b.validatorIndexCache.indexMap[pubKey]
-	if found {
-		return index, true
-	}
-
-	validatorCount := len(b.validatorIndexCache.indexMap)
-	vals := b.validatorsReadOnlySinceIndex(validatorCount)
-	for i, val := range vals {
-		if bytes.Equal(bytesutil.PadTo(val.publicKeySlice(), 48), pubKey[:]) {
-			index := primitives.ValidatorIndex(validatorCount + i)
-			return index, true
-		}
-	}
-	return 0, false
-}
-
-// saveValidatorIndices updates the validator index cache with new indices.
-// It processes validator indices starting after the last finalized index and updates the tracker.
-func (b *BeaconState) saveValidatorIndices() {
-	b.validatorIndexCache.Lock()
-	defer b.validatorIndexCache.Unlock()
-
-	validatorCount := len(b.validatorIndexCache.indexMap)
-	vals := b.validatorsReadOnlySinceIndex(validatorCount)
-	for i, val := range vals {
-		b.validatorIndexCache.indexMap[val.PublicKey()] = primitives.ValidatorIndex(validatorCount + i)
-	}
-}
-
-// validatorsReadOnlySinceIndex constructs a list of read only validator references after a specified index.
-// The indices in the returned list correspond to their respective validator indices in the state.
-// It returns nil if the specified index is out of bounds. This function is read-only and does not use locks.
-func (b *BeaconState) validatorsReadOnlySinceIndex(index int) []readOnlyValidator {
-	totalValidators := b.validatorsLen()
-	if index >= totalValidators {
-		return nil
-	}
-
-	var v []*ethpb.Validator
-	if features.Get().EnableExperimentalState {
-		if b.validatorsMultiValue == nil {
-			return nil
-		}
-		v = b.validatorsMultiValue.Value(b)
-	} else {
-		if b.validators == nil {
-			return nil
-		}
-		v = b.validators
-	}
-
-	result := make([]readOnlyValidator, totalValidators-index)
-	for i := 0; i < len(result); i++ {
-		val := v[i+index]
-		if val == nil {
-			continue
-		}
-		result[i] = readOnlyValidator{
-			validator: val,
-		}
-	}
-	return result
-}

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

@@ -1,105 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-)
-
-func Test_FinalizedValidatorIndexCache(t *testing.T) {
-	c := newFinalizedValidatorIndexCache()
-	b := &BeaconState{validatorIndexCache: c}
-
-	// What happens if you call getValidatorIndex with a public key that is not in the cache and state?
-	// The function will return 0 and false.
-	i, exists := b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{0})
-	require.Equal(t, primitives.ValidatorIndex(0), i)
-	require.Equal(t, false, exists)
-
-	// Validators are added to the state. They are [0, 1, 2]
-	b.validators = []*ethpb.Validator{
-		{PublicKey: []byte{1}},
-		{PublicKey: []byte{2}},
-		{PublicKey: []byte{3}},
-	}
-	// We should be able to retrieve these validators by public key even when they are not in the cache
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{1})
-	require.Equal(t, primitives.ValidatorIndex(0), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{2})
-	require.Equal(t, primitives.ValidatorIndex(1), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{3})
-	require.Equal(t, primitives.ValidatorIndex(2), i)
-	require.Equal(t, true, exists)
-
-	// State is finalized. We save [0, 1, 2 ] to the cache.
-	b.saveValidatorIndices()
-	require.Equal(t, 3, len(b.validatorIndexCache.indexMap))
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{1})
-	require.Equal(t, primitives.ValidatorIndex(0), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{2})
-	require.Equal(t, primitives.ValidatorIndex(1), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{3})
-	require.Equal(t, primitives.ValidatorIndex(2), i)
-	require.Equal(t, true, exists)
-
-	// New validators are added to the state. They are [4, 5]
-	b.validators = []*ethpb.Validator{
-		{PublicKey: []byte{1}},
-		{PublicKey: []byte{2}},
-		{PublicKey: []byte{3}},
-		{PublicKey: []byte{4}},
-		{PublicKey: []byte{5}},
-	}
-	// We should be able to retrieve these validators by public key even when they are not in the cache
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{4})
-	require.Equal(t, primitives.ValidatorIndex(3), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{5})
-	require.Equal(t, primitives.ValidatorIndex(4), i)
-	require.Equal(t, true, exists)
-
-	// State is finalized. We save [4, 5] to the cache.
-	b.saveValidatorIndices()
-	require.Equal(t, 5, len(b.validatorIndexCache.indexMap))
-
-	// New validators are added to the state. They are [6]
-	b.validators = []*ethpb.Validator{
-		{PublicKey: []byte{1}},
-		{PublicKey: []byte{2}},
-		{PublicKey: []byte{3}},
-		{PublicKey: []byte{4}},
-		{PublicKey: []byte{5}},
-		{PublicKey: []byte{6}},
-	}
-	// We should be able to retrieve these validators by public key even when they are not in the cache
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{6})
-	require.Equal(t, primitives.ValidatorIndex(5), i)
-	require.Equal(t, true, exists)
-
-	// State is finalized. We save [6] to the cache.
-	b.saveValidatorIndices()
-	require.Equal(t, 6, len(b.validatorIndexCache.indexMap))
-
-	// Save a few more times.
-	b.saveValidatorIndices()
-	b.saveValidatorIndices()
-	require.Equal(t, 6, len(b.validatorIndexCache.indexMap))
-
-	// Can still retrieve the validators from the cache
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{1})
-	require.Equal(t, primitives.ValidatorIndex(0), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{2})
-	require.Equal(t, primitives.ValidatorIndex(1), i)
-	require.Equal(t, true, exists)
-	i, exists = b.getValidatorIndex([fieldparams.BLSPubkeyLength]byte{3})
-	require.Equal(t, primitives.ValidatorIndex(2), i)
-	require.Equal(t, true, exists)
-}

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,29 @@ 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,
-			Index:  primitives.ValidatorIndex(0),
+			PublicKey:             sk.PublicKey().Marshal(),
+			WithdrawalCredentials: withdrawalCredentials,
+			ExitEpoch:             ffe,
+			EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
 		},
 	}))
-	genesisBlock := util.NewBeaconBlockElectra()
+
+	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 +257,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) {
-	return ssz.SliceRoot(slice, fieldparams.PendingBalanceDepositsLimit)
+func PendingDepositsRoot(slice []*ethpb.PendingDeposit) ([32]byte, error) {
+	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,
+	}
+}

cmd/client-stats/flags/flags.go

@@ -28,6 +28,6 @@ var (
 	ScrapeIntervalFlag = &cli.DurationFlag{
 		Name:  "scrape-interval",
 		Usage: "Frequency of scraping expressed as a duration, eg 2m or 1m5s.",
-		Value: 60 * time.Second,
+		Value: 120 * time.Second,
 	}
 )

config/features/config.go

@@ -141,6 +141,12 @@ func configureTestnet(ctx *cli.Context) error {
 		}
 		applyHoleskyFeatureFlags(ctx)
 		params.UseHoleskyNetworkConfig()
+	} else if ctx.Bool(MekongTestnet.Name) {
+		log.Info("Running on the Mekong Beacon Chain Testnet")
+		if err := params.SetActive(params.MekongConfig().Copy()); err != nil {
+			return err
+		}
+		params.UseMekongNetworkConfig()
 	} else {
 		if ctx.IsSet(cmd.ChainConfigFileFlag.Name) {
 			log.Warn("Running on custom Ethereum network specified in a chain configuration yaml file")

config/features/flags.go

@@ -18,6 +18,11 @@ var (
 		Name:  "holesky",
 		Usage: "Runs Prysm configured for the Holesky test network.",
 	}
+	// MekongTestnet flag for the multiclient Ethereum consensus testnet.
+	MekongTestnet = &cli.BoolFlag{
+		Name:  "mekong",
+		Usage: "Runs Prysm configured for the Mekong test network.",
+	}
 	// Mainnet flag for easier tooling, no-op
 	Mainnet = &cli.BoolFlag{
 		Value: true,
@@ -187,6 +192,7 @@ var ValidatorFlags = append(deprecatedFlags, []cli.Flag{
 	writeWalletPasswordOnWebOnboarding,
 	HoleskyTestnet,
 	SepoliaTestnet,
+	MekongTestnet,
 	Mainnet,
 	dynamicKeyReloadDebounceInterval,
 	attestTimely,
@@ -211,6 +217,7 @@ var BeaconChainFlags = append(deprecatedBeaconFlags, append(deprecatedFlags, []c
 	disableGRPCConnectionLogging,
 	HoleskyTestnet,
 	SepoliaTestnet,
+	MekongTestnet,
 	Mainnet,
 	disablePeerScorer,
 	disableBroadcastSlashingFlag,
@@ -244,4 +251,5 @@ var NetworkFlags = []cli.Flag{
 	Mainnet,
 	SepoliaTestnet,
 	HoleskyTestnet,
+	MekongTestnet,
 }

config/fieldparams/mainnet.go

@@ -37,7 +37,7 @@ const (
 	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
 	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
 	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
-	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

@@ -37,7 +37,7 @@ const (
 	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
 	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
 	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
-	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/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "network_config.go",
         "testnet_e2e_config.go",
         "testnet_holesky_config.go",
+        "testnet_mekong_config.go",
         "testnet_sepolia_config.go",
         "testutils.go",
         "testutils_develop.go",  # keep
@@ -30,6 +31,7 @@ go_library(
         "//math:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//params:go_default_library",
         "@com_github_mohae_deepcopy//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -49,6 +51,7 @@ go_test(
         "mainnet_config_test.go",
         "testnet_config_test.go",
         "testnet_holesky_config_test.go",
+        "testnet_mekong_config_test.go",
         "testnet_sepolia_config_test.go",
     ],
     data = glob(["*.yaml"]) + [
@@ -58,6 +61,7 @@ go_test(
         "@consensus_spec_tests_minimal//:test_data",
         "@eth2_networks//:configs",
         "@holesky_testnet//:configs",
+        "@mekong_testnet//:configs",
         "@sepolia_testnet//:configs",
     ],
     embed = [":go_default_library"],

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/loader_test.go

@@ -36,6 +36,8 @@ var placeholderFields = []string{
 	"EIP7732_FORK_VERSION",
 	"FIELD_ELEMENTS_PER_BLOB",              // Compile time constant.
 	"KZG_COMMITMENT_INCLUSION_PROOF_DEPTH", // Compile time constant on BlobSidecar.commitment_inclusion_proof.
+	"FULU_FORK_EPOCH",
+	"FULU_FORK_VERSION",
 	"MAX_BLOBS_PER_BLOCK",
 	"MAX_BLOB_COMMITMENTS_PER_BLOCK", // Compile time constant on BeaconBlockBodyDeneb.blob_kzg_commitments.
 	"MAX_BYTES_PER_TRANSACTION",      // Used for ssz of EL transactions. Unused in Prysm.

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

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

config/params/testnet_mekong_config.go

@@ -0,0 +1,166 @@
+package params
+
+import (
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+)
+
+// UseMekongNetworkConfig uses the Mekong beacon chain specific network config.
+func UseMekongNetworkConfig() {
+	cfg := BeaconNetworkConfig().Copy()
+	cfg.ContractDeploymentBlock = 0
+	cfg.BootstrapNodes = []string{
+		"enr:-Iq4QB2ny1q6gkBjqNRU_e-GTbpcJQcI4i3cIZDea0mnAzGgbUTKH8j81g9PRl_-m40F1V4GFBlqZElrcbGnUj9AjGeGAZL8bgmtgmlkgnY0gmlwhJ3m4Z6Jc2VjcDI1NmsxoQJJ3h8aUO3GJHv-bdvHtsQZ2OEisutelYfGjXO4lSg8BYN1ZHCCIzI",
+		"enr:-LK4QF2XD_Fe5H9QMVVwBoDs6P_37eURcFvNTcLzOc60p_XlDKIBleMgudA7nltZ7TyAiOuY0BSQzHsdv5iUs7sFyWQEh2F0dG5ldHOIAwAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ3m4Z6Jc2VjcDI1NmsxoQJJ7y6LF_to7NYQd3BVRW1840gm5r1Lm3lfAfC9Wqmw8YN0Y3CCIyiDdWRwgiMo",
+		"enr:-Mm4QMpfvuUXcMcRx0sCtnzvE8zTJEm7BAwhFtU6CvXCv1i5Wsksx0P7ocBEJLPHULf_O3w159cnbUoB-XZuyDBfME0Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEQ82iEYRxdWljgiMpiXNlY3AyNTZrMaECDdViaSTH6xjxrJT_gIaha3_CzJ64OQDQwTdbcN84BGuIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QNLiswecY50ofHVF3twuOmJCqqdzOviXI9xAmKU3SBmbdDUr_v-dpxcP_AHoYMBw62yEcpPRsKzY-yes3wMoJnUBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEp2MADIRxdWljgiMpiXNlY3AyNTZrMaEDgRLt4r0C6K63co6eoGRvi55-viwcW_ijblPrlNVulAqIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QMM5lT_k074lQ094vF8rGQXkM4sLmti9kTbwuZF-6fZ5KhTlTxEAWI8x5-EKRduIMoCaz6z0SfaYeOsfS35jr0EBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEoSM7S4RxdWljgiMpiXNlY3AyNTZrMaECW3vJ2OZ6yjQfrDB9AW_5J_YZUuQRFsp3U5z7VvCdu9GIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QPw3-nzQ6CXpRWLR_eo4KYcoshqRtaTlmqYTlwqcW5AtWMDuF6o9oVyUhYJ9BdqP7x-vi4D5C83wJ2N-sRX0D6YBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEjl3-GYRxdWljgiMpiXNlY3AyNTZrMaED9NVIDXAwA2kDI9wU2y1KV7oGALUrc6h6LQ2zqcWD7UWIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QO3f8z6h8uhY2fOr4iOmUkfGN8Q_ej-DOwcHJ6P4dCqWa20aA6Jxac5Ta6dcfnwdvSfWUz3ZFWUU3n3mmkNvjuEBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEsoBQvoRxdWljgiMpiXNlY3AyNTZrMaEDMSbjjMae81uRoMG_hZjfbXnLLuI9eEKUkKShaTBkfEaIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QFJKhdNYDyWgtK1rM_QsbocVqvkQGVrecxbcMSMzw58JN7Cw5uJoUVJJxxlY1bWzZZ6Y6fuL0MxVKVj2jQS-F-MBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEj26p9YRxdWljgiMpiXNlY3AyNTZrMaEDx6X-X_2EgQ2AUWkwmm1GFB2SYrm7XihW-IUlx5u0-FuIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QJkcqvThmP8DfQ7T-kwsIc_7J9VZovhRWNJJ_3mWksaiJPT0YYsLwIRMxhZaIoQ96umQDyXaAnYccJHXo4UWqdQBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEisVoUYRxdWljgiMpiXNlY3AyNTZrMaECcdygVaepRRqO6BpryxhbQCCZNRxJ6C4pUujAXUdM1E-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QH8zBo5Jxm8c6Tindg5gE6Ju94Zqik8Jli6t7p8gelwJX9hacP-9UteVI-PnQZNnXuTQ8MEWfkl_zyklzF4dP9IBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEp2MnPIRxdWljgiMpiXNlY3AyNTZrMaECRHo92MBzVuUg9l0XPGpT7SUm060N40IShmk39pg_TWmIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QCaIOIsJoVLQfna3OK6gMN0YBBpAhjrD6wh1zKb9SRA8GsJAQMREOg6uK137hV2IkqfieKvIEPiYUOsJ8LsaBf8Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEibgchYRxdWljgiMpiXNlY3AyNTZrMaEDbe9GtmMNbJRzijDmQfDQQN2YkGFTr7ImH9yPyveaxOqIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QDkVL9-sXu44WnfRdLee3nlGAiDFE0mqcahIKzPcQx5IMDcWsKddzjk7sIa1t_A3OrbgKZ-myxp-9Ft98lc7jYEBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEvKb94YRxdWljgiMpiXNlY3AyNTZrMaEDz6UjXFkPJYpRmVYPyJVGefekeG1Qxkg_AcDKIc6KNEaIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QPqcZ_jT7ZUOkLi-BgCExPlUytIP6jIvhV56nPV1A5pyMzKDnk4e-6a5_1seXtyQQluHkfAjZn9_H1NVXVdkA94Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEkH7L54RxdWljgiMpiXNlY3AyNTZrMaED0EyYkEKk31vfdXMLYneEyiCNimlOgdm0qcoI5YVZ7b-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QFjWfPILQklP6hndcbtDNhl3vGWQkXf7pR8Kun039DRpClIEwvxg3MW6-JUcVNjmD3MtJFsS8702ZG3fB8YHEJsBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEp2MG04RxdWljgiMpiXNlY3AyNTZrMaECYV9wARPI7Y69DK_yoe0D58LPTF3WaIHZmkTzzC-4PZyIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QANhzPcE163m_6hv99UOWiKNmD_qvUkZOhBP1jezm-wdfji1fL0L1yue7l5kb8TiSs_6dSEeaykst-bZ4OpChQoBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEGJB6D4RxdWljgiMpiXNlY3AyNTZrMaECOcOVxvzmKm5yFLyZBA50bzAWCi4wHzlYBIEujIFt46SIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QFGHCpBCazbxQbjG-QQXVNt0XKjOSpRXaseRQ7eCciBpWfT7VrRJ1btLOuNMzyKpQcRMfmywxH7LwK5awZhdpS4Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEQ82n3IRxdWljgiMpiXNlY3AyNTZrMaEC8WOCzbdKFeg3dYciZ7QKfXxNss29CqaHG5iwm4EHQcWIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QCGRQd2a8-pIgsH3PuqA5NZjcwIjVH9H7Dh6cPJJRsEzNojxFtDzY8rRebHKb1xrVAZPXneMuw5K3okA1k2KOOwBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEsoBRjIRxdWljgiMpiXNlY3AyNTZrMaEDMOw8ey6EZ_4GyR0kNDoB55it-p7PzFPpsXyc4TFMPRGIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QLaFtJfw-TGxUNAHQO2xmnvYDnmKgjfJve2MgrWG9OPaMnVDlLIAIz9v1_SdDTS1FH3vt10iU7YI5t7CIA7sKLsBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEGJBi-4RxdWljgiMpiXNlY3AyNTZrMaED4PMVrXwoLyISWzFzYU4cd76TnpxIZwIK1SwyFyN9rWSIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QPUpI9m3garHkV47o8jKj8VGTaJTOwpIWnUb4GlD5r-vK6xC06h-wPtUzQngBFk_FOUfuw1mcqAP5L0yTUozdHsBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEmCrsz4RxdWljgiMpiXNlY3AyNTZrMaECfWt_Vji8tocNvFs6orlyMLsoNkQa19BNqsbXN_tUhkyIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QHJGsttZD0_WxO_CjaP1s_gqJcb9gCYLnYI8G4qUi3t4FYGX3oJvkZD49kNfRx38a48GjpuBCxnHpd78OSxxgnUBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEpeNaNoRxdWljgiMpiXNlY3AyNTZrMaECseT38XZgU025QL32df-blQfLLYdrby3pO-d7axe0zF-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QPtT8J4rpYkixx-COebnEPreuWv9OpgOGOvM01hqZ19eeySxCxOEEVHl2r2c0BYwBuct_yZhvkLqUQatRORlIP4Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEibhIf4RxdWljgiMpiXNlY3AyNTZrMaEDjight_62uShKNt4IorH13hfqm7kZzVyFxXKI_qDlsTGIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QIW31dzBPtPxCAKvj-T29sFb9wCDM509ANmDizLq5ys1YJCcILx6PotmJxF4g829FlDiqSsREm4da7smcPcAalMBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCE0SYdtIRxdWljgiMpiXNlY3AyNTZrMaECNWg27r6a05oup0qlmM9iSuw2sj1ulbCSGGPKDYjvGDKIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QBwdkGDZH5GMc49ZkabCo4PbLDxKUxjy9AdUZSe6zGK4NCrGq27i4bkEXwg7IrZtzCJXhfgMocUz7a7uBWq_jrQBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEp2ObP4RxdWljgiMpiXNlY3AyNTZrMaEDRDkl8RqHIqP0kgd1-bhZY18QRV9nfpWPr8FEKdRRwZaIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QFCmA4GNnGBuIdevzwZ4-5GFN0cYDqGQucQ_zZyjr3m1Srqg1eN6RuRj3gKbxChAcAp6hVOX-wl2fFzqRpsZJ-UBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEneYo34RxdWljgiMpiXNlY3AyNTZrMaEDX6gmy0PDR51SEtytWsA0IxCE_LZdY_x9FiMT0WIYJV-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QBOzKDeXEfUTFsEBk3tX2-OvfpU7uPdQRl6iex1r-N-oJaB2Xw9Bfney1x4k8ZMsHlHFPBCRrcR2Lzmu2ghHqVEBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEsj4zroRxdWljgiMpiXNlY3AyNTZrMaECpp1D7pHZbF8l6vl4_DWdm4NJVDNMxGxvti-8ZqHrHCuIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QBL6auezk-Zi385j0PyjkzGwQJW7TdOFZKGZMKTGRkI4fxTSTiHLe7kTvdjhBq4kgjPXvUnFiXR6AisA8a0w2lQBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEmCr3YYRxdWljgiMpiXNlY3AyNTZrMaEDJ4xl2Our0Y7OKsSDX9f908HznXm3PKzmC9zD8OB2d0mIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QDOEqa8lWRsJXIoFqGGytT8xBJuGu_eE1p8Nob_QQI1-B4S0_6JjVoyH3pwfezShdUj9RdgdETUon3bXM06UVSUBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEikSL4oRxdWljgiMpiXNlY3AyNTZrMaEDe4qmuHzM_TfUgfRc_0nuiQRz7S2_UhphHbgC9ilzgnGIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QIPjOKp5Y9Gr2gS3OnAr3_1GxNU2yqs5Nwv-3r44yPriBJv5pIDm0vyJe7Pi9FQCBmikt00IXoO_pF0zwWHv5b0Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEhtEjL4RxdWljgiMpiXNlY3AyNTZrMaEDeCId8CCbXbvI53xmkqjFgJgsqmxbnWE76f90OiFsmYqIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QBOCEcm86USjdb2n8zRwzDfdEo9T_rKvRGLJ25y2PL9Zbc4RKEi8yOWk-vJ4QRZtgQ9PwgBUi0Zi478X_Wc6nlsBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEgMcixoRxdWljgiMpiXNlY3AyNTZrMaEDBTPknXjsIhdfxDYucKiVm6SgYTC9zohYC5s0YV_6EeyIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QEgoppH7VZWNAb398z96aK2gDlWc0x_EQlDjOKcp6DJMahC6LSf9yjXHmnHzdii_r9ztNMXw0_b9gsfmIG6so14Bh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEpeOpZYRxdWljgiMpiXNlY3AyNTZrMaECR7znvBtmDQ80qnoAeO_FFgwB5_tALE_aZiub5YgHJx-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QCnjdBwJ6xUGvP0wOAizMDUtFJ--0Zq37c6plEGsiuu3XUk_JMytx7I_LjQHsFx54GXxSP5T1x9-tJFMKq-mBbEBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEpeMtMYRxdWljgiMpiXNlY3AyNTZrMaECm_3lxmnovulk3kxkt9SRc8CJX591ufqSGLDUl2vFulWIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QJRpkRrnmIUApBcQsRl8my3qx_ThNeMuY7PZTRzgqDqpIOrISZOFpCcXRTMRo_va_AzAMNSLCt21xWsvc4iX_FUBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEhtGam4RxdWljgiMpiXNlY3AyNTZrMaECTsHuqtUTyvnbr_-bBlPQrDjJ2fK_fo6EI8cGBlkT1taIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QHF_2oiGaRM13lElGu9KVq6DcllqoHVbXKnT9BMZsQHDeQYJFrzRl2GZuzzjdzMsb_Qa0_fpwPqacrwKA1hCbaoBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEpeiA-oRxdWljgiMpiXNlY3AyNTZrMaEC5n6EKmWkFr_F_xhKlyL04Q1R9l6bPX-ew3l4_aX3tw-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QLZkxDCSlFHNHrELwY3Wbck4uEBfDe--Oe-ymSSdb54fajSDO91ILmm5UWJbiEpgaQ-tOaRBI_mzkzrBK9vOLiABh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEGJBqxIRxdWljgiMpiXNlY3AyNTZrMaED4YrrKCAARO7iCBkBCKg18IRChlSsrdgLXUFlWN7cAVSIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QM__NZQmR1Ujykum0flKS6es2lXTCsKMnGC4s4J3g_m-ZEk8TADO5s8BtdJMnBSJIXsqQsPvGZRCOrSye7UrcWMBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEnfXIRYRxdWljgiMpiXNlY3AyNTZrMaED-132tNKgfT5Kvdtyoy08SWPtnmqbKZYCTcw8F4HL6iWIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QIDMKaGp33io88FS5RJXLftryhiGmne8QSjP2ZlCqB2mAQu3uOEOoeeNQYrd6ZJaA16xDvcO1PnqLCEwzuOuoiEBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEizulmoRxdWljgiMpiXNlY3AyNTZrMaEC9Oi3dcFrr0j1P39XIVsXdoNc9AeRZG-UVkEG1C6j8aOIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QD3COs2fIKQrvFG4cphKA0U4Bg7IltWfnnAzxrONjqkhWjbrXP14d3EGUIEuOd7FzfZaIL6bK7CwBSQRH_dGm6ABh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEn0Hy14RxdWljgiMpiXNlY3AyNTZrMaEC02svkGF3_0dOYuBvvHKP5WqW8Vp8hfh6FOTPgREZWZeIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QPyFixsMFYX5FEqsq6Su1kZF0qUlR9WSdSlXGki2a1NSNdKPYx7teRVfnny22rCgjWQzEJrh9tqI_WcFNg_9wWgBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEaPjC2YRxdWljgiMpiXNlY3AyNTZrMaEDg8vFkCPwfrszMGSNp9O1d24cq_A-4XIxFlMAaBNP10WIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QLTvtxuCz_GEJclTPTbY2PFtq4sD3LD4HWglNJIO_tUcQ6QrtgHThuyKz_sIqE1_aW24aedXXpC2p_zPWO_WV9MBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEQOJWSIRxdWljgiMpiXNlY3AyNTZrMaEDZpd0NBAzCF2-LHUVu9_g0wJKoQvnEH3PfX-rz-WoC-yIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QDZSQ1JfQl9jqm4kIEzOTlvO9KMjG5J8xDB6cKRBGWtuaYItPaRDzXJybMr0yV-XmE3Vp24s5jks22dCE-nlRyQBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEpRbtA4RxdWljgiMpiXNlY3AyNTZrMaEC2YFYSOh3-zoIqHNAN3dzKXxZcfzaTcIO2eubX3BiEQ-Ic3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QNti3RuTSPH3aneI9m5R-4c5SUZqaOH_njvk2ezJUj2UQDFkgm2deWLOGkn0jMUjRyMOxXAluMvIS_-fDcySS8EBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEnfVSpIRxdWljgiMpiXNlY3AyNTZrMaECAZcUD06u8vG4odGwNWwnqd5YvLQzWpZWbcNJrUXl5UqIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QFtC2SkZ1Fmyfjg2r-lew5YX6AJU43EmOhvGTKLjDclPEqx22L809fuZibYzdUC4QziO4lw1NfvW7q3fGbmobCgBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEkr7eV4RxdWljgiMpiXNlY3AyNTZrMaECWM-19HsETwrty153VQK2Qf0lggex_NP-RUhkOgepnBWIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-Mm4QLaSJFtlYxdSqJvJFn7K1CSD5ctr8EC113_aQYB4V4aCEn1h1rxw4z1WFUcHhsLVvtXiRQT8E7rEuNA-zJYDe1sBh2F0dG5ldHOIAAAAAAAAAACDY3NjBIRldGgykNjdQwZgY3YkAAEAAAAAAACCaWSCdjSCaXCEp0fSfYRxdWljgiMpiXNlY3AyNTZrMaEDJzRMI6aBykFmWsQZ2TFFjQmZ2rbHqTZ-LYzbvOobl8eIc3luY25ldHMAg3RjcIIjKIN1ZHCCIyg",
+		"enr:-MS4QL7la6R4Sp8mD6nbUto7mXQpCPIucMXYonbxaihETbddQGirx9-Qqvtx4Ngw1g4_mleYM_I0H8i0-KPQQkbQjjMEh2F0dG5ldHOIABgAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI_Gf0iJc2VjcDI1NmsxoQI4KtS1lao9CxXhT-dthQGovzUEnODDPFYl7SBfEA08R4hzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QFSt__5LhjnRp9F-Q0v93uvlKpYyeb42V5qvRNSFkHxDPTHJ84j31_HZVJtCfeIyfnKpScbEklmAC3O8D75hdE8Eh2F0dG5ldHOIAIABAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJO2s4qJc2VjcDI1NmsxoQPDA64YfJmZDlj1LFjnJczhWpTEl32kc4RXy0cMiA6hcYhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QBqSz2fdFrHnpZnrjpOXXX7DRhO8IZiDM_Du2M_I6uYwEEcwfBPsa9v2D9Pxz2eTXJPKQav_hHMzeO3-59Nz-VIEh2F0dG5ldHOIAAAAAAAADACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhES3e-OJc2VjcDI1NmsxoQJ6gbvJoChFGM3fziLl6TfKD4Ddt_DKmIpA3F-nijLMHIhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QMdKhukqEi_AnWG-_qI_t3CrFQ8p-uGOEYBbXuJnbDxBSqdPnbpx1K7b42H8TQpxr3bJeOZuZ4vz1ret7VkJPocEh2F0dG5ldHOIAABgAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ31WCWJc2VjcDI1NmsxoQIEdDMa4eWOEzJPjVoElGm5CKpvUdD2VF-Q-o25AyV43YhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QLB-DtV5j-GdScoGse3R0ZsEXQYkh3pZzgLElGH__jN7cIaFuFfyw5vrTbxWMKJbHIYaaHfVcPrz2YFGSIJ_hXQEh2F0dG5ldHOIAAAAwAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhM69VfuJc2VjcDI1NmsxoQL2OAp25wYmzzzJKubNowvK5I3nHC4I5eEVS6R43Z4C-ohzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QE3-f8qUWYbx1zNdoh0WMjYaHuRvdo33xP5dNJQ56pBaMI8GpGwvLeaWun2UbF7OexlrL8evl39yhuUOPrepD0oEh2F0dG5ldHOIAAAAAAAAAAaEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhLKAJmyJc2VjcDI1NmsxoQNE22g9OW0JX2MsomMWm64rCbsiSrZ4rB3cWB2-kT1oWYhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QHYLVxO7IRuJpcYeQJK81tow8_P58XnIfYkVoQwOBDnLU2QiLTNtzDVHBLTLwpMrth5XwOJhjlC4z8L6Y3ffUBgEh2F0dG5ldHOIAAAwAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIrFV6KJc2VjcDI1NmsxoQKA5AkBxLZePDZUsYHLgsf10Ib7x_PdYZ_ORAvLNHVOoohzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QNJOA_EYx3fSHmfWFz5ffCCfRZW5n3C9gVAn64-1Vq4vZzYsmtF2fm6l4GQd53bIbDJO5XXwr-Ltaow2PbbNxq8Eh2F0dG5ldHOIAAAAAwAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIbRzgOJc2VjcDI1NmsxoQLownRcAKPtJvJ24jFhNL-XVkf0CUKRpaQCMaOX1DdbMYhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QKjT4PY-Bf8hyxURb8ONCVH4CPTc8DSp1mTlEDyPcr6rTR1G3AbDuFEDcL5z97K2OfeKwMwp9V82HmwRwC6UWMoEh2F0dG5ldHOIAAAAAAYAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhES3H5uJc2VjcDI1NmsxoQJjQFB0Q6Z8mh1dbe8DsbvVvfgX7na14JR8OnzOVongfohzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QAhMlMk0Sr4K29zo0qVw1ef4ufyealQRdIAXqbgtZVh6ab3o7WKx5Hvr3MK3sc60nBQB3hNaMpt--isKv09IM2EEh2F0dG5ldHOIAAAAAAAwAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ31NHGJc2VjcDI1NmsxoQP0uJtV8gdLm995mg98Gfp9L9TP4AA7wCZKSZcl0aYeLohzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QOu9DJTE50sYY-z_lU6xozdB5LJwhfCIPCUNozdhjeihLAA9CHyL1GBeJqJjvoIm5RIO6iiNZFp3ZB4uWB4hzuwEh2F0dG5ldHOIAAAAAAwAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIs7uVSJc2VjcDI1NmsxoQNWqxvo4uv00UaK_ETex9kqaB3xX17slXTxdvMqeHWUIIhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QGFtyo4ejnaQuOf6w62R7pWAkVQs02zZqiKB06ARhNsRJGL4TIewlqV0-cPSdSguuZYPSRJddrhHMRSnIa6kcvUEh2F0dG5ldHOIAAAAAAAAADCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhEDjHhOJc2VjcDI1NmsxoQJiLwrZNj46tPKMIaXyZp2D_dExmxjHMH_W0bDlSw4xEIhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-MS4QDa4tn2FRJLfuAPGrIIEYcPMaTlJlUqoHnZZBN7VX95Rbwn9cFN93mdYq5klQRfL3pSNo-iYCmN1SqIkm3B_fGkEh2F0dG5ldHOIAAYAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ_fqkuJc2VjcDI1NmsxoQJX1m_Dyt2QJekkL2O3f44GeJvqGXLPLLevk5oM5rNjpYhzeW5jbmV0c4gAAAAAAAAAAIN0Y3CCIyiDdWRwgiMo",
+		"enr:-Ly4QOxOkGvFqhKllD4vfg4xfwf1OH555pTPxd9n2IKddj9cC3v6XpALXuQOoFe3MeXuKcRSWx61LcTn-8kzkmFEIEADh2F0dG5ldHOIAAAAAAAAAAyEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhES3cBaJc2VjcDI1NmsxoQLi9EnRObjSmOysxaGITFdArRXVmpJCMKRkMX8KSc4rS4hzeW5jbmV0cwaDdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QH89XtIf-D3uX6m0YjkoTH7eGRhBGSZiu39ib2jXX6V5fa0QxUYabZdPl-5Fdew-rUPJ8sYuDQXYdEVeDjKwmKQDh2F0dG5ldHOIGAAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI_GpWiJc2VjcDI1NmsxoQM2u9Syt4BkQn-WSycLUXp7ajuESEUtVdtsjNMJ7n7Me4hzeW5jbmV0cwmDdGNwgiMog3VkcIIjKA",
+		"enr:-LK4QAH0JWA-ME1EiLIcJmQ7h9mStB0pkcV4R8d4BkG8t1hOe47k6vBNtEkMV9rBlRXlFIFfKwMcqH6h8sw7rgK0ORMCh2F0dG5ldHOIAAwAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhEPNoYaJc2VjcDI1NmsxoQK-pYgRudAjqNz7OVA5a2qmtxtsx_ZmDKwZm_Vub7lWPIN0Y3CCIyiDdWRwgiMo",
+		"enr:-Ly4QDVEJYjwK3H8Tj857ZmNZRo_20B7fYPR53keYS8pPIrHeiPFCwOBok6fvWr4457kOwXoszf41IpJEmFNXingyN8Dh2F0dG5ldHOIAAAAAAYAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKEjPAeJc2VjcDI1NmsxoQP6kCCPnIwk94L0eTPSyEnqtvM1yQZzg1WkDkZKjLdaTIhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QETJyo6kF40C8v3SYt_49v2tFHxuJiGNGFtr2GUHtn_pdHIEXYEFCAkooMLstcQY20qlLk_EYzs4nPx66swzZnQDh2F0dG5ldHOIADAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKUW-6KJc2VjcDI1NmsxoQKIjpnE7-XBEpSfEM3OTxwMirrmlWmuWxYTtuwQDaJ2XYhzeW5jbmV0cwKDdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QPJX60M6LiSApuKzABdZGcRZdXeNs9YK_RXkOi7mu-XBeT4p6ws6TV6UOWaQNghtOQBGt2dwDhA75oK_ZoktMCMDh2F0dG5ldHOIAACAAQAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhC5lURmJc2VjcDI1NmsxoQPyysL6sOJtdbbxCZ5R1aJjUfQmJhmE-I_xYqO9-i90johzeW5jbmV0cwqDdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QAw204L45p1Mp3ryCSdVvsHlBHMVJrwScuqXELpp7k6WQ8Vt7BypqMOSOVd3uL4ROT4R_paqzfrMIR-fFKItNMsDh2F0dG5ldHOIAAAYAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhGj4ByyJc2VjcDI1NmsxoQMJdFDFq8q3DhC943QMFSxkkluGHNsNvbrTTWKD-LYr94hzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QKJJaj_g8L8Okg4S3MJmQ9ZcNLytmtrPx_FY60TD_Pn2cVdm-PaIE9p5csITOvIpu6TYY4zBwc1uIE5FC4Vmh8YDh2F0dG5ldHOIAAAAAAAAwACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhLymYWaJc2VjcDI1NmsxoQLB7079lklX_9vsCAj2LZx71-4Dzj-MlLn2qmj6UiDjd4hzeW5jbmV0cw2DdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QMZw5ndFHQP8xRF46D_k1eyibF7FAypRq_oPkQioIJPBB2VdI43v2UV8Y_A0Ll0Rr1IoVkxGUW6JSP_naF3oStYDh2F0dG5ldHOIAAAAAIABAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhEPPX46Jc2VjcDI1NmsxoQI2VB9Qwv9Azwm5oM2MXDd-wILue3jE2DxVsVv3HKoBNohzeW5jbmV0cw6DdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QLpIqVziOnAZ-U2-uUgNq9EiEukP-Hsmr1rX5q9RN6bbOaMEJfgiQftGVje33Xz1z0YOqRR136VEn8r0jS5IFd8Dh2F0dG5ldHOIAAAAAAAAABiEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJK-Uy2Jc2VjcDI1NmsxoQLH5B5DL6IO9nhqNoj4sVyyYteRN1j012_LZ5HDGFaLvIhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-Ly4QKYuxsuhgcWTcwC-LfLKwBQLVTDmMg8iGNwa6Fu462j2IMCNKx1I-Vb77JxpDQs6JIq23O0sgvAv2sGkxnDAf9wDh2F0dG5ldHOIAAAAwAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIbRuLmJc2VjcDI1NmsxoQJoV-IcjTx1TkZqUDsKULphwU9maN4y7uLmAzQFycAAtohzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-LK4QDJp2U08hakweMKge9h1AHrsr28cIAMeY18b8-7PAathFBuUuO6sXyJABhloJ94uWqKS26YC2UgA6H3Moju7Bb4Ch2F0dG5ldHOIDAAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKesmW2Jc2VjcDI1NmsxoQI_jFdc5GSJ0TnwA5DlKK-doN89Tr6oXDmB4KxWwzYoWIN0Y3CCIyiDdWRwgiMo",
+		"enr:-Ly4QH42VUJjJxw24sBTppaF190Pcn0laRqa3UUxcR5EoA-kLDPl0EAnH7hqnD4JBJ4BjkJ4IQGgDjquHUoWJpneAWcDh2F0dG5ldHOIAAAYAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJO21QqJc2VjcDI1NmsxoQKU8u3T4sCtMUkucKyRFXMGebCffrMnss3P_52W55RJIohzeW5jbmV0cwSDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QHMmDt1EuRPEgjoUJ5-leNqpUqIZBwWmzBrR-a_2AO5eFYukPyiE_2VHH8rVTu-CXpPwX2KBkSJBeacgF5VYCwiGAZL8lfxmh2F0dG5ldHOIAIABAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXjybOJc2VjcDI1NmsxoQJS3R2VkqpdkwyZkZQMDMU_IF04dLxQt6NAf70kWcXYvohzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QItySKXmpWDl3tLnVqAP00A5rFrlzBqfYbEXriD1gnIpWpiQIQ5fPLyUQq3leYmC-GpbtV6VQ2Iz9E_0hfKWaQKGAZL8lgN5h2F0dG5ldHOIAAAAAAAAAGCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ_fSeGJc2VjcDI1NmsxoQPMIZKzBRt9YGP7hlJHA1LzFAm8URxH98D4RDmQhKc-yIhzeW5jbmV0cwmDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QBlCr5bxnEMn3xk0GsS48gxy66ZVUBu6hJKvCJGTy6NhM2d8M4l08S-bqkN43z6swzN57bJ86Lcq9LXkNd-xLC-GAZL8lgKnh2F0dG5ldHOIAAAMAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI5dy46Jc2VjcDI1NmsxoQJoK-aOOTD9lMwTCcO37Ihmcnknp9FxO9lsFYBuTZRfGohzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QFP-ZBOIUZKl24rwQ2MDBiWioMBQ4Oi_rMBXRikKX0XDMV9-nXe9ITJJPQlWPFcSNrVIwcah3Trw5ImLKblk3ymGAZL8lgu_h2F0dG5ldHOIAAAAAAAAMACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhES34myJc2VjcDI1NmsxoQNTVdI6Vw-YubsEVxTl5-JECJHcsESDoq60UruR5JwjcohzeW5jbmV0cweDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QFEPaQEsgH8YL5Gu9Xw1HdSaCjfHBaavRcuwRlEq3QulQdU3xLoPXV0l_zRoEMkdMGh-5e3AY842xFamYub7ojGGAZL8lgByh2F0dG5ldHOIAAAAAAAAAMCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhBjHXU2Jc2VjcDI1NmsxoQIUCDXAKfrPVgTp5yIYkGgneVdc5FaYQjnRSAMD50_LIYhzeW5jbmV0cwSDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QNOSfKR0-_DO35S3ogEDB0HyS5O1KVG3AG56YUsSdTbvDq7nLS_BQBtYF3W_JwHjOLidbyCdsSpEZ73iMJuFhEeGAZL8lf2nh2F0dG5ldHOIAAAAADAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhMbHVWCJc2VjcDI1NmsxoQJmKRg0hEM-TnwPj2ilnshK9hGixG55MaGHv_vnYASWBYhzeW5jbmV0cweDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QABR7d4ppxIxFOvg5jUTJ2mBzkPjvsFAmx4ijBOlYgk7AU41gNphw78hzxmeCEw0Wq7LK5YTuHUahjz8WM7i3tmGAZL8lgVIh2F0dG5ldHOIAAAAAAAAgAGEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKpAyyGJc2VjcDI1NmsxoQM9MtxjAx2y-mL3gQD25yWl3Gks7nrEHGEM5DvSpX1rLohzeW5jbmV0cw2DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QCfAmFbSe4QLoUDERuSZ7aE74lIfXnXRkvm7cjjayHFLMVy0XRQxxvxRLBoLpZV_-SS-lQyaVDkjhmNuv-igbTeGAZL8lfv7h2F0dG5ldHOIGAAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI_GdHKJc2VjcDI1NmsxoQKl9J1dyW1CnoiAN9is5uNLnk9op4wIIXWVahx6DsLmDYhzeW5jbmV0cweDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QEjbxm5EwlJUp062pFTwpbnyOHUZJOE0BnxBuQYro80aWwzPxuYsj9S1zdOEhtMCadpHaueKsoJtD6x2be06XwyGAZL8lg22h2F0dG5ldHOIAAwAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ3mJJeJc2VjcDI1NmsxoQP68-24KkowwXNVIM5A5BlStNX8dUR636iyStKqFuXDIYhzeW5jbmV0cwiDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QPTbd5CgBXLtFu34aJw8TR4Mpk55PBJj6RQTZP_HPfSFOhOpLI4cLbR39tBBShjc43GGKhANt2RK0hHYUrMUNIeGAZL8lf3ch2F0dG5ldHOIAAAAAAAwAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXoaVWJc2VjcDI1NmsxoQK9VrHPA291SJwcKGe4cdSJdnRc2imeTGuUscFIlzIRSIhzeW5jbmV0cwuDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QM6qzQ2kwTRRe9dRGEGqpvdN_6czu0t3gSAO7ojsuennXtY2y2h3HlNoI8lFvQtjXFVz-TDJTia1aabby113GgSGAZL8lgc-h2F0dG5ldHOIAAAAAAAAAGCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhES37GeJc2VjcDI1NmsxoQLGSNIMObiRYK12eYlHVqXrRtkjld2qnfqeymyqS09vNYhzeW5jbmV0cwSDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QC1IbLWxtbrF4aiHmvelea2gn0DUjRQLbOVjfDvIg7NeCDkmgHcAULDfyv8nokHVadeHU_nZtXx5KFSWMRThXpeGAZL8lfxSh2F0dG5ldHOIAAAAAABgAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXj6aWJc2VjcDI1NmsxoQIRdEG4LqcWFxuGL8rKnuloHMaXaWcyTAW36bQF-vq43ohzeW5jbmV0cwaDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QB2VcgCAj5ZZW8ItWHT7kT115pGK9U2jQt9e6A-_blQCGgZYCVfsAoUPnFoatzpolSqfq5yDqaOUZVRqfble4-6GAZL8lf37h2F0dG5ldHOIAAAAADAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhGiDI7CJc2VjcDI1NmsxoQP1gXjy89Aq_qC3q4h6YpMAQ7ArRyOAkNSdt2uxR95aRYhzeW5jbmV0cwiDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QE5FCzl2lOL1yLeUI9sOKol9sMDIP_2_829ONxfEKJ0RCMJ5fVoVCgAzkQeCB3Qy5cTc-J_xvV0BTUGwVncUeSuGAZL8lf3ah2F0dG5ldHOIAACAAQAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhLKA-BqJc2VjcDI1NmsxoQOsPITil6o4aZGLJU4QVOouhwA_asQYKzx73WQrX9mKJ4hzeW5jbmV0cwuDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QDTSMAJnlzM5ge0zFDYIf3Dm1jo-QlW16bGEK1c5V4XqROkjICrItNtTHn_rWZ7sFLJ-HEJrEXuelLoNRq4Mk7KGAZL8lf41h2F0dG5ldHOIAAAAAAAAABiEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhEDjdKaJc2VjcDI1NmsxoQLd_yMbZ703FvFi-XREC6rLHnbD_UWUCza99qjnAmrv4IhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QM6zcrPDsArscPtgE1vIUYUttaaaoy9KK1UVJt_v2vltRucEOoJf1Y0YhSmEjVTnxtquUnNsthr1xEbzlINJMaCGAZL8lgbDh2F0dG5ldHOIAAAYAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJO2m8KJc2VjcDI1NmsxoQP-z75gbAYqR6_LCL2rpPTZmrOz8NnS1UFhqjsmwVbw9IhzeW5jbmV0cweDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QL18SZHDapmjGWInRUZYBuU3CTkqVLyhxpovPLcnMgsiPx6b2uf2jHQnj3lK8y0mLxv74y6Ww2kBFdrLKFLxZTmGAZL8lgfth2F0dG5ldHOIAAAAAAYAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIs7BZaJc2VjcDI1NmsxoQM1pgLIjSoQCDzGaH6k-xiL_H9FP_aO62iZXpnRFU_6zohzeW5jbmV0cw2DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QAKZrFxKHiZlNYqq3a3t5SSbg36XL1ipI93wPvj6nhmfVSi5iNK9qRxQmhRt8b6S5iEAcPhnHNiO4gtaZdGg3DKGAZL8lgRah2F0dG5ldHOIAAAAAADAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI_GaKKJc2VjcDI1NmsxoQMYWC2DzvQ8_K9V6kU3g2Bfr7qkp0MkkpLcc04szxTQ_ohzeW5jbmV0cwKDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QAeVsVSVHkpiv2wpX4JovFW-8zlNJGQvso-cu25VIRIkYDs1uokbt_XexoabwaneyuftPbDFnNbuTVFjOiixIAqGAZL8lgJOh2F0dG5ldHOIAQAAAAAAAICEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIm4xiSJc2VjcDI1NmsxoQNj5zT1FZCoZp2vu0xyPvIn3nTGjbIweVwEkAAeqdMJ9YhzeW5jbmV0cwWDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QIejUXUsOX2Zt0gaZ0L0nNjE40rCu5S3H_lNaug79Gk2aNObUAorRsTXKslKTc2oFRFd68vn_294oKtOjKQ6lP2GAZL8lgrih2F0dG5ldHOIABgAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKdjQ9WJc2VjcDI1NmsxoQNBNJ9KuHDBEp0PnogcADqdijjfYEI94yP91iLwFNM6johzeW5jbmV0cw2DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QN0Jin_u-UobugNNP9ux3Fin5tk93ax5tCwNTWhIQNmkf4hKHVQc7n39zaYTauxHg44byC_F1XAroTedeudWKMCGAZL8lgHwh2F0dG5ldHOIAAAAABgAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXj6zuJc2VjcDI1NmsxoQJKQP5WBCZz89oRMDF0ZK657hmXuScPIKk22SQMBXBseYhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QAySvod_fX8760QzGJ6pMeZGGY05vUG7HY2IndLnkvJBYR48NdvtvqWWTXmScVEy4blZoxDuRIKiu1FX3ym2XjaGAZL8lgNyh2F0dG5ldHOIAAAAAADAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ_LaLyJc2VjcDI1NmsxoQLVROfxZ1332xSDedlu954b4dQKw3stV5r7PMKWS0VD94hzeW5jbmV0cwWDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QKThqho0pK2Ez22RIJkCqWasVhyFkXxQKTq1B_o05Yx9elbWfAMvoyl15XfE1u5oNRP6JGLSNoBGPwfAHDQT_XmGAZL8lgFxh2F0dG5ldHOIAAAAYAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhGj4WPmJc2VjcDI1NmsxoQIt33J7LcbYU-dhqYzMYlK9NNZoGq6Pd6Gkei5LITPYHYhzeW5jbmV0cwODdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QPvlUxfKTEuGcjtgBmh6dmMVlJ9kXCuvEJVxhXLpHokLcQO70_HIiPhTifc7nL9uVYf-aLsR9i9_Ju0juMl2obqGAZL8lgRih2F0dG5ldHOIAIABAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXoREOJc2VjcDI1NmsxoQP8EniEQ3S7NIc7G0eCJ-4fmsBmPEsXLLAIBTqhiEr1dohzeW5jbmV0cwODdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QPVLA2XuDDDHyJv6a6vs1zKf-QucEokYhtG5pJtwPWBza6TXV8q1SgwU_FdkK-ngvd4VX4VkqFxgTc0Rjc9xrASGAZL8lgHph2F0dG5ldHOIAAAAAAAAAwCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI9u1yKJc2VjcDI1NmsxoQMdrx7mbyTnW_cSUJci7F6zPiIRtn99q5F6l_m0jQqtA4hzeW5jbmV0cwqDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QE7dJR9k1mKgRM8N5i_MGxWwqGRX3jUD_ODVlu3ai9zEd59l9Cc1LcUzcrNhnsxsY7ESwvGA1WsR-uvbpwMNz4OGAZL8lfirh2F0dG5ldHOIAAAAAAAAYACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ_fp9qJc2VjcDI1NmsxoQIslFIGQRB_VFWMPevzyxhMDX9CkCnJp4PEFRG5n7jk2YhzeW5jbmV0cwSDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QEuke5XW36g1t9fIhgBBdTsBsbVxUy6BPT5I-QMZ0gylMLKTO8OWrxprpOL_bqFM24x4YbpKzCcGlJet1m8P6D6GAZL8lfmLh2F0dG5ldHOIgAEAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIm4z1uJc2VjcDI1NmsxoQLsGvwvgwBKlErW3e4Wxlp_C-2LoemsgxNh4YXhzYh184hzeW5jbmV0cweDdGNwgiMog3VkcIIjKA",
+		"enr:-MK4QOKr0la5UiDsWR0svdmz5bRU2cAO8q2gbVGFVP_5zUjUTAyS482sVR2EEMU84R5Vag1rmKN2B50N62SAeFDvmUmGAZL8lgXAh2F0dG5ldHOIAAAAAAAAAwCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIs7dg6Jc2VjcDI1NmsxoQI_Abpl-E4Sm5BYS-Rq19nAYTj3xG2t1GwsR6azMDvjjYhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-LK4QGKKpJY2mO2wwRWE1GrSOo0YbIhvGU3Q-jCp89LHJRZKObPECBJFrkx55lBHmBdofOU42tjHtcdaDEuz1y3mWOkEh2F0dG5ldHOIAAAAAMAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ9Z7GWJc2VjcDI1NmsxoQMcuYnhiF7_6Qlli7BHk-HtRJAJF1sAQIjBMMZFhHibLYN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QDE7XQf1xXn_1svSTXMAGEfMCB06HojK0hGLFufHu65SBXvlV1oPxy9O_Ww4hqSwK_Ttn9RujfEpAl4p2Yp3Ox8Eh2F0dG5ldHOIAwAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKUW-E2Jc2VjcDI1NmsxoQO1c8OIsBWo_BTB2AcTOi3qr8PvnYK1mM5kIfuyJZ5ptIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QHbSqmyPO4e25hz5dAjD9R70Am45I757aI1VOivcheRnCL0IGR1srnCizSDmV0DAN-pgPPB7v4D_e8WIPpCKtWIEh2F0dG5ldHOIMAAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI_GfsCJc2VjcDI1NmsxoQPRD80hT3L5trkyN7YR6dTa0eY8m8-BPEQ9VzVHr-KCm4N0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QDiQXp7rnmRd32bGVtboxwh-MFBpIAWTSUXAaxWhjVE9UERQUvGLsMYMcOHSRTND2Q7ViZ-t-VdnWG37q-ModXQEh2F0dG5ldHOIAABgAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKdH2zWJc2VjcDI1NmsxoQLlA-CJY9lvScDxC3c0gbqgv0fVcK8__JhCLi-OWqjLooN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QF4azbnoYa11BniDYhO9-U14PRHaGGgU9VkUBXxiaQQLBoEXnE5PitCXZksrjr6IXZs1Rtk_rYat6Kg56rVl7A8Eh2F0dG5ldHOIAABgAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXjWVmJc2VjcDI1NmsxoQJ-BjW6tpjmiDKUW-KNDVRL_avDPmK_yRo5HSGvJYgt04N0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QFPSLoXEbUBBQTlZEwJtNqX8hVq1GccfOqUYPY7UEggpGrC0IFuIpZGi1yLetMUd9gc055On116W36EaRtlxVeYEh2F0dG5ldHOIAAAAAAwAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhBjHXyKJc2VjcDI1NmsxoQI47lLtfQTztWdm3pVhY6giqC1PKudRwODxTQZEpGpcY4N0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QFFn8IQKKhPTcIos-3CSClVm7r102YpoTnjUvSZ6syyNWyJGeIDF6Uvm8SwzXKjfKmdV7g5TGyCgA0hO0-PNRFoEh2F0dG5ldHOIAAAADAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKpAkzeJc2VjcDI1NmsxoQPk4qNUMWmRxQKwDA99a2CjqktjXKi5wqCmNHQmFtegDYN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QL2JLllEpB8OyarfTP9CxjpgsHAHsPZoY19qBjR85HYTI76d64iTA0RxusXCiJdTLRJWgE6DE8ArpbkRvAWYJ6sEh2F0dG5ldHOIAAAAAwAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhM69nQ6Jc2VjcDI1NmsxoQJIB8SxOEE4zHpubxYwAEFTFPvCvH1PK-aAawd5X_IfeoN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QAW2bNcn_byPRldddp4zOJQrdZ0Tm_rmPLNIOUC0VUFjInLcNFLdxfUgWouL3VNN0sfs7zT0nfcSTWL4joj_0IMEh2F0dG5ldHOIAAAwAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhLI-E7uJc2VjcDI1NmsxoQLBU9O0JOoFxULrs225uuzI--xb3VzeV-Ub_i7ylzWp2YN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QF83C8OV4vbbr1HS0LFL1Fy4ZpJKOIi9QlSEJkfrDyRqIyy-D-Dp8A_vRVcJbbV5SbjBq1g-pQh7j1zzctlBXWoEh2F0dG5ldHOIAAAAAAAMAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKEji72Jc2VjcDI1NmsxoQPEmmzHJQH9TRjb_K5yanwJ6Cakw3ki3ChgFXYOqLR-3IN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QDKtIFH1vZaG2pMhLPrgY-4g0zFk2iXOVs3WySC3MikxAhBdDEttTKSH1opVZOhnI_5Ivxp8raDNhMhntvJVTkUEh2F0dG5ldHOIAAAAAAwAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ_f11yJc2VjcDI1NmsxoQLdayDMFPEnWPa_1MkL0YDmom_3zQKH2D3atBAIIt9rpIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QAt1xPThwZtp4fFdytsWwzuBuN_Kh_rlV0aJjkjWQUbddvBYctYLrzHAo7mFWktctMsGUO0VoBQdnm3ZiMoo3lEEh2F0dG5ldHOIAAAAAAAYAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhEDiYIuJc2VjcDI1NmsxoQOkRH_IBZwuZmpxh9ldiwDYUqChz6_ei6yXAxqQ9z8QyYN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QPYpTeJc1dtO_CB2Lvp7TCg6iQOU_WfpKPrTt_e3fHVKRZnmkGMA7aUzA-lxEgQQgb72TyPECN4z_vbO_XbJCL8Eh2F0dG5ldHOIAAAAAAAAgAGEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKXjJ-CJc2VjcDI1NmsxoQOuuqf6k-s_yOnNLcDNv0tIhesiYvvdphMIgyOBLDNeKoN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QG0SdN74uXa3ZthPN7B-1egIGMBzW5wlR7QX3Y0eoJwRAetxow_pyIBPsTRkPY2FHLhv8jEqna_kPHt7eXe1A_AEh2F0dG5ldHOIAAwAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKUW3BOJc2VjcDI1NmsxoQJKVmvTZgOjFKGc3ShLgTA1H192A5PLYAPaFW3CVxEmHIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QFBL2CvVr5Sz-P3nkE6jvAQdArjrLkYkxlhAxNrOHPauOsaBaa5m5OF2IzIkw09hosGwOs4XOnhVPHuYfFdV2YIEh2F0dG5ldHOIAAAAAAAAAMCEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ_fxziJc2VjcDI1NmsxoQPfWXddZQ4UAiu178G3WlyghgoIpgrZATEBNsApnA9b5YN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QPsih3HzKvodMe13_S7G7-LdHARWSWqGrfjBwpld7uBZAmE5509YBXunP5YOVfN7-65FjBRkR4HmImaVTW-3ILIEh2F0dG5ldHOIAAYAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhEPNp5mJc2VjcDI1NmsxoQPKHJGGjFBqh9a3p0xyykr1iyzYG1YGPujEkx_hilG9tIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QHRInI7TYE6LVBAAsU1ahJONNnYjGpJEVZMOgLH3hEPzQsEWzYAMWTIU_d9mlL4SAT3jMHi0RUOQ1tNvKpdFo5cEh2F0dG5ldHOIAAAwAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIs75jmJc2VjcDI1NmsxoQJTVNZQIGja0Btyt1pPX21sQ25PAIs16JYqRpc2OIOHMIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QJOiEnrs_7W2xD5ni1S4HGGXKhrzuluvt3XGMM-4HZl2OM5gtKY3OtkKKUPYYTFbkz8-IZh27fimVhiYHAr7rwwEh2F0dG5ldHOIAADAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKdjX6-Jc2VjcDI1NmsxoQLDUVY1B_Y7uKNnNuFBqVjsXXZPF4UcHYwlRIX8bOqwDIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QGJlf3p3S3hfJTs2Bmj2YoidPP_QWT14t6eMySxYa22cDWdNPDY3gmFkevT_C_f1J1DAbQCCEELcjh2Y2gQ9U6sEh2F0dG5ldHOIAAAAAAAwAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhIbRrmKJc2VjcDI1NmsxoQND9l9iIY92LxR5Yg0JThjZt2atGz9Wu7V-_Zn1JFsPgoN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QIzc1HoQowg-CyrkruCbNxJ19dcn_UpWh07zKhyl_b3TBhjju0QVnwMC0HBUo-mFPlLqVI-v4dvS7pIp5llr1cAEh2F0dG5ldHOIgAEAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhKEjnAqJc2VjcDI1NmsxoQJI2HA4O9X4qs7K2Tgh637dz876s8f40wanbnnPxJcBKYN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QG9_qJS-qov-VWaRJB7NDD1XJExA2zaTqSUsXS87mqsGdLbNlMEUcUl6-Jjn2h5JCrgjdekJajxIDBSozs2FLPIEh2F0dG5ldHOIAAAAAAAwAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhI5deB6Jc2VjcDI1NmsxoQL0hy3fyx2QhB-qxvdBIB1RqBIXwEcpNAspkyMESe-Ds4N0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QMjMMPjyls4JEnYlNcQi7k9j66Z6aDvmyLGh-MmK6Do_CncBF2dTEvrXJPcbDgIrpFrImsyw6tF4YUzO0OhHaGYEh2F0dG5ldHOIwAAAAAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJ3m4YuJc2VjcDI1NmsxoQLP3iDQVX979MeG4JUG5TEEOfcBDq4DL6IwV_vMO-iMsIN0Y3CCIyiDdWRwgiMo",
+		"enr:-LK4QPNn6P_ydDEeOPMp77RH7NHZtEdFstujjbM_mg9N9mHDEGaAim7qZo5jWgMC1HZpf0c4-tf0Y6eFkDdw9EbhPlAEh2F0dG5ldHOIAAAAwAAAAACEZXRoMpDY3UMGYGN2JAABAAAAAAAAgmlkgnY0gmlwhJgq582Jc2VjcDI1NmsxoQN2tk0LwZ9dacFxiUApBGnqfHwLTiOjtC8Kstlel29Xw4N0Y3CCIyiDdWRwgiMo",
+	}
+	OverrideBeaconNetworkConfig(cfg)
+}
+
+// MekongConfig defines the config for the Mekong beacon chain testnet.
+func MekongConfig() *BeaconChainConfig {
+	cfg := MainnetConfig().Copy()
+	cfg.MinGenesisTime = 1730822340
+	cfg.GenesisDelay = 60
+	cfg.ConfigName = MekongName
+	cfg.GenesisValidatorsRoot = bytesutil.ToBytes32(hexutil.MustDecode("0x9838240bca889c52818d7502179b393a828f61f15119d9027827c36caeb67db7"))
+	cfg.GenesisForkVersion = []byte{0x10, 0x63, 0x76, 0x24}
+	cfg.SecondsPerETH1Block = 12
+	cfg.DepositChainID = 7078815900
+	cfg.DepositNetworkID = 7078815900
+	cfg.AltairForkEpoch = 0
+	cfg.AltairForkVersion = []byte{0x20, 0x63, 0x76, 0x24}
+	cfg.BellatrixForkEpoch = 0
+	cfg.BellatrixForkVersion = []byte{0x30, 0x63, 0x76, 0x24}
+	cfg.CapellaForkEpoch = 0
+	cfg.CapellaForkVersion = []byte{0x40, 0x63, 0x76, 0x24}
+	cfg.DenebForkEpoch = 0
+	cfg.DenebForkVersion = []byte{0x50, 0x63, 0x76, 0x24}
+	cfg.ElectraForkEpoch = 256
+	cfg.ElectraForkVersion = []byte{0x60, 0x63, 0x76, 0x24}
+	cfg.TerminalTotalDifficulty = "0"
+	cfg.DepositContractAddress = "0x4242424242424242424242424242424242424242"
+	cfg.EjectionBalance = 30000000000
+	cfg.ChurnLimitQuotient = 128
+	cfg.MinGenesisActiveValidatorCount = 100000
+	cfg.MinValidatorWithdrawabilityDelay = 2
+	cfg.InitializeForkSchedule()
+	return cfg
+}

config/params/testnet_mekong_config_test.go

@@ -0,0 +1,28 @@
+package params_test
+
+import (
+	"path"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestMekongConfigMatchesUpstreamYaml(t *testing.T) {
+	presetFPs := presetsFilePath(t, "mainnet")
+	mn, err := params.ByName(params.MainnetName)
+	require.NoError(t, err)
+	cfg := mn.Copy()
+	for _, fp := range presetFPs {
+		cfg, err = params.UnmarshalConfigFile(fp, cfg)
+		require.NoError(t, err)
+	}
+	fPath, err := bazel.Runfile("external/mekong_testnet")
+	require.NoError(t, err)
+	configFP := path.Join(fPath, "network-configs/devnet-0/metadata", "config.yaml")
+	pcfg, err := params.UnmarshalConfigFile(configFP, nil)
+	require.NoError(t, err)
+	fields := fieldsFromYamls(t, append(presetFPs, configFP))
+	assertYamlFieldsMatch(t, "mekong", fields, pcfg, params.MekongConfig())
+}

config/params/values.go

@@ -10,4 +10,5 @@ const (
 	MinimalName         = "minimal"
 	SepoliaName         = "sepolia"
 	HoleskyName         = "holesky"
+	MekongName          = "mekong"
 )

consensus-types/blocks/execution.go

@@ -37,6 +37,9 @@ func NewWrappedExecutionData(v proto.Message) (interfaces.ExecutionData, error)
 		return WrappedExecutionPayloadDeneb(pbStruct)
 	case *enginev1.ExecutionPayloadDenebWithValueAndBlobsBundle:
 		return WrappedExecutionPayloadDeneb(pbStruct.Payload)
+	case *enginev1.ExecutionBundleElectra:
+		// note: no payload changes in electra so using deneb
+		return WrappedExecutionPayloadDeneb(pbStruct.Payload)
 	default:
 		return nil, ErrUnsupportedVersion
 	}

consensus-types/blocks/get_payload.go

@@ -14,7 +14,8 @@ type GetPayloadResponse struct {
 	BlobsBundle     *pb.BlobsBundle
 	OverrideBuilder bool
 	// todo: should we convert this to Gwei up front?
-	Bid primitives.Wei
+	Bid               primitives.Wei
+	ExecutionRequests *pb.ExecutionRequests
 }
 
 // bundleGetter is an interface satisfied by get payload responses that have a blobs bundle.
@@ -31,6 +32,10 @@ type shouldOverrideBuilderGetter interface {
 	GetShouldOverrideBuilder() bool
 }
 
+type executionRequestsGetter interface {
+	GetDecodedExecutionRequests() (*pb.ExecutionRequests, error)
+}
+
 func NewGetPayloadResponse(msg proto.Message) (*GetPayloadResponse, error) {
 	r := &GetPayloadResponse{}
 	bundleGetter, hasBundle := msg.(bundleGetter)
@@ -38,6 +43,7 @@ func NewGetPayloadResponse(msg proto.Message) (*GetPayloadResponse, error) {
 		r.BlobsBundle = bundleGetter.GetBlobsBundle()
 	}
 	bidValueGetter, hasBid := msg.(bidValueGetter)
+	executionRequestsGetter, hasExecutionRequests := msg.(executionRequestsGetter)
 	wei := primitives.ZeroWei()
 	if hasBid {
 		// The protobuf types that engine api responses unmarshal into store their values in little endian form.
@@ -56,5 +62,12 @@ func NewGetPayloadResponse(msg proto.Message) (*GetPayloadResponse, error) {
 		return nil, err
 	}
 	r.ExecutionData = ed
+	if hasExecutionRequests {
+		requests, err := executionRequestsGetter.GetDecodedExecutionRequests()
+		if err != nil {
+			return nil, err
+		}
+		r.ExecutionRequests = requests
+	}
 	return r, nil
 }

consensus-types/blocks/setters.go

@@ -6,6 +6,7 @@ import (
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
@@ -172,3 +173,12 @@ func (b *SignedBeaconBlock) SetBlobKzgCommitments(c [][]byte) error {
 	b.block.body.blobKzgCommitments = c
 	return nil
 }
+
+// SetExecutionRequests sets the execution requests in the block.
+func (b *SignedBeaconBlock) SetExecutionRequests(req *enginev1.ExecutionRequests) error {
+	if b.version < version.Electra {
+		return consensus_types.ErrNotSupported("SetExecutionRequests", b.version)
+	}
+	b.block.body.executionRequests = req
+	return nil
+}

consensus-types/interfaces/beacon_block.go

@@ -91,6 +91,7 @@ type SignedBeaconBlock interface {
 	SetProposerIndex(idx primitives.ValidatorIndex)
 	SetSlot(slot primitives.Slot)
 	SetSignature(sig []byte)
+	SetExecutionRequests(er *enginev1.ExecutionRequests) error
 	Unblind(e ExecutionData) error
 }
 

consensus-types/interfaces/light_client.go

@@ -9,6 +9,7 @@ import (
 
 type LightClientExecutionBranch = [fieldparams.ExecutionBranchDepth][fieldparams.RootLength]byte
 type LightClientSyncCommitteeBranch = [fieldparams.SyncCommitteeBranchDepth][fieldparams.RootLength]byte
+type LightClientSyncCommitteeBranchElectra = [fieldparams.SyncCommitteeBranchDepthElectra][fieldparams.RootLength]byte
 type LightClientFinalityBranch = [fieldparams.FinalityBranchDepth][fieldparams.RootLength]byte
 
 type LightClientHeader interface {
@@ -24,7 +25,8 @@ type LightClientBootstrap interface {
 	Version() int
 	Header() LightClientHeader
 	CurrentSyncCommittee() *pb.SyncCommittee
-	CurrentSyncCommitteeBranch() LightClientSyncCommitteeBranch
+	CurrentSyncCommitteeBranch() (LightClientSyncCommitteeBranch, error)
+	CurrentSyncCommitteeBranchElectra() (LightClientSyncCommitteeBranchElectra, error)
 }
 
 type LightClientUpdate interface {
@@ -32,7 +34,8 @@ type LightClientUpdate interface {
 	Version() int
 	AttestedHeader() LightClientHeader
 	NextSyncCommittee() *pb.SyncCommittee
-	NextSyncCommitteeBranch() LightClientSyncCommitteeBranch
+	NextSyncCommitteeBranch() (LightClientSyncCommitteeBranch, error)
+	NextSyncCommitteeBranchElectra() (LightClientSyncCommitteeBranchElectra, error)
 	FinalizedHeader() LightClientHeader
 	FinalityBranch() LightClientFinalityBranch
 	SyncAggregate() *pb.SyncAggregate

consensus-types/light-client/bootstrap.go

@@ -22,6 +22,8 @@ func NewWrappedBootstrap(m proto.Message) (interfaces.LightClientBootstrap, erro
 		return NewWrappedBootstrapCapella(t)
 	case *pb.LightClientBootstrapDeneb:
 		return NewWrappedBootstrapDeneb(t)
+	case *pb.LightClientBootstrapElectra:
+		return NewWrappedBootstrapElectra(t)
 	default:
 		return nil, fmt.Errorf("cannot construct light client bootstrap from type %T", t)
 	}
@@ -83,8 +85,12 @@ func (h *bootstrapAltair) CurrentSyncCommittee() *pb.SyncCommittee {
 	return h.p.CurrentSyncCommittee
 }
 
-func (h *bootstrapAltair) CurrentSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
-	return h.currentSyncCommitteeBranch
+func (h *bootstrapAltair) CurrentSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return h.currentSyncCommitteeBranch, nil
+}
+
+func (h *bootstrapAltair) CurrentSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return [6][32]byte{}, consensustypes.ErrNotSupported("CurrentSyncCommitteeBranchElectra", version.Altair)
 }
 
 type bootstrapCapella struct {
@@ -143,8 +149,12 @@ func (h *bootstrapCapella) CurrentSyncCommittee() *pb.SyncCommittee {
 	return h.p.CurrentSyncCommittee
 }
 
-func (h *bootstrapCapella) CurrentSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
-	return h.currentSyncCommitteeBranch
+func (h *bootstrapCapella) CurrentSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return h.currentSyncCommitteeBranch, nil
+}
+
+func (h *bootstrapCapella) CurrentSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return [6][32]byte{}, consensustypes.ErrNotSupported("CurrentSyncCommitteeBranchElectra", version.Capella)
 }
 
 type bootstrapDeneb struct {
@@ -203,6 +213,74 @@ func (h *bootstrapDeneb) CurrentSyncCommittee() *pb.SyncCommittee {
 	return h.p.CurrentSyncCommittee
 }
 
-func (h *bootstrapDeneb) CurrentSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
-	return h.currentSyncCommitteeBranch
+func (h *bootstrapDeneb) CurrentSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return h.currentSyncCommitteeBranch, nil
+}
+
+func (h *bootstrapDeneb) CurrentSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return [6][32]byte{}, consensustypes.ErrNotSupported("CurrentSyncCommitteeBranchElectra", version.Deneb)
+}
+
+type bootstrapElectra struct {
+	p                          *pb.LightClientBootstrapElectra
+	header                     interfaces.LightClientHeader
+	currentSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranchElectra
+}
+
+var _ interfaces.LightClientBootstrap = &bootstrapElectra{}
+
+func NewWrappedBootstrapElectra(p *pb.LightClientBootstrapElectra) (interfaces.LightClientBootstrap, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	header, err := NewWrappedHeaderDeneb(p.Header)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientSyncCommitteeBranchElectra](
+		"sync committee",
+		p.CurrentSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepthElectra,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &bootstrapElectra{
+		p:                          p,
+		header:                     header,
+		currentSyncCommitteeBranch: branch,
+	}, nil
+}
+
+func (h *bootstrapElectra) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *bootstrapElectra) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *bootstrapElectra) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *bootstrapElectra) Version() int {
+	return version.Electra
+}
+
+func (h *bootstrapElectra) Header() interfaces.LightClientHeader {
+	return h.header
+}
+
+func (h *bootstrapElectra) CurrentSyncCommittee() *pb.SyncCommittee {
+	return h.p.CurrentSyncCommittee
+}
+
+func (h *bootstrapElectra) CurrentSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return [5][32]byte{}, consensustypes.ErrNotSupported("CurrentSyncCommitteeBranch", version.Electra)
+}
+
+func (h *bootstrapElectra) CurrentSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return h.currentSyncCommitteeBranch, nil
 }

consensus-types/light-client/update.go

@@ -100,8 +100,12 @@ func (u *updateAltair) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
-func (u *updateAltair) NextSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
-	return u.nextSyncCommitteeBranch
+func (u *updateAltair) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return u.nextSyncCommitteeBranch, nil
+}
+
+func (u *updateAltair) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return [6][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranchElectra", version.Altair)
 }
 
 func (u *updateAltair) FinalizedHeader() interfaces.LightClientHeader {
@@ -192,8 +196,12 @@ func (u *updateCapella) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
-func (u *updateCapella) NextSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
-	return u.nextSyncCommitteeBranch
+func (u *updateCapella) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return u.nextSyncCommitteeBranch, nil
+}
+
+func (u *updateCapella) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return [6][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranchElectra", version.Capella)
 }
 
 func (u *updateCapella) FinalizedHeader() interfaces.LightClientHeader {
@@ -284,8 +292,12 @@ func (u *updateDeneb) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
-func (u *updateDeneb) NextSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
-	return u.nextSyncCommitteeBranch
+func (u *updateDeneb) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return u.nextSyncCommitteeBranch, nil
+}
+
+func (u *updateDeneb) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return [6][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranchElectra", version.Deneb)
 }
 
 func (u *updateDeneb) FinalizedHeader() interfaces.LightClientHeader {
@@ -303,3 +315,99 @@ func (u *updateDeneb) SyncAggregate() *pb.SyncAggregate {
 func (u *updateDeneb) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
+
+type updateElectra struct {
+	p                       *pb.LightClientUpdateElectra
+	attestedHeader          interfaces.LightClientHeader
+	nextSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranchElectra
+	finalizedHeader         interfaces.LightClientHeader
+	finalityBranch          interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientUpdate = &updateElectra{}
+
+func NewWrappedUpdateElectra(p *pb.LightClientUpdateElectra) (interfaces.LightClientUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderDeneb(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranchElectra](
+		"sync committee",
+		p.NextSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepthElectra,
+	)
+	if err != nil {
+		return nil, err
+	}
+	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &updateElectra{
+		p:                       p,
+		attestedHeader:          attestedHeader,
+		nextSyncCommitteeBranch: scBranch,
+		finalizedHeader:         finalizedHeader,
+		finalityBranch:          finalityBranch,
+	}, nil
+}
+
+func (u *updateElectra) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *updateElectra) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *updateElectra) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *updateElectra) Version() int {
+	return version.Electra
+}
+
+func (u *updateElectra) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *updateElectra) NextSyncCommittee() *pb.SyncCommittee {
+	return u.p.NextSyncCommittee
+}
+
+func (u *updateElectra) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
+	return [5][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranch", version.Electra)
+}
+
+func (u *updateElectra) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
+	return u.nextSyncCommitteeBranch, nil
+}
+
+func (u *updateElectra) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *updateElectra) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *updateElectra) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *updateElectra) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}

proto/engine/v1/BUILD.bazel

@@ -48,7 +48,7 @@ ssz_gen_marshal(
         "WithdrawalRequest",
         "DepositRequest",
         "ConsolidationRequest",
-	"ExecutionRequests",
+        "ExecutionRequests",
     ],
 )
 
@@ -74,7 +74,7 @@ go_proto_library(
 go_library(
     name = "go_default_library",
     srcs = [
-	"electra.go",
+        "electra.go",
         "execution_engine.go",
         "json_marshal_unmarshal.go",
         ":ssz_generated_files",  # keep

proto/engine/v1/electra.go

@@ -1,4 +1,118 @@
 package enginev1
 
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
+)
+
 type ExecutionPayloadElectra = ExecutionPayloadDeneb
 type ExecutionPayloadHeaderElectra = ExecutionPayloadHeaderDeneb
+
+var (
+	drExample = &DepositRequest{}
+	drSize    = drExample.SizeSSZ()
+	wrExample = &WithdrawalRequest{}
+	wrSize    = wrExample.SizeSSZ()
+	crExample = &ConsolidationRequest{}
+	crSize    = crExample.SizeSSZ()
+)
+
+const LenExecutionRequestsElectra = 3
+
+func (ebe *ExecutionBundleElectra) GetDecodedExecutionRequests() (*ExecutionRequests, error) {
+	requests := &ExecutionRequests{}
+
+	if len(ebe.ExecutionRequests) != LenExecutionRequestsElectra /* types of requests */ {
+		return nil, errors.Errorf("invalid execution request size: %d", len(ebe.ExecutionRequests))
+	}
+
+	// deposit requests
+	drs, err := unmarshalItems(ebe.ExecutionRequests[0], drSize, func() *DepositRequest { return &DepositRequest{} })
+	if err != nil {
+		return nil, err
+	}
+	requests.Deposits = drs
+
+	// withdrawal requests
+	wrs, err := unmarshalItems(ebe.ExecutionRequests[1], wrSize, func() *WithdrawalRequest { return &WithdrawalRequest{} })
+	if err != nil {
+		return nil, err
+	}
+	requests.Withdrawals = wrs
+
+	// consolidation requests
+	crs, err := unmarshalItems(ebe.ExecutionRequests[2], crSize, func() *ConsolidationRequest { return &ConsolidationRequest{} })
+	if err != nil {
+		return nil, err
+	}
+	requests.Consolidations = crs
+
+	return requests, nil
+}
+
+func EncodeExecutionRequests(requests *ExecutionRequests) ([]hexutil.Bytes, error) {
+	if requests == nil {
+		return nil, errors.New("invalid execution requests")
+	}
+
+	drBytes, err := marshalItems(requests.Deposits)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshal deposit requests")
+	}
+
+	wrBytes, err := marshalItems(requests.Withdrawals)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshal withdrawal requests")
+	}
+
+	crBytes, err := marshalItems(requests.Consolidations)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshal consolidation requests")
+	}
+	return []hexutil.Bytes{drBytes, wrBytes, crBytes}, nil
+}
+
+type sszUnmarshaler interface {
+	UnmarshalSSZ([]byte) error
+}
+
+type sszMarshaler interface {
+	MarshalSSZTo(buf []byte) ([]byte, error)
+	SizeSSZ() int
+}
+
+func marshalItems[T sszMarshaler](items []T) ([]byte, error) {
+	if len(items) == 0 {
+		return []byte{}, nil
+	}
+	size := items[0].SizeSSZ()
+	buf := make([]byte, 0, size*len(items))
+	var err error
+	for i, item := range items {
+		buf, err = item.MarshalSSZTo(buf)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal item at index %d: %w", i, err)
+		}
+	}
+	return buf, nil
+}
+
+// Generic function to unmarshal items
+func unmarshalItems[T sszUnmarshaler](data []byte, itemSize int, newItem func() T) ([]T, error) {
+	if len(data)%itemSize != 0 {
+		return nil, fmt.Errorf("invalid data length: data size (%d) is not a multiple of item size (%d)", len(data), itemSize)
+	}
+	numItems := len(data) / itemSize
+	items := make([]T, numItems)
+	for i := range items {
+		itemBytes := data[i*itemSize : (i+1)*itemSize]
+		item := newItem()
+		if err := item.UnmarshalSSZ(itemBytes); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal item at index %d: %w", i, err)
+		}
+		items[i] = item
+	}
+	return items, nil
+}

proto/engine/v1/electra.pb.go

@@ -290,6 +290,85 @@ func (x *ExecutionRequests) GetConsolidations() []*ConsolidationRequest {
 	return nil
 }
 
+type ExecutionBundleElectra struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Payload               *ExecutionPayloadDeneb `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
+	Value                 []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	BlobsBundle           *BlobsBundle           `protobuf:"bytes,3,opt,name=blobs_bundle,json=blobsBundle,proto3" json:"blobs_bundle,omitempty"`
+	ShouldOverrideBuilder bool                   `protobuf:"varint,4,opt,name=should_override_builder,json=shouldOverrideBuilder,proto3" json:"should_override_builder,omitempty"`
+	ExecutionRequests     [][]byte               `protobuf:"bytes,5,rep,name=execution_requests,json=executionRequests,proto3" json:"execution_requests,omitempty"`
+}
+
+func (x *ExecutionBundleElectra) Reset() {
+	*x = ExecutionBundleElectra{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_engine_v1_electra_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExecutionBundleElectra) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExecutionBundleElectra) ProtoMessage() {}
+
+func (x *ExecutionBundleElectra) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_engine_v1_electra_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExecutionBundleElectra.ProtoReflect.Descriptor instead.
+func (*ExecutionBundleElectra) Descriptor() ([]byte, []int) {
+	return file_proto_engine_v1_electra_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *ExecutionBundleElectra) GetPayload() *ExecutionPayloadDeneb {
+	if x != nil {
+		return x.Payload
+	}
+	return nil
+}
+
+func (x *ExecutionBundleElectra) GetValue() []byte {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *ExecutionBundleElectra) GetBlobsBundle() *BlobsBundle {
+	if x != nil {
+		return x.BlobsBundle
+	}
+	return nil
+}
+
+func (x *ExecutionBundleElectra) GetShouldOverrideBuilder() bool {
+	if x != nil {
+		return x.ShouldOverrideBuilder
+	}
+	return false
+}
+
+func (x *ExecutionBundleElectra) GetExecutionRequests() [][]byte {
+	if x != nil {
+		return x.ExecutionRequests
+	}
+	return nil
+}
+
 var File_proto_engine_v1_electra_proto protoreflect.FileDescriptor
 
 var file_proto_engine_v1_electra_proto_rawDesc = []byte{
@@ -298,64 +377,85 @@ var file_proto_engine_v1_electra_proto_rawDesc = []byte{
 	0x12, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65,
 	0x2e, 0x76, 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, 0x8d, 0x01, 0x0a, 0x11, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
-	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06,
-	0x8a, 0xb5, 0x18, 0x02, 0x32, 0x30, 0x52, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x31, 0x0a, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x6f, 0x72, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42,
-	0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x52, 0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75,
-	0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
-	0x22, 0xc3, 0x01, 0x0a, 0x0e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x52, 0x06, 0x70, 0x75, 0x62,
-	0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x16, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61,
-	0x6c, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x15, 0x77, 0x69, 0x74,
-	0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61,
-	0x6c, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x09, 0x73, 0x69,
-	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
-	0xb5, 0x18, 0x02, 0x39, 0x36, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
-	0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x9f, 0x01, 0x0a, 0x14, 0x43, 0x6f, 0x6e, 0x73, 0x6f,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x2d, 0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x32, 0x30, 0x52,
-	0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2b,
-	0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x52, 0x0c, 0x73,
-	0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x0d, 0x74,
-	0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67,
-	0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x87, 0x02, 0x0a, 0x11, 0x45, 0x78, 0x65,
-	0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x48,
-	0x0a, 0x08, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69,
-	0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x42, 0x08, 0x92, 0xb5, 0x18, 0x04, 0x38, 0x31, 0x39, 0x32, 0x52, 0x08,
-	0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73, 0x12, 0x4f, 0x0a, 0x0b, 0x77, 0x69, 0x74, 0x68,
-	0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e,
-	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e,
-	0x76, 0x31, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x42, 0x06, 0x92, 0xb5, 0x18, 0x02, 0x31, 0x36, 0x52, 0x0b, 0x77, 0x69,
-	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x12, 0x57, 0x0a, 0x0e, 0x63, 0x6f, 0x6e,
-	0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67,
-	0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x05, 0x92, 0xb5, 0x18,
-	0x01, 0x31, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x42, 0x8e, 0x01, 0x0a, 0x16, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
-	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x45,
-	0x6c, 0x65, 0x63, 0x74, 0x72, 0x61, 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, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31,
-	0x3b, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x76, 0x31, 0xaa, 0x02, 0x12, 0x45, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x56, 0x31, 0xca, 0x02,
-	0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65,
-	0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x1a, 0x26, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76,
+	0x31, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x67, 0x69,
+	0x6e, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8d, 0x01, 0x0a, 0x11, 0x57, 0x69, 0x74,
+	0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d,
+	0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x32, 0x30, 0x52, 0x0d,
+	0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x31, 0x0a,
+	0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65,
+	0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x52,
+	0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79,
+	0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xc3, 0x01, 0x0a, 0x0e, 0x44, 0x65, 0x70,
+	0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x06, 0x70,
+	0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18,
+	0x02, 0x34, 0x38, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x16, 0x77,
+	0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e,
+	0x74, 0x69, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18,
+	0x02, 0x33, 0x32, 0x52, 0x15, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43,
+	0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x12, 0x24, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x39, 0x36, 0x52, 0x09, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65,
+	0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x9f,
+	0x01, 0x0a, 0x14, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63,
+	0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42,
+	0x06, 0x8a, 0xb5, 0x18, 0x02, 0x32, 0x30, 0x52, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2b, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
+	0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
+	0xb5, 0x18, 0x02, 0x34, 0x38, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62,
+	0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x75,
+	0x62, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02,
+	0x34, 0x38, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79,
+	0x22, 0x87, 0x02, 0x0a, 0x11, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x48, 0x0a, 0x08, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69,
+	0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65,
+	0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x08, 0x92, 0xb5,
+	0x18, 0x04, 0x38, 0x31, 0x39, 0x32, 0x52, 0x08, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73,
+	0x12, 0x4f, 0x0a, 0x0b, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
+	0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64,
+	0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x06, 0x92, 0xb5,
+	0x18, 0x02, 0x31, 0x36, 0x52, 0x0b, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c,
+	0x73, 0x12, 0x57, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43,
+	0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x42, 0x05, 0x92, 0xb5, 0x18, 0x01, 0x31, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x73,
+	0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x9e, 0x02, 0x0a, 0x16, 0x45,
+	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x45, 0x6c,
+	0x65, 0x63, 0x74, 0x72, 0x61, 0x12, 0x43, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63,
+	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x44, 0x65, 0x6e, 0x65,
+	0x62, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x12, 0x42, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x5f, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x62,
+	0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75,
+	0x6e, 0x64, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x5f, 0x6f,
+	0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65,
+	0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x12,
+	0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
+	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x42, 0x8e, 0x01, 0x0a, 0x16,
+	0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67,
+	0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x61, 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,
+	0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65,
+	0x76, 0x31, 0xaa, 0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x6e,
+	0x67, 0x69, 0x6e, 0x65, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x5c, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -370,22 +470,27 @@ func file_proto_engine_v1_electra_proto_rawDescGZIP() []byte {
 	return file_proto_engine_v1_electra_proto_rawDescData
 }
 
-var file_proto_engine_v1_electra_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_proto_engine_v1_electra_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
 var file_proto_engine_v1_electra_proto_goTypes = []interface{}{
-	(*WithdrawalRequest)(nil),    // 0: ethereum.engine.v1.WithdrawalRequest
-	(*DepositRequest)(nil),       // 1: ethereum.engine.v1.DepositRequest
-	(*ConsolidationRequest)(nil), // 2: ethereum.engine.v1.ConsolidationRequest
-	(*ExecutionRequests)(nil),    // 3: ethereum.engine.v1.ExecutionRequests
+	(*WithdrawalRequest)(nil),      // 0: ethereum.engine.v1.WithdrawalRequest
+	(*DepositRequest)(nil),         // 1: ethereum.engine.v1.DepositRequest
+	(*ConsolidationRequest)(nil),   // 2: ethereum.engine.v1.ConsolidationRequest
+	(*ExecutionRequests)(nil),      // 3: ethereum.engine.v1.ExecutionRequests
+	(*ExecutionBundleElectra)(nil), // 4: ethereum.engine.v1.ExecutionBundleElectra
+	(*ExecutionPayloadDeneb)(nil),  // 5: ethereum.engine.v1.ExecutionPayloadDeneb
+	(*BlobsBundle)(nil),            // 6: ethereum.engine.v1.BlobsBundle
 }
 var file_proto_engine_v1_electra_proto_depIdxs = []int32{
 	1, // 0: ethereum.engine.v1.ExecutionRequests.deposits:type_name -> ethereum.engine.v1.DepositRequest
 	0, // 1: ethereum.engine.v1.ExecutionRequests.withdrawals:type_name -> ethereum.engine.v1.WithdrawalRequest
 	2, // 2: ethereum.engine.v1.ExecutionRequests.consolidations:type_name -> ethereum.engine.v1.ConsolidationRequest
-	3, // [3:3] is the sub-list for method output_type
-	3, // [3:3] is the sub-list for method input_type
-	3, // [3:3] is the sub-list for extension type_name
-	3, // [3:3] is the sub-list for extension extendee
-	0, // [0:3] is the sub-list for field type_name
+	5, // 3: ethereum.engine.v1.ExecutionBundleElectra.payload:type_name -> ethereum.engine.v1.ExecutionPayloadDeneb
+	6, // 4: ethereum.engine.v1.ExecutionBundleElectra.blobs_bundle:type_name -> ethereum.engine.v1.BlobsBundle
+	5, // [5:5] is the sub-list for method output_type
+	5, // [5:5] is the sub-list for method input_type
+	5, // [5:5] is the sub-list for extension type_name
+	5, // [5:5] is the sub-list for extension extendee
+	0, // [0:5] is the sub-list for field type_name
 }
 
 func init() { file_proto_engine_v1_electra_proto_init() }
@@ -393,6 +498,7 @@ func file_proto_engine_v1_electra_proto_init() {
 	if File_proto_engine_v1_electra_proto != nil {
 		return
 	}
+	file_proto_engine_v1_execution_engine_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_proto_engine_v1_electra_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*WithdrawalRequest); i {
@@ -442,6 +548,18 @@ func file_proto_engine_v1_electra_proto_init() {
 				return nil
 			}
 		}
+		file_proto_engine_v1_electra_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExecutionBundleElectra); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -449,7 +567,7 @@ func file_proto_engine_v1_electra_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_engine_v1_electra_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   4,
+			NumMessages:   5,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/engine/v1/electra.proto

@@ -16,6 +16,7 @@ syntax = "proto3";
 package ethereum.engine.v1;
 
 import "proto/eth/ext/options.proto";
+import "proto/engine/v1/execution_engine.proto";
 
 option csharp_namespace = "Ethereum.Engine.V1";
 option go_package = "github.com/prysmaticlabs/prysm/v5/proto/engine/v1;enginev1";
@@ -60,7 +61,16 @@ message ConsolidationRequest {
 
 // ExecutionRequests is a container that contains all the requests from the execution layer to be included in a block
 message ExecutionRequests {
-        repeated DepositRequest deposits = 1 [(ethereum.eth.ext.ssz_max) = "max_deposit_requests_per_payload.size"];
+	repeated DepositRequest deposits = 1 [(ethereum.eth.ext.ssz_max) = "max_deposit_requests_per_payload.size"];
 	repeated WithdrawalRequest	withdrawals = 2 [(ethereum.eth.ext.ssz_max) = "max_withdrawal_requests_per_payload.size"];
-        repeated ConsolidationRequest consolidations = 3 [(ethereum.eth.ext.ssz_max) = "max_consolidation_requests_per_payload.size"];
+	repeated ConsolidationRequest consolidations = 3 [(ethereum.eth.ext.ssz_max) = "max_consolidation_requests_per_payload.size"];
+}
+
+// ExecutionBundleElectra is a container that builds on Payload V4 and includes execution requests sidecar needed post Electra
+message ExecutionBundleElectra {
+	ExecutionPayloadDeneb payload = 1;
+	bytes value = 2;
+	BlobsBundle blobs_bundle = 3;
+	bool should_override_builder = 4;
+	repeated bytes execution_requests = 5;
 }

proto/engine/v1/electra_test.go

@@ -0,0 +1,56 @@
+package enginev1_test
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+var depositRequestsSSZHex = "0x706b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000077630000000000000000000000000000000000000000000000000000000000007b00000000000000736967000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c801000000000000706b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000776300000000000000000000000000000000000000000000000000000000000090010000000000007369670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000"
+
+func TestUnmarshalItems_OK(t *testing.T) {
+	drb, err := hexutil.Decode(depositRequestsSSZHex)
+	require.NoError(t, err)
+	exampleRequest := &enginev1.DepositRequest{}
+	depositRequests, err := enginev1.UnmarshalItems(drb, exampleRequest.SizeSSZ(), func() *enginev1.DepositRequest { return &enginev1.DepositRequest{} })
+	require.NoError(t, err)
+
+	exampleRequest1 := &enginev1.DepositRequest{
+		Pubkey:                bytesutil.PadTo([]byte("pk"), 48),
+		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
+		Amount:                123,
+		Signature:             bytesutil.PadTo([]byte("sig"), 96),
+		Index:                 456,
+	}
+	exampleRequest2 := &enginev1.DepositRequest{
+		Pubkey:                bytesutil.PadTo([]byte("pk"), 48),
+		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
+		Amount:                400,
+		Signature:             bytesutil.PadTo([]byte("sig"), 96),
+		Index:                 32,
+	}
+	require.DeepEqual(t, depositRequests, []*enginev1.DepositRequest{exampleRequest1, exampleRequest2})
+}
+
+func TestMarshalItems_OK(t *testing.T) {
+	exampleRequest1 := &enginev1.DepositRequest{
+		Pubkey:                bytesutil.PadTo([]byte("pk"), 48),
+		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
+		Amount:                123,
+		Signature:             bytesutil.PadTo([]byte("sig"), 96),
+		Index:                 456,
+	}
+	exampleRequest2 := &enginev1.DepositRequest{
+		Pubkey:                bytesutil.PadTo([]byte("pk"), 48),
+		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
+		Amount:                400,
+		Signature:             bytesutil.PadTo([]byte("sig"), 96),
+		Index:                 32,
+	}
+	drbs, err := enginev1.MarshalItems([]*enginev1.DepositRequest{exampleRequest1, exampleRequest2})
+	require.NoError(t, err)
+	require.DeepEqual(t, depositRequestsSSZHex, hexutil.Encode(drbs))
+}

proto/engine/v1/execution_engine.pb.go

@@ -1697,53 +1697,6 @@ func (x *Blob) GetData() []byte {
 	return nil
 }
 
-type ExchangeCapabilities struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	SupportedMethods []string `protobuf:"bytes,1,rep,name=supported_methods,json=supportedMethods,proto3" json:"supported_methods,omitempty"`
-}
-
-func (x *ExchangeCapabilities) Reset() {
-	*x = ExchangeCapabilities{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_engine_v1_execution_engine_proto_msgTypes[16]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ExchangeCapabilities) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ExchangeCapabilities) ProtoMessage() {}
-
-func (x *ExchangeCapabilities) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_engine_v1_execution_engine_proto_msgTypes[16]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ExchangeCapabilities.ProtoReflect.Descriptor instead.
-func (*ExchangeCapabilities) Descriptor() ([]byte, []int) {
-	return file_proto_engine_v1_execution_engine_proto_rawDescGZIP(), []int{16}
-}
-
-func (x *ExchangeCapabilities) GetSupportedMethods() []string {
-	if x != nil {
-		return x.SupportedMethods
-	}
-	return nil
-}
-
 var File_proto_engine_v1_execution_engine_proto protoreflect.FileDescriptor
 
 var file_proto_engine_v1_execution_engine_proto_rawDesc = []byte{
@@ -2119,22 +2072,17 @@ var file_proto_engine_v1_execution_engine_proto_rawDesc = []byte{
 	0x31, 0x30, 0x37, 0x32, 0x92, 0xb5, 0x18, 0x04, 0x34, 0x30, 0x39, 0x36, 0x52, 0x05, 0x62, 0x6c,
 	0x6f, 0x62, 0x73, 0x22, 0x26, 0x0a, 0x04, 0x42, 0x6c, 0x6f, 0x62, 0x12, 0x1e, 0x0a, 0x04, 0x64,
 	0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x0a, 0x8a, 0xb5, 0x18, 0x06, 0x31,
-	0x33, 0x31, 0x30, 0x37, 0x32, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x43, 0x0a, 0x14, 0x45,
-	0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
-	0x69, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64,
-	0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10,
-	0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73,
-	0x42, 0x96, 0x01, 0x0a, 0x16, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
-	0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x14, 0x45, 0x78, 0x65,
-	0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 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, 0x65, 0x6e, 0x67,
-	0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x76, 0x31, 0xaa,
-	0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x6e, 0x67, 0x69, 0x6e,
-	0x65, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c,
-	0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x33,
+	0x33, 0x31, 0x30, 0x37, 0x32, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0x96, 0x01, 0x0a, 0x16,
+	0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67,
+	0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x14, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f,
+	0x6e, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 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, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76,
+	0x31, 0x3b, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x76, 0x31, 0xaa, 0x02, 0x12, 0x45, 0x74, 0x68,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x56, 0x31, 0xca,
+	0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x6e, 0x67, 0x69, 0x6e,
+	0x65, 0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -2150,7 +2098,7 @@ func file_proto_engine_v1_execution_engine_proto_rawDescGZIP() []byte {
 }
 
 var file_proto_engine_v1_execution_engine_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_proto_engine_v1_execution_engine_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
+var file_proto_engine_v1_execution_engine_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
 var file_proto_engine_v1_execution_engine_proto_goTypes = []interface{}{
 	(PayloadStatus_Status)(0),                            // 0: ethereum.engine.v1.PayloadStatus.Status
 	(*ExecutionPayload)(nil),                             // 1: ethereum.engine.v1.ExecutionPayload
@@ -2169,7 +2117,6 @@ var file_proto_engine_v1_execution_engine_proto_goTypes = []interface{}{
 	(*Withdrawal)(nil),                                   // 14: ethereum.engine.v1.Withdrawal
 	(*BlobsBundle)(nil),                                  // 15: ethereum.engine.v1.BlobsBundle
 	(*Blob)(nil),                                         // 16: ethereum.engine.v1.Blob
-	(*ExchangeCapabilities)(nil),                         // 17: ethereum.engine.v1.ExchangeCapabilities
 }
 var file_proto_engine_v1_execution_engine_proto_depIdxs = []int32{
 	14, // 0: ethereum.engine.v1.ExecutionPayloadCapella.withdrawals:type_name -> ethereum.engine.v1.Withdrawal
@@ -2385,18 +2332,6 @@ func file_proto_engine_v1_execution_engine_proto_init() {
 				return nil
 			}
 		}
-		file_proto_engine_v1_execution_engine_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ExchangeCapabilities); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -2404,7 +2339,7 @@ func file_proto_engine_v1_execution_engine_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_engine_v1_execution_engine_proto_rawDesc,
 			NumEnums:      1,
-			NumMessages:   17,
+			NumMessages:   16,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/engine/v1/execution_engine.proto

@@ -224,6 +224,3 @@ message Blob {
 	bytes data = 1 [(ethereum.eth.ext.ssz_size) = "blob.size"];
 }
 
-message ExchangeCapabilities {
-	repeated string supported_methods = 1;
-}

proto/engine/v1/export_test.go

@@ -1,3 +1,11 @@
 package enginev1
 
 type Copier[T any] copier[T]
+
+func MarshalItems[T sszMarshaler](items []T) ([]byte, error) {
+	return marshalItems(items)
+}
+
+func UnmarshalItems[T sszUnmarshaler](data []byte, itemSize int, newItem func() T) ([]T, error) {
+	return unmarshalItems(data, itemSize, newItem)
+}