Update CHANGELOG.md

* reduce validator registration logs

* reverting a log change that's probably better as warn

* Update CHANGELOG.md

---------

Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com>
Co-authored-by: Preston Van Loon <preston@pvl.dev>

.github/PULL_REQUEST_TEMPLATE.md

@@ -10,6 +10,7 @@
    in review.
 4. Note that PRs updating dependencies and new Go versions are not accepted.
    Please file an issue instead.
+5. A changelog entry is required for user facing issues.
 -->
 
 **What type of PR is this?**
@@ -28,3 +29,9 @@
 Fixes #
 
 **Other notes for review**
+
+**Acknowledgements**
+
+- [ ] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
+- [ ] I have made an appropriate entry to [CHANGELOG.md](https://github.com/prysmaticlabs/prysm/blob/develop/CHANGELOG.md).
+- [ ] I have added a description to this PR with sufficient context for reviewers to understand this PR.

.github/workflows/changelog.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+jobs:
+  changed_files:
+    runs-on: ubuntu-latest 
+    name: Check CHANGELOG.md
+    steps:
+      - uses: actions/checkout@v4
+      - name: changelog modified
+        id: changelog-modified
+        uses: tj-actions/changed-files@v45
+        with:
+          files: CHANGELOG.md
+
+      - name: List all changed files
+        env:
+          ALL_CHANGED_FILES: ${{ steps.changelog-modified.outputs.all_changed_files }}
+        run: |
+          if [[ ${ALL_CHANGED_FILES[*]} =~ (^|[[:space:]])"CHANGELOG.md"($|[[:space:]]) ]];
+          then
+            echo "CHANGELOG.md was modified.";
+            exit 0;
+          else
+            echo "CHANGELOG.md was not modified.";
+            echo "Please see CHANGELOG.md and follow the instructions to add your changes to that file."
+            echo "In some rare scenarios, a changelog entry is not required and this CI check can be ignored."
+            exit 1;
+          fi

CONTRIBUTING.md

@@ -6,6 +6,8 @@ Excited by our work and want to get involved in building out our sharding releas
 
 You can explore our [Open Issues](https://github.com/prysmaticlabs/prysm/issues) in-the works for our different releases. Feel free to fork our repo and start creating PR’s after assigning yourself to an issue of interest. We are always chatting on [Discord](https://discord.gg/CTYGPUJ) drop us a line there if you want to get more involved or have any questions on our implementation!
 
+Please, do not send pull requests for trivial changes, such as typos, these will be rejected. These types of pull requests incur a cost to reviewers and do not provide much value to the project. If you are unsure, please open an issue first to discuss the change.
+
 ## Contribution Steps
 
 **1. Set up Prysm following the instructions in README.md.**
@@ -120,15 +122,19 @@ $ git push myrepo feature-in-progress-branch
 
 Navigate to your fork of the repo on GitHub. On the upper left where the current branch is listed, change the branch to your feature-in-progress-branch. Open the files that you have worked on and check to make sure they include your changes.
 
-**16. Create a pull request.**
+**16. Add an entry to CHANGELOG.md.**
 
-Navigate your browser to https://github.com/prysmaticlabs/prysm and click on the new pull request button. In the “base” box on the left, leave the default selection “base master”, the branch that you want your changes to be applied to. In the “compare” box on the right, select feature-in-progress-branch, the branch containing the changes you want to apply. You will then be asked to answer a few questions about your pull request. After you complete the questionnaire, the pull request will appear in the list of pull requests at https://github.com/prysmaticlabs/prysm/pulls.
+If your change is user facing, you must include a CHANGELOG.md entry. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
 
-**17. Respond to comments by Core Contributors.**
+**17. Create a pull request.**
+
+Navigate your browser to https://github.com/prysmaticlabs/prysm and click on the new pull request button. In the “base” box on the left, leave the default selection “base master”, the branch that you want your changes to be applied to. In the “compare” box on the right, select feature-in-progress-branch, the branch containing the changes you want to apply. You will then be asked to answer a few questions about your pull request. After you complete the questionnaire, the pull request will appear in the list of pull requests at https://github.com/prysmaticlabs/prysm/pulls. Ensure that you have added an entry to CHANGELOG.md if your PR is a user-facing change. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
+
+**18. Respond to comments by Core Contributors.**
 
 Core Contributors may ask questions and request that you make edits. If you set notifications at the top of the page to “not watching,” you will still be notified by email whenever someone comments on the page of a pull request you have created. If you are asked to modify your pull request, repeat steps 8 through 15, then leave a comment to notify the Core Contributors that the pull request is ready for further review.
 
-**18. If the number of commits becomes excessive, you may be asked to squash your commits.**
+**19. If the number of commits becomes excessive, you may be asked to squash your commits.**
 
  You can do this with an interactive rebase. Start by running the following command to determine the commit that is the base of your branch...
 
@@ -136,7 +142,7 @@ Core Contributors may ask questions and request that you make edits. If you set
 $ git merge-base feature-in-progress-branch prysm/master
 ```
 
-**19. The previous command will return a commit-hash that you should use in the following command.**
+**20. The previous command will return a commit-hash that you should use in the following command.**
 
 ```
 $ git rebase -i commit-hash
@@ -160,13 +166,30 @@ squash  hash 	add a feature
 
 Save and close the file, then a commit command will appear in the terminal that squashes the smaller commits into one. Check to be sure the commit message accurately reflects your changes and then hit enter to execute it.
 
-**20. Update your pull request with the following command.**
+**21. Update your pull request with the following command.**
 
 ```
 $ git push myrepo feature-in-progress-branch -f
 ```
 
-**21.  Finally, again leave a comment to the Core Contributors on the pull request to let them know that the pull request has been updated.**
+**22.  Finally, again leave a comment to the Core Contributors on the pull request to let them know that the pull request has been updated.**
+
+## Maintaining CHANGELOG.md
+
+This project follows the changelog guidelines from [keepachangelog.com](https://keepachangelog.com/en/1.1.0/).
+
+All PRs with user facing changes should have an entry in the CHANGELOG.md file and the change should be categorized in the appropriate category within the "Unreleased" section. The categories are:
+
+-  `Added` for new features.
+-  `Changed` for changes in existing functionality.
+-  `Deprecated` for soon-to-be removed features.
+-  `Removed` for now removed features.
+-  `Fixed` for any bug fixes.
+-  `Security` in case of vulnerabilities. Please see the [Security Policy](SECURITY.md) for responsible disclosure before adding a change with this category.
+
+### Releasing
+
+When a new release is made, the "Unreleased" section should be moved to a new section with the release version and the current date. Then a new "Unreleased" section is made at the top of the file with the categories listed above.
 
 ## Contributor Responsibilities
 

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.3"
+consensus_spec_version = "v1.5.0-alpha.5"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-+byv+GUOQytex5GgtjBGVoNDseJZbiBdAjEtlgCbjEo=",
+    integrity = "sha256-R9vG5HEL5eGMOAmbkKfJ2jfelNqL5V0xBUPiXOiGM6U=",
     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-JJUy/jT1h3kGQkinTuzL7gMOA1+qgmPgJXVrYuH63Cg=",
+    integrity = "sha256-AEIiEOlf1XuxoRMCsN+kgJMo4LrS05+biTA1p/7Ro00=",
     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-T2VM4Qd0SwgGnTjWxjOX297DqEsovO9Ueij1UEJy48Y=",
+    integrity = "sha256-LH/Xr20yrJRYnbpjRGupMWTIOWt3cpxZJWXgThwVDsk=",
     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-OP9BCBcQ7i+93bwj7ktY8pZ5uWsGjgTe4XTp7BDhX+I=",
+    integrity = "sha256-mlytz4MPjKh0DwV7FMiAtnRbJw9B6o78/x66/vmnYc8=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/server/structs/block.go

@@ -317,6 +317,94 @@ type BlindedBeaconBlockBodyDeneb struct {
 	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
 }
 
+type SignedBeaconBlockContentsElectra struct {
+	SignedBlock *SignedBeaconBlockElectra `json:"signed_block"`
+	KzgProofs   []string                  `json:"kzg_proofs"`
+	Blobs       []string                  `json:"blobs"`
+}
+
+type BeaconBlockContentsElectra struct {
+	Block     *BeaconBlockElectra `json:"block"`
+	KzgProofs []string            `json:"kzg_proofs"`
+	Blobs     []string            `json:"blobs"`
+}
+
+type SignedBeaconBlockElectra struct {
+	Message   *BeaconBlockElectra `json:"message"`
+	Signature string              `json:"signature"`
+}
+
+var _ SignedMessageJsoner = &SignedBeaconBlockElectra{}
+
+func (s *SignedBeaconBlockElectra) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockElectra) SigString() string {
+	return s.Signature
+}
+
+type BeaconBlockElectra struct {
+	Slot          string                  `json:"slot"`
+	ProposerIndex string                  `json:"proposer_index"`
+	ParentRoot    string                  `json:"parent_root"`
+	StateRoot     string                  `json:"state_root"`
+	Body          *BeaconBlockBodyElectra `json:"body"`
+}
+
+type BeaconBlockBodyElectra struct {
+	RandaoReveal          string                        `json:"randao_reveal"`
+	Eth1Data              *Eth1Data                     `json:"eth1_data"`
+	Graffiti              string                        `json:"graffiti"`
+	ProposerSlashings     []*ProposerSlashing           `json:"proposer_slashings"`
+	AttesterSlashings     []*AttesterSlashingElectra    `json:"attester_slashings"`
+	Attestations          []*AttestationElectra         `json:"attestations"`
+	Deposits              []*Deposit                    `json:"deposits"`
+	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits"`
+	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
+	ExecutionPayload      *ExecutionPayloadElectra      `json:"execution_payload"`
+	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
+	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
+}
+
+type BlindedBeaconBlockElectra struct {
+	Slot          string                         `json:"slot"`
+	ProposerIndex string                         `json:"proposer_index"`
+	ParentRoot    string                         `json:"parent_root"`
+	StateRoot     string                         `json:"state_root"`
+	Body          *BlindedBeaconBlockBodyElectra `json:"body"`
+}
+
+type SignedBlindedBeaconBlockElectra struct {
+	Message   *BlindedBeaconBlockElectra `json:"message"`
+	Signature string                     `json:"signature"`
+}
+
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockElectra{}
+
+func (s *SignedBlindedBeaconBlockElectra) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockElectra) SigString() string {
+	return s.Signature
+}
+
+type BlindedBeaconBlockBodyElectra struct {
+	RandaoReveal           string                         `json:"randao_reveal"`
+	Eth1Data               *Eth1Data                      `json:"eth1_data"`
+	Graffiti               string                         `json:"graffiti"`
+	ProposerSlashings      []*ProposerSlashing            `json:"proposer_slashings"`
+	AttesterSlashings      []*AttesterSlashingElectra     `json:"attester_slashings"`
+	Attestations           []*AttestationElectra          `json:"attestations"`
+	Deposits               []*Deposit                     `json:"deposits"`
+	VoluntaryExits         []*SignedVoluntaryExit         `json:"voluntary_exits"`
+	SyncAggregate          *SyncAggregate                 `json:"sync_aggregate"`
+	ExecutionPayloadHeader *ExecutionPayloadHeaderElectra `json:"execution_payload_header"`
+	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
+	BlobKzgCommitments     []string                       `json:"blob_kzg_commitments"`
+}
+
 type SignedBeaconBlockHeaderContainer struct {
 	Header    *SignedBeaconBlockHeader `json:"header"`
 	Root      string                   `json:"root"`
@@ -445,3 +533,49 @@ type ExecutionPayloadHeaderDeneb struct {
 	BlobGasUsed      string `json:"blob_gas_used"`
 	ExcessBlobGas    string `json:"excess_blob_gas"`
 }
+
+type ExecutionPayloadElectra struct {
+	ParentHash            string                  `json:"parent_hash"`
+	FeeRecipient          string                  `json:"fee_recipient"`
+	StateRoot             string                  `json:"state_root"`
+	ReceiptsRoot          string                  `json:"receipts_root"`
+	LogsBloom             string                  `json:"logs_bloom"`
+	PrevRandao            string                  `json:"prev_randao"`
+	BlockNumber           string                  `json:"block_number"`
+	GasLimit              string                  `json:"gas_limit"`
+	GasUsed               string                  `json:"gas_used"`
+	Timestamp             string                  `json:"timestamp"`
+	ExtraData             string                  `json:"extra_data"`
+	BaseFeePerGas         string                  `json:"base_fee_per_gas"`
+	BlockHash             string                  `json:"block_hash"`
+	Transactions          []string                `json:"transactions"`
+	Withdrawals           []*Withdrawal           `json:"withdrawals"`
+	BlobGasUsed           string                  `json:"blob_gas_used"`
+	ExcessBlobGas         string                  `json:"excess_blob_gas"`
+	DepositRequests       []*DepositRequest       `json:"deposit_requests"`
+	WithdrawalRequests    []*WithdrawalRequest    `json:"withdrawal_requests"`
+	ConsolidationRequests []*ConsolidationRequest `json:"consolidation_requests"`
+}
+
+type ExecutionPayloadHeaderElectra struct {
+	ParentHash                string `json:"parent_hash"`
+	FeeRecipient              string `json:"fee_recipient"`
+	StateRoot                 string `json:"state_root"`
+	ReceiptsRoot              string `json:"receipts_root"`
+	LogsBloom                 string `json:"logs_bloom"`
+	PrevRandao                string `json:"prev_randao"`
+	BlockNumber               string `json:"block_number"`
+	GasLimit                  string `json:"gas_limit"`
+	GasUsed                   string `json:"gas_used"`
+	Timestamp                 string `json:"timestamp"`
+	ExtraData                 string `json:"extra_data"`
+	BaseFeePerGas             string `json:"base_fee_per_gas"`
+	BlockHash                 string `json:"block_hash"`
+	TransactionsRoot          string `json:"transactions_root"`
+	WithdrawalsRoot           string `json:"withdrawals_root"`
+	BlobGasUsed               string `json:"blob_gas_used"`
+	ExcessBlobGas             string `json:"excess_blob_gas"`
+	DepositRequestsRoot       string `json:"deposit_requests_root"`
+	WithdrawalRequestsRoot    string `json:"withdrawal_requests_root"`
+	ConsolidationRequestsRoot string `json:"consolidation_requests_root"`
+}

api/server/structs/conversions.go

@@ -340,6 +340,42 @@ func (a *AggregateAttestationAndProof) ToConsensus() (*eth.AggregateAttestationA
 	}, nil
 }
 
+func (s *SignedAggregateAttestationAndProofElectra) ToConsensus() (*eth.SignedAggregateAttestationAndProofElectra, error) {
+	msg, err := s.Message.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Message")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(s.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+
+	return &eth.SignedAggregateAttestationAndProofElectra{
+		Message:   msg,
+		Signature: sig,
+	}, nil
+}
+
+func (a *AggregateAttestationAndProofElectra) ToConsensus() (*eth.AggregateAttestationAndProofElectra, error) {
+	aggIndex, err := strconv.ParseUint(a.AggregatorIndex, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "AggregatorIndex")
+	}
+	agg, err := a.Aggregate.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Aggregate")
+	}
+	proof, err := bytesutil.DecodeHexWithLength(a.SelectionProof, 96)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SelectionProof")
+	}
+	return &eth.AggregateAttestationAndProofElectra{
+		AggregatorIndex: primitives.ValidatorIndex(aggIndex),
+		Aggregate:       agg,
+		SelectionProof:  proof,
+	}, nil
+}
+
 func (a *Attestation) ToConsensus() (*eth.Attestation, error) {
 	aggBits, err := hexutil.Decode(a.AggregationBits)
 	if err != nil {
@@ -369,6 +405,41 @@ func AttFromConsensus(a *eth.Attestation) *Attestation {
 	}
 }
 
+func (a *AttestationElectra) ToConsensus() (*eth.AttestationElectra, error) {
+	aggBits, err := hexutil.Decode(a.AggregationBits)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "AggregationBits")
+	}
+	data, err := a.Data.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Data")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(a.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+	committeeBits, err := hexutil.Decode(a.CommitteeBits)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "CommitteeBits")
+	}
+
+	return &eth.AttestationElectra{
+		AggregationBits: aggBits,
+		Data:            data,
+		Signature:       sig,
+		CommitteeBits:   committeeBits,
+	}, nil
+}
+
+func AttElectraFromConsensus(a *eth.AttestationElectra) *AttestationElectra {
+	return &AttestationElectra{
+		AggregationBits: hexutil.Encode(a.AggregationBits),
+		Data:            AttDataFromConsensus(a.Data),
+		Signature:       hexutil.Encode(a.Signature),
+		CommitteeBits:   hexutil.Encode(a.CommitteeBits),
+	}
+}
+
 func (a *AttestationData) ToConsensus() (*eth.AttestationData, error) {
 	slot, err := strconv.ParseUint(a.Slot, 10, 64)
 	if err != nil {
@@ -623,6 +694,18 @@ func (s *AttesterSlashing) ToConsensus() (*eth.AttesterSlashing, error) {
 	return &eth.AttesterSlashing{Attestation_1: att1, Attestation_2: att2}, nil
 }
 
+func (s *AttesterSlashingElectra) ToConsensus() (*eth.AttesterSlashingElectra, error) {
+	att1, err := s.Attestation1.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Attestation1")
+	}
+	att2, err := s.Attestation2.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Attestation2")
+	}
+	return &eth.AttesterSlashingElectra{Attestation_1: att1, Attestation_2: att2}, nil
+}
+
 func (a *IndexedAttestation) ToConsensus() (*eth.IndexedAttestation, error) {
 	indices := make([]uint64, len(a.AttestingIndices))
 	var err error
@@ -648,6 +731,31 @@ func (a *IndexedAttestation) ToConsensus() (*eth.IndexedAttestation, error) {
 	}, nil
 }
 
+func (a *IndexedAttestationElectra) ToConsensus() (*eth.IndexedAttestationElectra, error) {
+	indices := make([]uint64, len(a.AttestingIndices))
+	var err error
+	for i, ix := range a.AttestingIndices {
+		indices[i], err = strconv.ParseUint(ix, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("AttestingIndices[%d]", i))
+		}
+	}
+	data, err := a.Data.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Data")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(a.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+
+	return &eth.IndexedAttestationElectra{
+		AttestingIndices: indices,
+		Data:             data,
+		Signature:        sig,
+	}, nil
+}
+
 func WithdrawalsFromConsensus(ws []*enginev1.Withdrawal) []*Withdrawal {
 	result := make([]*Withdrawal, len(ws))
 	for i, w := range ws {
@@ -665,6 +773,126 @@ func WithdrawalFromConsensus(w *enginev1.Withdrawal) *Withdrawal {
 	}
 }
 
+func WithdrawalRequestsFromConsensus(ws []*enginev1.WithdrawalRequest) []*WithdrawalRequest {
+	result := make([]*WithdrawalRequest, len(ws))
+	for i, w := range ws {
+		result[i] = WithdrawalRequestFromConsensus(w)
+	}
+	return result
+}
+
+func WithdrawalRequestFromConsensus(w *enginev1.WithdrawalRequest) *WithdrawalRequest {
+	return &WithdrawalRequest{
+		SourceAddress:   hexutil.Encode(w.SourceAddress),
+		ValidatorPubkey: hexutil.Encode(w.ValidatorPubkey),
+		Amount:          fmt.Sprintf("%d", w.Amount),
+	}
+}
+
+func (w *WithdrawalRequest) ToConsensus() (*enginev1.WithdrawalRequest, error) {
+	src, err := bytesutil.DecodeHexWithLength(w.SourceAddress, common.AddressLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SourceAddress")
+	}
+	pubkey, err := bytesutil.DecodeHexWithLength(w.ValidatorPubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ValidatorPubkey")
+	}
+	amount, err := strconv.ParseUint(w.Amount, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Amount")
+	}
+	return &enginev1.WithdrawalRequest{
+		SourceAddress:   src,
+		ValidatorPubkey: pubkey,
+		Amount:          amount,
+	}, nil
+}
+
+func ConsolidationRequestsFromConsensus(cs []*enginev1.ConsolidationRequest) []*ConsolidationRequest {
+	result := make([]*ConsolidationRequest, len(cs))
+	for i, c := range cs {
+		result[i] = ConsolidationRequestFromConsensus(c)
+	}
+	return result
+}
+
+func ConsolidationRequestFromConsensus(c *enginev1.ConsolidationRequest) *ConsolidationRequest {
+	return &ConsolidationRequest{
+		SourceAddress: hexutil.Encode(c.SourceAddress),
+		SourcePubkey:  hexutil.Encode(c.SourcePubkey),
+		TargetPubkey:  hexutil.Encode(c.TargetPubkey),
+	}
+}
+
+func (c *ConsolidationRequest) ToConsensus() (*enginev1.ConsolidationRequest, error) {
+	srcAddress, err := bytesutil.DecodeHexWithLength(c.SourceAddress, common.AddressLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SourceAddress")
+	}
+	srcPubkey, err := bytesutil.DecodeHexWithLength(c.SourcePubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SourcePubkey")
+	}
+	targetPubkey, err := bytesutil.DecodeHexWithLength(c.TargetPubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "TargetPubkey")
+	}
+	return &enginev1.ConsolidationRequest{
+		SourceAddress: srcAddress,
+		SourcePubkey:  srcPubkey,
+		TargetPubkey:  targetPubkey,
+	}, nil
+}
+
+func DepositRequestsFromConsensus(ds []*enginev1.DepositRequest) []*DepositRequest {
+	result := make([]*DepositRequest, len(ds))
+	for i, d := range ds {
+		result[i] = DepositRequestFromConsensus(d)
+	}
+	return result
+}
+
+func DepositRequestFromConsensus(d *enginev1.DepositRequest) *DepositRequest {
+	return &DepositRequest{
+		Pubkey:                hexutil.Encode(d.Pubkey),
+		WithdrawalCredentials: hexutil.Encode(d.WithdrawalCredentials),
+		Amount:                fmt.Sprintf("%d", d.Amount),
+		Signature:             hexutil.Encode(d.Signature),
+		Index:                 fmt.Sprintf("%d", d.Index),
+	}
+}
+
+func (d *DepositRequest) ToConsensus() (*enginev1.DepositRequest, error) {
+	pubkey, err := bytesutil.DecodeHexWithLength(d.Pubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Pubkey")
+	}
+	withdrawalCredentials, err := bytesutil.DecodeHexWithLength(d.WithdrawalCredentials, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "WithdrawalCredentials")
+	}
+	amount, err := strconv.ParseUint(d.Amount, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Amount")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(d.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+	index, err := strconv.ParseUint(d.Index, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Index")
+	}
+	return &enginev1.DepositRequest{
+		Pubkey:                pubkey,
+		WithdrawalCredentials: withdrawalCredentials,
+		Amount:                amount,
+		Signature:             sig,
+		Index:                 index,
+	}, nil
+}
+
 func ProposerSlashingsToConsensus(src []*ProposerSlashing) ([]*eth.ProposerSlashing, error) {
 	if src == nil {
 		return nil, errNilValue
@@ -930,6 +1158,138 @@ func AttesterSlashingFromConsensus(src *eth.AttesterSlashing) *AttesterSlashing
 	}
 }
 
+func AttesterSlashingsElectraToConsensus(src []*AttesterSlashingElectra) ([]*eth.AttesterSlashingElectra, error) {
+	if src == nil {
+		return nil, errNilValue
+	}
+	err := slice.VerifyMaxLength(src, 2)
+	if err != nil {
+		return nil, err
+	}
+
+	attesterSlashings := make([]*eth.AttesterSlashingElectra, len(src))
+	for i, s := range src {
+		if s == nil {
+			return nil, server.NewDecodeError(errNilValue, fmt.Sprintf("[%d]", i))
+		}
+		if s.Attestation1 == nil {
+			return nil, server.NewDecodeError(errNilValue, fmt.Sprintf("[%d].Attestation1", i))
+		}
+		if s.Attestation2 == nil {
+			return nil, server.NewDecodeError(errNilValue, fmt.Sprintf("[%d].Attestation2", i))
+		}
+
+		a1Sig, err := bytesutil.DecodeHexWithLength(s.Attestation1.Signature, fieldparams.BLSSignatureLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.Signature", i))
+		}
+		err = slice.VerifyMaxLength(s.Attestation1.AttestingIndices, 2048)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.AttestingIndices", i))
+		}
+		a1AttestingIndices := make([]uint64, len(s.Attestation1.AttestingIndices))
+		for j, ix := range s.Attestation1.AttestingIndices {
+			attestingIndex, err := strconv.ParseUint(ix, 10, 64)
+			if err != nil {
+				return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.AttestingIndices[%d]", i, j))
+			}
+			a1AttestingIndices[j] = attestingIndex
+		}
+		a1Data, err := s.Attestation1.Data.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.Data", i))
+		}
+		a2Sig, err := bytesutil.DecodeHexWithLength(s.Attestation2.Signature, fieldparams.BLSSignatureLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.Signature", i))
+		}
+		err = slice.VerifyMaxLength(s.Attestation2.AttestingIndices, 2048)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.AttestingIndices", i))
+		}
+		a2AttestingIndices := make([]uint64, len(s.Attestation2.AttestingIndices))
+		for j, ix := range s.Attestation2.AttestingIndices {
+			attestingIndex, err := strconv.ParseUint(ix, 10, 64)
+			if err != nil {
+				return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.AttestingIndices[%d]", i, j))
+			}
+			a2AttestingIndices[j] = attestingIndex
+		}
+		a2Data, err := s.Attestation2.Data.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.Data", i))
+		}
+		attesterSlashings[i] = &eth.AttesterSlashingElectra{
+			Attestation_1: &eth.IndexedAttestationElectra{
+				AttestingIndices: a1AttestingIndices,
+				Data:             a1Data,
+				Signature:        a1Sig,
+			},
+			Attestation_2: &eth.IndexedAttestationElectra{
+				AttestingIndices: a2AttestingIndices,
+				Data:             a2Data,
+				Signature:        a2Sig,
+			},
+		}
+	}
+	return attesterSlashings, nil
+}
+
+func AttesterSlashingsElectraFromConsensus(src []*eth.AttesterSlashingElectra) []*AttesterSlashingElectra {
+	attesterSlashings := make([]*AttesterSlashingElectra, len(src))
+	for i, s := range src {
+		attesterSlashings[i] = AttesterSlashingElectraFromConsensus(s)
+	}
+	return attesterSlashings
+}
+
+func AttesterSlashingElectraFromConsensus(src *eth.AttesterSlashingElectra) *AttesterSlashingElectra {
+	a1AttestingIndices := make([]string, len(src.Attestation_1.AttestingIndices))
+	for j, ix := range src.Attestation_1.AttestingIndices {
+		a1AttestingIndices[j] = fmt.Sprintf("%d", ix)
+	}
+	a2AttestingIndices := make([]string, len(src.Attestation_2.AttestingIndices))
+	for j, ix := range src.Attestation_2.AttestingIndices {
+		a2AttestingIndices[j] = fmt.Sprintf("%d", ix)
+	}
+	return &AttesterSlashingElectra{
+		Attestation1: &IndexedAttestationElectra{
+			AttestingIndices: a1AttestingIndices,
+			Data: &AttestationData{
+				Slot:            fmt.Sprintf("%d", src.Attestation_1.Data.Slot),
+				CommitteeIndex:  fmt.Sprintf("%d", src.Attestation_1.Data.CommitteeIndex),
+				BeaconBlockRoot: hexutil.Encode(src.Attestation_1.Data.BeaconBlockRoot),
+				Source: &Checkpoint{
+					Epoch: fmt.Sprintf("%d", src.Attestation_1.Data.Source.Epoch),
+					Root:  hexutil.Encode(src.Attestation_1.Data.Source.Root),
+				},
+				Target: &Checkpoint{
+					Epoch: fmt.Sprintf("%d", src.Attestation_1.Data.Target.Epoch),
+					Root:  hexutil.Encode(src.Attestation_1.Data.Target.Root),
+				},
+			},
+			Signature: hexutil.Encode(src.Attestation_1.Signature),
+		},
+		Attestation2: &IndexedAttestationElectra{
+			AttestingIndices: a2AttestingIndices,
+			Data: &AttestationData{
+				Slot:            fmt.Sprintf("%d", src.Attestation_2.Data.Slot),
+				CommitteeIndex:  fmt.Sprintf("%d", src.Attestation_2.Data.CommitteeIndex),
+				BeaconBlockRoot: hexutil.Encode(src.Attestation_2.Data.BeaconBlockRoot),
+				Source: &Checkpoint{
+					Epoch: fmt.Sprintf("%d", src.Attestation_2.Data.Source.Epoch),
+					Root:  hexutil.Encode(src.Attestation_2.Data.Source.Root),
+				},
+				Target: &Checkpoint{
+					Epoch: fmt.Sprintf("%d", src.Attestation_2.Data.Target.Epoch),
+					Root:  hexutil.Encode(src.Attestation_2.Data.Target.Root),
+				},
+			},
+			Signature: hexutil.Encode(src.Attestation_2.Signature),
+		},
+	}
+}
+
 func AttsToConsensus(src []*Attestation) ([]*eth.Attestation, error) {
 	if src == nil {
 		return nil, errNilValue
@@ -957,6 +1317,33 @@ func AttsFromConsensus(src []*eth.Attestation) []*Attestation {
 	return atts
 }
 
+func AttsElectraToConsensus(src []*AttestationElectra) ([]*eth.AttestationElectra, error) {
+	if src == nil {
+		return nil, errNilValue
+	}
+	err := slice.VerifyMaxLength(src, 8)
+	if err != nil {
+		return nil, err
+	}
+
+	atts := make([]*eth.AttestationElectra, len(src))
+	for i, a := range src {
+		atts[i], err = a.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d]", i))
+		}
+	}
+	return atts, nil
+}
+
+func AttsElectraFromConsensus(src []*eth.AttestationElectra) []*AttestationElectra {
+	atts := make([]*AttestationElectra, len(src))
+	for i, a := range src {
+		atts[i] = AttElectraFromConsensus(a)
+	}
+	return atts
+}
+
 func DepositsToConsensus(src []*Deposit) ([]*eth.Deposit, error) {
 	if src == nil {
 		return nil, errNilValue
@@ -1087,3 +1474,37 @@ func DepositSnapshotFromConsensus(ds *eth.DepositSnapshot) *DepositSnapshot {
 		ExecutionBlockHeight: fmt.Sprintf("%d", ds.ExecutionDepth),
 	}
 }
+
+func PendingBalanceDepositsFromConsensus(ds []*eth.PendingBalanceDeposit) []*PendingBalanceDeposit {
+	deposits := make([]*PendingBalanceDeposit, len(ds))
+	for i, d := range ds {
+		deposits[i] = &PendingBalanceDeposit{
+			Index:  fmt.Sprintf("%d", d.Index),
+			Amount: fmt.Sprintf("%d", d.Amount),
+		}
+	}
+	return deposits
+}
+
+func PendingPartialWithdrawalsFromConsensus(ws []*eth.PendingPartialWithdrawal) []*PendingPartialWithdrawal {
+	withdrawals := make([]*PendingPartialWithdrawal, len(ws))
+	for i, w := range ws {
+		withdrawals[i] = &PendingPartialWithdrawal{
+			Index:             fmt.Sprintf("%d", w.Index),
+			Amount:            fmt.Sprintf("%d", w.Amount),
+			WithdrawableEpoch: fmt.Sprintf("%d", w.WithdrawableEpoch),
+		}
+	}
+	return withdrawals
+}
+
+func PendingConsolidationsFromConsensus(cs []*eth.PendingConsolidation) []*PendingConsolidation {
+	consolidations := make([]*PendingConsolidation, len(cs))
+	for i, c := range cs {
+		consolidations[i] = &PendingConsolidation{
+			SourceIndex: fmt.Sprintf("%d", c.SourceIndex),
+			TargetIndex: fmt.Sprintf("%d", c.TargetIndex),
+		}
+	}
+	return consolidations
+}

api/server/structs/conversions_state.go

@@ -593,3 +593,185 @@ func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDene
 		HistoricalSummaries:          hs,
 	}, nil
 }
+
+func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateElectra, error) {
+	srcBr := st.BlockRoots()
+	br := make([]string, len(srcBr))
+	for i, r := range srcBr {
+		br[i] = hexutil.Encode(r)
+	}
+	srcSr := st.StateRoots()
+	sr := make([]string, len(srcSr))
+	for i, r := range srcSr {
+		sr[i] = hexutil.Encode(r)
+	}
+	srcHr, err := st.HistoricalRoots()
+	if err != nil {
+		return nil, err
+	}
+	hr := make([]string, len(srcHr))
+	for i, r := range srcHr {
+		hr[i] = hexutil.Encode(r)
+	}
+	srcVotes := st.Eth1DataVotes()
+	votes := make([]*Eth1Data, len(srcVotes))
+	for i, e := range srcVotes {
+		votes[i] = Eth1DataFromConsensus(e)
+	}
+	srcVals := st.Validators()
+	vals := make([]*Validator, len(srcVals))
+	for i, v := range srcVals {
+		vals[i] = ValidatorFromConsensus(v)
+	}
+	srcBals := st.Balances()
+	bals := make([]string, len(srcBals))
+	for i, b := range srcBals {
+		bals[i] = fmt.Sprintf("%d", b)
+	}
+	srcRm := st.RandaoMixes()
+	rm := make([]string, len(srcRm))
+	for i, m := range srcRm {
+		rm[i] = hexutil.Encode(m)
+	}
+	srcSlashings := st.Slashings()
+	slashings := make([]string, len(srcSlashings))
+	for i, s := range srcSlashings {
+		slashings[i] = fmt.Sprintf("%d", s)
+	}
+	srcPrevPart, err := st.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	prevPart := make([]string, len(srcPrevPart))
+	for i, p := range srcPrevPart {
+		prevPart[i] = fmt.Sprintf("%d", p)
+	}
+	srcCurrPart, err := st.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currPart := make([]string, len(srcCurrPart))
+	for i, p := range srcCurrPart {
+		currPart[i] = fmt.Sprintf("%d", p)
+	}
+	srcIs, err := st.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	is := make([]string, len(srcIs))
+	for i, s := range srcIs {
+		is[i] = fmt.Sprintf("%d", s)
+	}
+	currSc, err := st.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSc, err := st.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	execData, err := st.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
+	if !ok {
+		return nil, errPayloadHeaderNotFound
+	}
+	payload, err := ExecutionPayloadHeaderElectraFromConsensus(srcPayload)
+	if err != nil {
+		return nil, err
+	}
+	srcHs, err := st.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	hs := make([]*HistoricalSummary, len(srcHs))
+	for i, s := range srcHs {
+		hs[i] = HistoricalSummaryFromConsensus(s)
+	}
+	nwi, err := st.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	nwvi, err := st.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	drsi, err := st.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, err
+	}
+	dbtc, err := st.DepositBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	ebtc, err := st.ExitBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	eee, err := st.EarliestExitEpoch()
+	if err != nil {
+		return nil, err
+	}
+	cbtc, err := st.ConsolidationBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	ece, err := st.EarliestConsolidationEpoch()
+	if err != nil {
+		return nil, err
+	}
+	pbd, err := st.PendingBalanceDeposits()
+	if err != nil {
+		return nil, err
+	}
+	ppw, err := st.PendingPartialWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	pc, err := st.PendingConsolidations()
+	if err != nil {
+		return nil, err
+	}
+
+	return &BeaconStateElectra{
+		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime()),
+		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
+		Slot:                          fmt.Sprintf("%d", st.Slot()),
+		Fork:                          ForkFromConsensus(st.Fork()),
+		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
+		BlockRoots:                    br,
+		StateRoots:                    sr,
+		HistoricalRoots:               hr,
+		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
+		Eth1DataVotes:                 votes,
+		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
+		Validators:                    vals,
+		Balances:                      bals,
+		RandaoMixes:                   rm,
+		Slashings:                     slashings,
+		PreviousEpochParticipation:    prevPart,
+		CurrentEpochParticipation:     currPart,
+		JustificationBits:             hexutil.Encode(st.JustificationBits()),
+		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
+		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
+		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
+		InactivityScores:              is,
+		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
+		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
+		LatestExecutionPayloadHeader:  payload,
+		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
+		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
+		HistoricalSummaries:           hs,
+		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
+		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
+		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
+		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
+		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
+		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
+		PendingBalanceDeposits:        PendingBalanceDepositsFromConsensus(pbd),
+		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
+		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
+	}, nil
+}

api/server/structs/endpoints_beacon.go

@@ -225,3 +225,19 @@ type IndividualVote struct {
 	InclusionDistance                string `json:"inclusion_distance"`
 	InactivityScore                  string `json:"inactivity_score"`
 }
+
+type ChainHead struct {
+	HeadSlot                   string `json:"head_slot"`
+	HeadEpoch                  string `json:"head_epoch"`
+	HeadBlockRoot              string `json:"head_block_root"`
+	FinalizedSlot              string `json:"finalized_slot"`
+	FinalizedEpoch             string `json:"finalized_epoch"`
+	FinalizedBlockRoot         string `json:"finalized_block_root"`
+	JustifiedSlot              string `json:"justified_slot"`
+	JustifiedEpoch             string `json:"justified_epoch"`
+	JustifiedBlockRoot         string `json:"justified_block_root"`
+	PreviousJustifiedSlot      string `json:"previous_justified_slot"`
+	PreviousJustifiedEpoch     string `json:"previous_justified_epoch"`
+	PreviousJustifiedBlockRoot string `json:"previous_justified_block_root"`
+	OptimisticStatus           bool   `json:"optimistic_status"`
+}

api/server/structs/endpoints_lightclient.go

@@ -1,12 +1,16 @@
 package structs
 
+type LightClientHeader struct {
+	Beacon *BeaconBlockHeader `json:"beacon"`
+}
+
 type LightClientBootstrapResponse struct {
 	Version string                `json:"version"`
 	Data    *LightClientBootstrap `json:"data"`
 }
 
 type LightClientBootstrap struct {
-	Header                     *BeaconBlockHeader `json:"header"`
+	Header                     *LightClientHeader `json:"header"`
 	CurrentSyncCommittee       *SyncCommittee     `json:"current_sync_committee"`
 	CurrentSyncCommitteeBranch []string           `json:"current_sync_committee_branch"`
 }

api/server/structs/endpoints_validator.go

@@ -118,3 +118,34 @@ type GetValidatorPerformanceResponse struct {
 	MissingValidators             [][]byte `json:"missing_validators,omitempty"`
 	InactivityScores              []uint64 `json:"inactivity_scores,omitempty"`
 }
+
+type GetValidatorParticipationResponse struct {
+	Epoch         string                  `json:"epoch"`
+	Finalized     bool                    `json:"finalized"`
+	Participation *ValidatorParticipation `json:"participation"`
+}
+
+type ValidatorParticipation struct {
+	GlobalParticipationRate          string `json:"global_participation_rate" deprecated:"true"`
+	VotedEther                       string `json:"voted_ether" deprecated:"true"`
+	EligibleEther                    string `json:"eligible_ether" deprecated:"true"`
+	CurrentEpochActiveGwei           string `json:"current_epoch_active_gwei"`
+	CurrentEpochAttestingGwei        string `json:"current_epoch_attesting_gwei"`
+	CurrentEpochTargetAttestingGwei  string `json:"current_epoch_target_attesting_gwei"`
+	PreviousEpochActiveGwei          string `json:"previous_epoch_active_gwei"`
+	PreviousEpochAttestingGwei       string `json:"previous_epoch_attesting_gwei"`
+	PreviousEpochTargetAttestingGwei string `json:"previous_epoch_target_attesting_gwei"`
+	PreviousEpochHeadAttestingGwei   string `json:"previous_epoch_head_attesting_gwei"`
+}
+
+type ActiveSetChanges struct {
+	Epoch               string   `json:"epoch"`
+	ActivatedPublicKeys []string `json:"activated_public_keys"`
+	ActivatedIndices    []string `json:"activated_indices"`
+	ExitedPublicKeys    []string `json:"exited_public_keys"`
+	ExitedIndices       []string `json:"exited_indices"`
+	SlashedPublicKeys   []string `json:"slashed_public_keys"`
+	SlashedIndices      []string `json:"slashed_indices"`
+	EjectedPublicKeys   []string `json:"ejected_public_keys"`
+	EjectedIndices      []string `json:"ejected_indices"`
+}

api/server/structs/other.go

@@ -29,6 +29,13 @@ type Attestation struct {
 	Signature       string           `json:"signature"`
 }
 
+type AttestationElectra struct {
+	AggregationBits string           `json:"aggregation_bits"`
+	Data            *AttestationData `json:"data"`
+	Signature       string           `json:"signature"`
+	CommitteeBits   string           `json:"committee_bits"`
+}
+
 type AttestationData struct {
 	Slot            string      `json:"slot"`
 	CommitteeIndex  string      `json:"index"`
@@ -78,6 +85,17 @@ type AggregateAttestationAndProof struct {
 	SelectionProof  string       `json:"selection_proof"`
 }
 
+type SignedAggregateAttestationAndProofElectra struct {
+	Message   *AggregateAttestationAndProofElectra `json:"message"`
+	Signature string                               `json:"signature"`
+}
+
+type AggregateAttestationAndProofElectra struct {
+	AggregatorIndex string              `json:"aggregator_index"`
+	Aggregate       *AttestationElectra `json:"aggregate"`
+	SelectionProof  string              `json:"selection_proof"`
+}
+
 type SyncCommitteeSubscription struct {
 	ValidatorIndex       string   `json:"validator_index"`
 	SyncCommitteeIndices []string `json:"sync_committee_indices"`
@@ -178,6 +196,11 @@ type AttesterSlashing struct {
 	Attestation2 *IndexedAttestation `json:"attestation_2"`
 }
 
+type AttesterSlashingElectra struct {
+	Attestation1 *IndexedAttestationElectra `json:"attestation_1"`
+	Attestation2 *IndexedAttestationElectra `json:"attestation_2"`
+}
+
 type Deposit struct {
 	Proof []string     `json:"proof"`
 	Data  *DepositData `json:"data"`
@@ -196,6 +219,12 @@ type IndexedAttestation struct {
 	Signature        string           `json:"signature"`
 }
 
+type IndexedAttestationElectra struct {
+	AttestingIndices []string         `json:"attesting_indices"`
+	Data             *AttestationData `json:"data"`
+	Signature        string           `json:"signature"`
+}
+
 type SyncAggregate struct {
 	SyncCommitteeBits      string `json:"sync_committee_bits"`
 	SyncCommitteeSignature string `json:"sync_committee_signature"`
@@ -207,3 +236,39 @@ type Withdrawal struct {
 	ExecutionAddress string `json:"address"`
 	Amount           string `json:"amount"`
 }
+
+type DepositRequest struct {
+	Pubkey                string `json:"pubkey"`
+	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Amount                string `json:"amount"`
+	Signature             string `json:"signature"`
+	Index                 string `json:"index"`
+}
+
+type WithdrawalRequest struct {
+	SourceAddress   string `json:"source_address"`
+	ValidatorPubkey string `json:"validator_pubkey"`
+	Amount          string `json:"amount"`
+}
+
+type ConsolidationRequest struct {
+	SourceAddress string `json:"source_address"`
+	SourcePubkey  string `json:"source_pubkey"`
+	TargetPubkey  string `json:"target_pubkey"`
+}
+
+type PendingBalanceDeposit struct {
+	Index  string `json:"index"`
+	Amount string `json:"amount"`
+}
+
+type PendingPartialWithdrawal struct {
+	Index             string `json:"index"`
+	Amount            string `json:"amount"`
+	WithdrawableEpoch string `json:"withdrawable_epoch"`
+}
+
+type PendingConsolidation struct {
+	SourceIndex string `json:"source_index"`
+	TargetIndex string `json:"target_index"`
+}

api/server/structs/state.go

@@ -140,3 +140,43 @@ type BeaconStateDeneb struct {
 	NextWithdrawalValidatorIndex string                       `json:"next_withdrawal_validator_index"`
 	HistoricalSummaries          []*HistoricalSummary         `json:"historical_summaries"`
 }
+
+type BeaconStateElectra struct {
+	GenesisTime                   string                         `json:"genesis_time"`
+	GenesisValidatorsRoot         string                         `json:"genesis_validators_root"`
+	Slot                          string                         `json:"slot"`
+	Fork                          *Fork                          `json:"fork"`
+	LatestBlockHeader             *BeaconBlockHeader             `json:"latest_block_header"`
+	BlockRoots                    []string                       `json:"block_roots"`
+	StateRoots                    []string                       `json:"state_roots"`
+	HistoricalRoots               []string                       `json:"historical_roots"`
+	Eth1Data                      *Eth1Data                      `json:"eth1_data"`
+	Eth1DataVotes                 []*Eth1Data                    `json:"eth1_data_votes"`
+	Eth1DepositIndex              string                         `json:"eth1_deposit_index"`
+	Validators                    []*Validator                   `json:"validators"`
+	Balances                      []string                       `json:"balances"`
+	RandaoMixes                   []string                       `json:"randao_mixes"`
+	Slashings                     []string                       `json:"slashings"`
+	PreviousEpochParticipation    []string                       `json:"previous_epoch_participation"`
+	CurrentEpochParticipation     []string                       `json:"current_epoch_participation"`
+	JustificationBits             string                         `json:"justification_bits"`
+	PreviousJustifiedCheckpoint   *Checkpoint                    `json:"previous_justified_checkpoint"`
+	CurrentJustifiedCheckpoint    *Checkpoint                    `json:"current_justified_checkpoint"`
+	FinalizedCheckpoint           *Checkpoint                    `json:"finalized_checkpoint"`
+	InactivityScores              []string                       `json:"inactivity_scores"`
+	CurrentSyncCommittee          *SyncCommittee                 `json:"current_sync_committee"`
+	NextSyncCommittee             *SyncCommittee                 `json:"next_sync_committee"`
+	LatestExecutionPayloadHeader  *ExecutionPayloadHeaderElectra `json:"latest_execution_payload_header"`
+	NextWithdrawalIndex           string                         `json:"next_withdrawal_index"`
+	NextWithdrawalValidatorIndex  string                         `json:"next_withdrawal_validator_index"`
+	HistoricalSummaries           []*HistoricalSummary           `json:"historical_summaries"`
+	DepositRequestsStartIndex     string                         `json:"deposit_requests_start_index"`
+	DepositBalanceToConsume       string                         `json:"deposit_balance_to_consume"`
+	ExitBalanceToConsume          string                         `json:"exit_balance_to_consume"`
+	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"`
+	PendingPartialWithdrawals     []*PendingPartialWithdrawal    `json:"pending_partial_withdrawals"`
+	PendingConsolidations         []*PendingConsolidation        `json:"pending_consolidations"`
+}

beacon-chain/blockchain/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
         "head.go",
         "head_sync_committee_info.go",
         "init_sync_process_block.go",
-        "lightclient.go",
         "log.go",
         "merge_ascii_art.go",
         "metrics.go",
@@ -48,6 +47,7 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -84,7 +84,6 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
-        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -117,7 +116,6 @@ go_test(
         "head_test.go",
         "init_sync_process_block_test.go",
         "init_test.go",
-        "lightclient_test.go",
         "log_test.go",
         "metrics_test.go",
         "mock_test.go",
@@ -174,7 +172,6 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -22,13 +22,6 @@ func (s *Service) GetProposerHead() [32]byte {
 	return s.cfg.ForkChoiceStore.GetProposerHead()
 }
 
-// ShouldOverrideFCU returns the corresponding value from forkchoice
-func (s *Service) ShouldOverrideFCU() bool {
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.ShouldOverrideFCU()
-}
-
 // SetForkChoiceGenesisTime sets the genesis time in Forkchoice
 func (s *Service) SetForkChoiceGenesisTime(timestamp uint64) {
 	s.cfg.ForkChoiceStore.Lock()
@@ -99,3 +92,10 @@ func (s *Service) FinalizedBlockHash() [32]byte {
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	return s.cfg.ForkChoiceStore.FinalizedPayloadBlockHash()
 }
+
+// ParentRoot wraps a call to the corresponding method in forkchoice
+func (s *Service) ParentRoot(root [32]byte) ([32]byte, error) {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.ParentRoot(root)
+}

beacon-chain/blockchain/lightclient_test.go

@@ -1,160 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	v1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-)
-
-type testlc struct {
-	t              *testing.T
-	ctx            context.Context
-	state          state.BeaconState
-	block          interfaces.ReadOnlySignedBeaconBlock
-	attestedState  state.BeaconState
-	attestedHeader *ethpb.BeaconBlockHeader
-}
-
-func newTestLc(t *testing.T) *testlc {
-	return &testlc{t: t}
-}
-
-func (l *testlc) setupTest() *testlc {
-	ctx := context.Background()
-
-	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
-
-	attestedState, err := util.NewBeaconStateCapella()
-	require.NoError(l.t, err)
-	err = attestedState.SetSlot(slot)
-	require.NoError(l.t, err)
-
-	parent := util.NewBeaconBlockCapella()
-	parent.Block.Slot = slot
-
-	signedParent, err := blocks.NewSignedBeaconBlock(parent)
-	require.NoError(l.t, err)
-
-	parentHeader, err := signedParent.Header()
-	require.NoError(l.t, err)
-	attestedHeader := parentHeader.Header
-
-	err = attestedState.SetLatestBlockHeader(attestedHeader)
-	require.NoError(l.t, err)
-	attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
-	require.NoError(l.t, err)
-
-	// get a new signed block so the root is updated with the new state root
-	parent.Block.StateRoot = attestedStateRoot[:]
-	signedParent, err = blocks.NewSignedBeaconBlock(parent)
-	require.NoError(l.t, err)
-
-	state, err := util.NewBeaconStateCapella()
-	require.NoError(l.t, err)
-	err = state.SetSlot(slot)
-	require.NoError(l.t, err)
-
-	parentRoot, err := signedParent.Block().HashTreeRoot()
-	require.NoError(l.t, err)
-
-	block := util.NewBeaconBlockCapella()
-	block.Block.Slot = slot
-	block.Block.ParentRoot = parentRoot[:]
-
-	for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
-		block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
-	}
-
-	signedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.t, err)
-
-	h, err := signedBlock.Header()
-	require.NoError(l.t, err)
-
-	err = state.SetLatestBlockHeader(h.Header)
-	require.NoError(l.t, err)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	require.NoError(l.t, err)
-
-	// get a new signed block so the root is updated with the new state root
-	block.Block.StateRoot = stateRoot[:]
-	signedBlock, err = blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.t, err)
-
-	l.state = state
-	l.attestedState = attestedState
-	l.attestedHeader = attestedHeader
-	l.block = signedBlock
-	l.ctx = ctx
-
-	return l
-}
-
-func (l *testlc) checkAttestedHeader(update *ethpbv2.LightClientUpdate) {
-	require.Equal(l.t, l.attestedHeader.Slot, update.AttestedHeader.Slot, "Attested header slot is not equal")
-	require.Equal(l.t, l.attestedHeader.ProposerIndex, update.AttestedHeader.ProposerIndex, "Attested header proposer index is not equal")
-	require.DeepSSZEqual(l.t, l.attestedHeader.ParentRoot, update.AttestedHeader.ParentRoot, "Attested header parent root is not equal")
-	require.DeepSSZEqual(l.t, l.attestedHeader.BodyRoot, update.AttestedHeader.BodyRoot, "Attested header body root is not equal")
-
-	attestedStateRoot, err := l.attestedState.HashTreeRoot(l.ctx)
-	require.NoError(l.t, err)
-	require.DeepSSZEqual(l.t, attestedStateRoot[:], update.AttestedHeader.StateRoot, "Attested header state root is not equal")
-}
-
-func (l *testlc) checkSyncAggregate(update *ethpbv2.LightClientUpdate) {
-	syncAggregate, err := l.block.Block().Body().SyncAggregate()
-	require.NoError(l.t, err)
-	require.DeepSSZEqual(l.t, syncAggregate.SyncCommitteeBits, update.SyncAggregate.SyncCommitteeBits, "SyncAggregate bits is not equal")
-	require.DeepSSZEqual(l.t, syncAggregate.SyncCommitteeSignature, update.SyncAggregate.SyncCommitteeSignature, "SyncAggregate signature is not equal")
-}
-
-func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T) {
-	l := newTestLc(t).setupTest()
-
-	update, err := NewLightClientOptimisticUpdateFromBeaconState(l.ctx, l.state, l.block, l.attestedState)
-	require.NoError(t, err)
-	require.NotNil(t, update, "update is nil")
-
-	require.Equal(t, l.block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-	l.checkSyncAggregate(update)
-	l.checkAttestedHeader(update)
-
-	require.Equal(t, (*v1.BeaconBlockHeader)(nil), update.FinalizedHeader, "Finalized header is not nil")
-	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
-}
-
-func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
-	l := newTestLc(t).setupTest()
-
-	update, err := NewLightClientFinalityUpdateFromBeaconState(l.ctx, l.state, l.block, l.attestedState, nil)
-	require.NoError(t, err)
-	require.NotNil(t, update, "update is nil")
-
-	require.Equal(t, l.block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-	l.checkSyncAggregate(update)
-	l.checkAttestedHeader(update)
-
-	zeroHash := params.BeaconConfig().ZeroHash[:]
-	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
-	require.Equal(t, primitives.Slot(0), update.FinalizedHeader.Slot, "Finalized header slot is not zero")
-	require.Equal(t, primitives.ValidatorIndex(0), update.FinalizedHeader.ProposerIndex, "Finalized header proposer index is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.ParentRoot, "Finalized header parent root is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.StateRoot, "Finalized header state root is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.BodyRoot, "Finalized header body root is not zero")
-	require.Equal(t, FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
-	for _, leaf := range update.FinalityBranch {
-		require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
-	}
-}

beacon-chain/blockchain/process_block.go

@@ -142,7 +142,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	b := blks[0].Block()
 
 	// Retrieve incoming block's pre state.
-	if err := s.verifyBlkPreState(ctx, b); err != nil {
+	if err := s.verifyBlkPreState(ctx, b.ParentRoot()); err != nil {
 		return err
 	}
 	preState, err := s.cfg.StateGen.StateByRootInitialSync(ctx, b.ParentRoot())

beacon-chain/blockchain/process_block_helpers.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"
 
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
@@ -14,6 +16,7 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -175,7 +178,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		}
 	}
 
-	update, err := NewLightClientFinalityUpdateFromBeaconState(
+	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -190,7 +193,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	// Return the result
 	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    CreateLightClientFinalityUpdate(update),
+		Data:    lightclient.CreateLightClientFinalityUpdate(update),
 	}
 
 	// Send event
@@ -210,7 +213,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 		return 0, errors.Wrap(err, "could not get attested state")
 	}
 
-	update, err := NewLightClientOptimisticUpdateFromBeaconState(
+	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -224,7 +227,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	// Return the result
 	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    CreateLightClientOptimisticUpdate(update),
+		Data:    lightclient.CreateLightClientOptimisticUpdate(update),
 	}
 
 	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
@@ -285,7 +288,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 	defer span.End()
 
 	// Verify incoming block has a valid pre state.
-	if err := s.verifyBlkPreState(ctx, b); err != nil {
+	if err := s.verifyBlkPreState(ctx, b.ParentRoot()); err != nil {
 		return nil, err
 	}
 
@@ -311,11 +314,10 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 }
 
 // verifyBlkPreState validates input block has a valid pre-state.
-func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.ReadOnlyBeaconBlock) error {
+func (s *Service) verifyBlkPreState(ctx context.Context, parentRoot [field_params.RootLength]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()
 
-	parentRoot := b.ParentRoot()
 	// Loosen the check to HasBlock because state summary gets saved in batches
 	// during initial syncing. There's no risk given a state summary object is just a
 	// subset of the block object.

beacon-chain/blockchain/process_block_test.go

@@ -117,7 +117,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: root[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, root, st))
-	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block()))
+	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block().ParentRoot()))
 }
 
 func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
@@ -2044,7 +2044,11 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
-		b, err := util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 1)
+		defaultConfig := util.DefaultBlockGenConfig()
+		defaultConfig.NumWithdrawalRequests = 1
+		defaultConfig.NumDepositRequests = 2
+		defaultConfig.NumConsolidationRequests = 1
+		b, err := util.GenerateFullBlockElectra(st, keys, defaultConfig, 1)
 		require.NoError(t, err)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
@@ -2059,7 +2063,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
-		b, err = util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 2)
+		b, err = util.GenerateFullBlockElectra(st, keys, defaultConfig, 2)
 		require.NoError(t, err)
 		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
@@ -2067,7 +2071,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		// prepare another block that is not inserted
 		st3, err := transition.ExecuteStateTransition(ctx, st, wsb)
 		require.NoError(t, err)
-		b3, err := util.GenerateFullBlockElectra(st3, keys, util.DefaultBlockGenConfig(), 3)
+		b3, err := util.GenerateFullBlockElectra(st3, keys, defaultConfig, 3)
 		require.NoError(t, err)
 		wsb3, err := consensusblocks.NewSignedBeaconBlock(b3)
 		require.NoError(t, err)

beacon-chain/blockchain/receive_attestation.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "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"
 	"go.opencensus.io/trace"
@@ -190,13 +191,26 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		}
 
 		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
-			log.WithFields(logrus.Fields{
-				"slot":             a.GetData().Slot,
-				"committeeIndex":   a.GetData().CommitteeIndex,
-				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
-				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
-				"aggregationCount": a.GetAggregationBits().Count(),
-			}).WithError(err).Warn("Could not process attestation for fork choice")
+			var fields logrus.Fields
+			if a.Version() >= version.Electra {
+				fields = logrus.Fields{
+					"slot":             a.GetData().Slot,
+					"committeeCount":   a.CommitteeBitsVal().Count(),
+					"committeeIndices": a.CommitteeBitsVal().BitIndices(),
+					"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
+					"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
+					"aggregatedCount":  a.GetAggregationBits().Count(),
+				}
+			} else {
+				fields = logrus.Fields{
+					"slot":            a.GetData().Slot,
+					"committeeIndex":  a.GetData().CommitteeIndex,
+					"beaconBlockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
+					"targetRoot":      fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
+					"aggregatedCount": a.GetAggregationBits().Count(),
+				}
+			}
+			log.WithFields(fields).WithError(err).Warn("Could not process attestation for fork choice")
 		}
 	}
 }

beacon-chain/blockchain/receive_block.go

@@ -77,59 +77,20 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
-	rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
-	if err != nil {
-		return err
-	}
-
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
 	if err != nil {
 		return errors.Wrap(err, "could not get block's prestate")
 	}
-	// Save current justified and finalized epochs for future use.
-	currStoreJustifiedEpoch := s.CurrentJustifiedCheckpt().Epoch
-	currStoreFinalizedEpoch := s.FinalizedCheckpt().Epoch
-	currentEpoch := coreTime.CurrentEpoch(preState)
 
-	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	currentCheckpoints := s.saveCurrentCheckpoints(preState)
+	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, blockCopy, blockRoot)
 	if err != nil {
 		return err
 	}
-	eg, _ := errgroup.WithContext(ctx)
-	var postState state.BeaconState
-	eg.Go(func() error {
-		var err error
-		postState, err = s.validateStateTransition(ctx, preState, blockCopy)
-		if err != nil {
-			return errors.Wrap(err, "failed to validate consensus state transition function")
-		}
-		return nil
-	})
-	var isValidPayload bool
-	eg.Go(func() error {
-		var err error
-		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, blockCopy, blockRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not notify the engine of the new payload")
-		}
-		return nil
-	})
-	if err := eg.Wait(); err != nil {
+	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
+	if err != nil {
 		return err
 	}
-	daStartTime := time.Now()
-	if avs != nil {
-		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
-			return errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
-		}
-	} else {
-		if err := s.isDataAvailable(ctx, blockRoot, blockCopy); err != nil {
-			return errors.Wrap(err, "could not validate blob data availability")
-		}
-	}
-	daWaitedTime := time.Since(daStartTime)
-	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
-
 	// Defragment the state before continuing block processing.
 	s.defragmentState(postState)
 
@@ -151,29 +112,9 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		tracing.AnnotateError(span, err)
 		return err
 	}
-	if coreTime.CurrentEpoch(postState) > currentEpoch && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
-		headSt, err := s.HeadState(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not get head state")
-		}
-		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
-			log.WithError(err).Error("could not report epoch metrics")
-		}
+	if err := s.updateCheckpoints(ctx, currentCheckpoints, preState, postState, blockRoot); err != nil {
+		return err
 	}
-	if err := s.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch); err != nil {
-		return errors.Wrap(err, "could not update justified checkpoint")
-	}
-
-	newFinalized, err := s.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
-	if err != nil {
-		return errors.Wrap(err, "could not update finalized checkpoint")
-	}
-	// Send finalized events and finalized deposits in the background
-	if newFinalized {
-		// hook to process all post state finalization tasks
-		s.executePostFinalizationTasks(ctx, postState)
-	}
-
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
 	if features.Get().EnableSlasher {
 		go s.sendBlockAttestationsToSlasher(blockCopy, preState)
@@ -193,31 +134,140 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err := s.handleCaches(); err != nil {
 		return err
 	}
+	s.reportPostBlockProcessing(blockCopy, blockRoot, receivedTime, daWaitedTime)
+	return nil
+}
 
+type ffgCheckpoints struct {
+	j, f, c primitives.Epoch
+}
+
+func (s *Service) saveCurrentCheckpoints(state state.BeaconState) (cp ffgCheckpoints) {
+	// Save current justified and finalized epochs for future use.
+	cp.j = s.CurrentJustifiedCheckpt().Epoch
+	cp.f = s.FinalizedCheckpt().Epoch
+	cp.c = coreTime.CurrentEpoch(state)
+	return
+}
+
+func (s *Service) updateCheckpoints(
+	ctx context.Context,
+	cp ffgCheckpoints,
+	preState, postState state.BeaconState,
+	blockRoot [32]byte,
+) error {
+	if coreTime.CurrentEpoch(postState) > cp.c && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
+		headSt, err := s.HeadState(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not get head state")
+		}
+		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
+			log.WithError(err).Error("could not report epoch metrics")
+		}
+	}
+	if err := s.updateJustificationOnBlock(ctx, preState, postState, cp.j); err != nil {
+		return errors.Wrap(err, "could not update justified checkpoint")
+	}
+
+	newFinalized, err := s.updateFinalizationOnBlock(ctx, preState, postState, cp.f)
+	if err != nil {
+		return errors.Wrap(err, "could not update finalized checkpoint")
+	}
+	// Send finalized events and finalized deposits in the background
+	if newFinalized {
+		// hook to process all post state finalization tasks
+		s.executePostFinalizationTasks(ctx, postState)
+	}
+	return nil
+}
+
+func (s *Service) validateExecutionAndConsensus(
+	ctx context.Context,
+	preState state.BeaconState,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
+) (state.BeaconState, bool, error) {
+	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	if err != nil {
+		return nil, false, err
+	}
+	eg, _ := errgroup.WithContext(ctx)
+	var postState state.BeaconState
+	eg.Go(func() error {
+		var err error
+		postState, err = s.validateStateTransition(ctx, preState, block)
+		if err != nil {
+			return errors.Wrap(err, "failed to validate consensus state transition function")
+		}
+		return nil
+	})
+	var isValidPayload bool
+	eg.Go(func() error {
+		var err error
+		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block, blockRoot)
+		if err != nil {
+			return errors.Wrap(err, "could not notify the engine of the new payload")
+		}
+		return nil
+	})
+	if err := eg.Wait(); err != nil {
+		return nil, false, err
+	}
+	return postState, isValidPayload, nil
+}
+
+func (s *Service) handleDA(
+	ctx context.Context,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
+	avs das.AvailabilityStore,
+) (time.Duration, error) {
+	daStartTime := time.Now()
+	if avs != nil {
+		rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
+		if err != nil {
+			return 0, err
+		}
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
+			return 0, errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
+		}
+	} else {
+		if err := s.isDataAvailable(ctx, blockRoot, block); err != nil {
+			return 0, errors.Wrap(err, "could not validate blob data availability")
+		}
+	}
+	daWaitedTime := time.Since(daStartTime)
+	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
+	return daWaitedTime, nil
+}
+
+func (s *Service) reportPostBlockProcessing(
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
+	receivedTime time.Time,
+	daWaitedTime time.Duration,
+) {
 	// Reports on block and fork choice metrics.
 	cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	finalized := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
+	reportSlotMetrics(block.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 
 	// Log block sync status.
 	cp = s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	justified := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix()), daWaitedTime); err != nil {
+	if err := logBlockSyncStatus(block.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix()), daWaitedTime); err != nil {
 		log.WithError(err).Error("Unable to log block sync status")
 	}
 	// Log payload data
-	if err := logPayload(blockCopy.Block()); err != nil {
+	if err := logPayload(block.Block()); err != nil {
 		log.WithError(err).Error("Unable to log debug block payload data")
 	}
 	// Log state transition data.
-	if err := logStateTransitionData(blockCopy.Block()); err != nil {
+	if err := logStateTransitionData(block.Block()); err != nil {
 		log.WithError(err).Error("Unable to log state transition data")
 	}
-
 	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
 	chainServiceProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
-
-	return nil
 }
 
 func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {

beacon-chain/core/blocks/attestation.go

@@ -110,25 +110,7 @@ func VerifyAttestationNoVerifySignature(
 
 	var indexedAtt ethpb.IndexedAtt
 
-	if att.Version() < version.Electra {
-		if uint64(att.GetData().CommitteeIndex) >= c {
-			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
-		}
-
-		if err = helpers.VerifyAttestationBitfieldLengths(ctx, beaconState, att); err != nil {
-			return errors.Wrap(err, "could not verify attestation bitfields")
-		}
-
-		// Verify attesting indices are correct.
-		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
-		if err != nil {
-			return err
-		}
-		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
-		if err != nil {
-			return err
-		}
-	} else {
+	if att.Version() >= version.Electra {
 		if att.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
@@ -154,6 +136,29 @@ func VerifyAttestationNoVerifySignature(
 		if err != nil {
 			return err
 		}
+	} else {
+		if uint64(att.GetData().CommitteeIndex) >= c {
+			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
+		}
+
+		// Verify attesting indices are correct.
+		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
+		if err != nil {
+			return err
+		}
+
+		if committee == nil {
+			return errors.New("no committee exist for this attestation")
+		}
+
+		if err := helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
+			return errors.Wrap(err, "failed to verify aggregation bitfield")
+		}
+
+		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
+		if err != nil {
+			return err
+		}
 	}
 
 	return attestation.IsValidAttestationIndices(ctx, indexedAtt)

beacon-chain/core/blocks/exports_test.go

@@ -1,3 +1,5 @@
 package blocks
 
 var ProcessBLSToExecutionChange = processBLSToExecutionChange
+
+var VerifyBlobCommitmentCount = verifyBlobCommitmentCount

beacon-chain/core/blocks/payload.go

@@ -2,11 +2,13 @@ package blocks
 
 import (
 	"bytes"
+	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -200,13 +202,13 @@ func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) err
 //	    block_hash=payload.block_hash,
 //	    transactions_root=hash_tree_root(payload.transactions),
 //	)
-func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (state.BeaconState, error) {
-	var err error
-	if st.Version() >= version.Capella {
-		st, err = ProcessWithdrawals(st, payload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process withdrawals")
-		}
+func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) (state.BeaconState, error) {
+	payload, err := body.Execution()
+	if err != nil {
+		return nil, err
+	}
+	if err := verifyBlobCommitmentCount(body); err != nil {
+		return nil, err
 	}
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
 		return nil, err
@@ -220,70 +222,20 @@ func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (sta
 	return st, nil
 }
 
-// ValidatePayloadHeaderWhenMergeCompletes validates the payload header when the merge completes.
-func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header interfaces.ExecutionData) error {
-	// Skip validation if the state is not merge compatible.
-	complete, err := IsMergeTransitionComplete(st)
-	if err != nil {
-		return err
-	}
-	if !complete {
+func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
+	if body.Version() < version.Deneb {
 		return nil
 	}
-	// Validate current header's parent hash matches state header's block hash.
-	h, err := st.LatestExecutionPayloadHeader()
+	kzgs, err := body.BlobKzgCommitments()
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(header.ParentHash(), h.BlockHash()) {
-		return ErrInvalidPayloadBlockHash
+	if len(kzgs) > field_params.MaxBlobsPerBlock {
+		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
 	}
 	return nil
 }
 
-// ValidatePayloadHeader validates the payload header.
-func ValidatePayloadHeader(st state.BeaconState, header interfaces.ExecutionData) error {
-	// Validate header's random mix matches with state in current epoch
-	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
-	if err != nil {
-		return err
-	}
-	if !bytes.Equal(header.PrevRandao(), random) {
-		return ErrInvalidPayloadPrevRandao
-	}
-
-	// Validate header's timestamp matches with state in current slot.
-	t, err := slots.ToTime(st.GenesisTime(), st.Slot())
-	if err != nil {
-		return err
-	}
-	if header.Timestamp() != uint64(t.Unix()) {
-		return ErrInvalidPayloadTimeStamp
-	}
-	return nil
-}
-
-// ProcessPayloadHeader processes the payload header.
-func ProcessPayloadHeader(st state.BeaconState, header interfaces.ExecutionData) (state.BeaconState, error) {
-	var err error
-	if st.Version() >= version.Capella {
-		st, err = ProcessWithdrawals(st, header)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process withdrawals")
-		}
-	}
-	if err := ValidatePayloadHeaderWhenMergeCompletes(st, header); err != nil {
-		return nil, err
-	}
-	if err := ValidatePayloadHeader(st, header); err != nil {
-		return nil, err
-	}
-	if err := st.SetLatestExecutionPayloadHeader(header); err != nil {
-		return nil, err
-	}
-	return st, nil
-}
-
 // GetBlockPayloadHash returns the hash of the execution payload of the block
 func GetBlockPayloadHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
 	var payloadHash [32]byte

beacon-chain/core/blocks/payload_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
@@ -13,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -581,14 +583,18 @@ func Test_ProcessPayload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedPayload, err := consensusblocks.WrappedExecutionPayload(tt.payload)
+			body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{
+				ExecutionPayload: tt.payload,
+			})
 			require.NoError(t, err)
-			st, err := blocks.ProcessPayload(st, wrappedPayload)
+			st, err := blocks.ProcessPayload(st, body)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
-				want, err := consensusblocks.PayloadToHeader(wrappedPayload)
+				payload, err := body.Execution()
+				require.NoError(t, err)
+				want, err := consensusblocks.PayloadToHeader(payload)
 				require.Equal(t, tt.err, err)
 				h, err := st.LatestExecutionPayloadHeader()
 				require.NoError(t, err)
@@ -609,13 +615,15 @@ func Test_ProcessPayloadCapella(t *testing.T) {
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
 	payload.PrevRandao = random
-	wrapped, err := consensusblocks.WrappedExecutionPayloadCapella(payload)
+	body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BeaconBlockBodyCapella{
+		ExecutionPayload: payload,
+	})
 	require.NoError(t, err)
-	_, err = blocks.ProcessPayload(st, wrapped)
+	_, err = blocks.ProcessPayload(st, body)
 	require.NoError(t, err)
 }
 
-func Test_ProcessPayloadHeader(t *testing.T) {
+func Test_ProcessPayload_Blinded(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
@@ -663,7 +671,13 @@ func Test_ProcessPayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, err := blocks.ProcessPayloadHeader(st, tt.header)
+			p, ok := tt.header.Proto().(*enginev1.ExecutionPayloadHeader)
+			require.Equal(t, true, ok)
+			body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{
+				ExecutionPayloadHeader: p,
+			})
+			require.NoError(t, err)
+			st, err := blocks.ProcessPayload(st, body)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
@@ -728,7 +742,7 @@ func Test_ValidatePayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err = blocks.ValidatePayloadHeader(st, tt.header)
+			err = blocks.ValidatePayload(st, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -785,7 +799,7 @@ func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err = blocks.ValidatePayloadHeaderWhenMergeCompletes(tt.state, tt.header)
+			err = blocks.ValidatePayloadWhenMergeCompletes(tt.state, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -906,3 +920,15 @@ func emptyPayloadCapella() *enginev1.ExecutionPayloadCapella {
 		Withdrawals:   make([]*enginev1.Withdrawal, 0),
 	}
 }
+
+func TestVerifyBlobCommitmentCount(t *testing.T) {
+	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
+	rb, err := consensusblocks.NewBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Body()))
+
+	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, fieldparams.MaxBlobsPerBlock+1)}}
+	rb, err = consensusblocks.NewBeaconBlock(b)
+	require.NoError(t, err)
+	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", fieldparams.MaxBlobsPerBlock+1), blocks.VerifyBlobCommitmentCount(rb.Body()))
+}

beacon-chain/core/electra/consolidations.go

@@ -49,7 +49,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 		return errors.New("nil state")
 	}
 
-	currentEpoch := slots.ToEpoch(st.Slot())
+	nextEpoch := slots.ToEpoch(st.Slot()) + 1
 
 	var nextPendingConsolidation uint64
 	pendingConsolidations, err := st.PendingConsolidations()
@@ -66,7 +66,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			nextPendingConsolidation++
 			continue
 		}
-		if sourceValidator.WithdrawableEpoch > currentEpoch {
+		if sourceValidator.WithdrawableEpoch > nextEpoch {
 			break
 		}
 

beacon-chain/core/electra/deposits.go

@@ -248,7 +248,7 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 
 	// constants
 	ffe := params.BeaconConfig().FarFutureEpoch
-	curEpoch := slots.ToEpoch(st.Slot())
+	nextEpoch := slots.ToEpoch(st.Slot()) + 1
 
 	for _, balanceDeposit := range deposits {
 		v, err := st.ValidatorAtIndexReadOnly(balanceDeposit.Index)
@@ -259,7 +259,7 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 		// If the validator is currently exiting, postpone the deposit until after the withdrawable
 		// epoch.
 		if v.ExitEpoch() < ffe {
-			if curEpoch <= v.WithdrawableEpoch() {
+			if nextEpoch <= v.WithdrawableEpoch() {
 				depositsToPostpone = append(depositsToPostpone, balanceDeposit)
 			} else {
 				// The deposited balance will never become active. Therefore, we increase the balance but do

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -22,29 +22,31 @@ var (
 //
 // Spec definition:
 //
-//	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
-//	    # [Modified in Electra:EIP6110]
-//	    # Disable former deposit mechanism once all prior deposits are processed
-//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
-//	    if state.eth1_deposit_index < eth1_deposit_index_limit:
-//	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
-//	    else:
-//	        assert len(body.deposits) == 0
+//  def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
+//      # [Modified in Electra:EIP6110]
+//      # Disable former deposit mechanism once all prior deposits are processed
+//      eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
+//      if state.eth1_deposit_index < eth1_deposit_index_limit:
+//          assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
+//      else:
+//          assert len(body.deposits) == 0
 //
-//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
-//	        for operation in operations:
-//	            fn(state, operation)
+//      def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
+//          for operation in operations:
+//              fn(state, operation)
 //
-//	    for_ops(body.proposer_slashings, process_proposer_slashing)
-//	    for_ops(body.attester_slashings, process_attester_slashing)
-//	    for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
-//	    for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
-//	    for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
-//	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
-//	    # [New in Electra:EIP7002:EIP7251]
-//	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
-//	    for_ops(body.execution_payload.deposit_requests, process_deposit_requests)  # [New in Electra:EIP6110]
-//	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
+//      for_ops(body.proposer_slashings, process_proposer_slashing)
+//      for_ops(body.attester_slashings, process_attester_slashing)
+//      for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
+//      for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
+//      for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
+//      for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
+//      for_ops(body.execution_payload.deposit_requests, process_deposit_request)  # [New in Electra:EIP6110]
+//      # [New in Electra:EIP7002:EIP7251]
+//      for_ops(body.execution_payload.withdrawal_requests, process_withdrawal_request)
+//      # [New in Electra:EIP7251]
+//      for_ops(body.execution_payload.consolidation_requests, process_consolidation_request)
+
 func ProcessOperations(
 	ctx context.Context,
 	st state.BeaconState,
@@ -84,16 +86,14 @@ func ProcessOperations(
 	if !ok {
 		return nil, errors.New("could not cast execution data to electra execution data")
 	}
-	st, err = ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
-	}
-
 	st, err = ProcessDepositRequests(ctx, st, exe.DepositRequests())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit receipts")
 	}
-
+	st, err = ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
+	}
 	if err := ProcessConsolidationRequests(ctx, st, exe.ConsolidationRequests()); err != nil {
 		return nil, fmt.Errorf("could not process consolidation requests: %w", err)
 	}

beacon-chain/core/electra/transition_test.go

@@ -1,11 +1,15 @@
 package electra_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -47,3 +51,68 @@ func TestVerifyOperationLengths_Electra(t *testing.T) {
 		require.ErrorContains(t, "incorrect outstanding deposits in block body", err)
 	})
 }
+
+func TestProcessEpoch_CanProcessElectra(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	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)
+	for i := 0; i < len(deps); i += 1 {
+		deps[i] = &ethpb.PendingBalanceDeposit{
+			Amount: uint64(amountAvailForProcessing) / 10,
+			Index:  primitives.ValidatorIndex(i),
+		}
+	}
+	require.NoError(t, st.SetPendingBalanceDeposits(deps))
+	require.NoError(t, st.SetPendingConsolidations([]*ethpb.PendingConsolidation{
+		{
+			SourceIndex: 2,
+			TargetIndex: 3,
+		},
+		{
+			SourceIndex: 0,
+			TargetIndex: 1,
+		},
+	}))
+	err := electra.ProcessEpoch(context.Background(), st)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), st.Slashings()[2], "Unexpected slashed balance")
+
+	b := st.Balances()
+	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(b)))
+	require.Equal(t, uint64(44799839993), b[0])
+
+	s, err := st.InactivityScores()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(s)))
+
+	p, err := st.PreviousEpochParticipation()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
+
+	p, err = st.CurrentEpochParticipation()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
+
+	sc, err := st.CurrentSyncCommittee()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
+
+	sc, err = st.NextSyncCommittee()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
+
+	res, err := st.DepositBalanceToConsume()
+	require.NoError(t, err)
+	require.Equal(t, primitives.Gwei(100), res)
+
+	// Half of the balance deposits should have been processed.
+	remaining, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 10, len(remaining))
+
+	num, err := st.NumPendingConsolidations()
+	require.NoError(t, err)
+	require.Equal(t, uint64(2), num)
+}

beacon-chain/core/electra/upgrade.go

@@ -40,6 +40,7 @@ import (
 //	    excess_blob_gas=pre.latest_execution_payload_header.excess_blob_gas,
 //	    deposit_requests_root=Root(),  # [New in Electra:EIP6110]
 //	    withdrawal_requests_root=Root(),  # [New in Electra:EIP7002],
+//	    consolidation_requests_root=Root(),  # [New in Electra:EIP7251]
 //	)
 //
 //	exit_epochs = [v.exit_epoch for v in pre.validators if v.exit_epoch != FAR_FUTURE_EPOCH]

beacon-chain/core/epoch/BUILD.bazel

@@ -22,7 +22,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -53,7 +52,6 @@ go_test(
         "//testing/util:go_default_library",
         "@com_github_google_go_cmp//cmp:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/epoch/epoch_processing.go

@@ -20,32 +20,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
-// AttestingBalance returns the total balance from all the attesting indices.
-//
-// WARNING: This method allocates a new copy of the attesting validator indices set and is
-// considered to be very memory expensive. Avoid using this unless you really
-// need to get attesting balance from attestations.
-//
-// Spec pseudocode definition:
-//
-//	def get_attesting_balance(state: BeaconState, attestations: Sequence[PendingAttestation]) -> Gwei:
-//	  """
-//	  Return the combined effective balance of the set of unslashed validators participating in ``attestations``.
-//	  Note: ``get_total_balance`` returns ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero.
-//	  """
-//	  return get_total_balance(state, get_unslashed_attesting_indices(state, attestations))
-func AttestingBalance(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) (uint64, error) {
-	indices, err := UnslashedAttestingIndices(ctx, state, atts)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get attesting indices")
-	}
-	return helpers.TotalBalance(state, indices), nil
-}
-
 // ProcessRegistryUpdates rotates validators in and out of active pool.
 // the amount to rotate is determined churn limit.
 //
@@ -455,51 +432,3 @@ func ProcessFinalUpdates(state state.BeaconState) (state.BeaconState, error) {
 
 	return state, nil
 }
-
-// UnslashedAttestingIndices returns all the attesting indices from a list of attestations,
-// it sorts the indices and filters out the slashed ones.
-//
-// Spec pseudocode definition:
-//
-//	def get_unslashed_attesting_indices(state: BeaconState,
-//	                                  attestations: Sequence[PendingAttestation]) -> Set[ValidatorIndex]:
-//	  output = set()  # type: Set[ValidatorIndex]
-//	  for a in attestations:
-//	      output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
-//	  return set(filter(lambda index: not state.validators[index].slashed, output))
-func UnslashedAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) ([]primitives.ValidatorIndex, error) {
-	var setIndices []primitives.ValidatorIndex
-	seen := make(map[uint64]bool)
-
-	for _, att := range atts {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
-		if err != nil {
-			return nil, err
-		}
-		attestingIndices, err := attestation.AttestingIndices(att, committee)
-		if err != nil {
-			return nil, err
-		}
-		// Create a set for attesting indices
-		for _, index := range attestingIndices {
-			if !seen[index] {
-				setIndices = append(setIndices, primitives.ValidatorIndex(index))
-			}
-			seen[index] = true
-		}
-	}
-	// Sort the attesting set indices by increasing order.
-	sort.Slice(setIndices, func(i, j int) bool { return setIndices[i] < setIndices[j] })
-	// Remove the slashed validator indices.
-	for i := 0; i < len(setIndices); i++ {
-		v, err := state.ValidatorAtIndexReadOnly(setIndices[i])
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to look up validator")
-		}
-		if !v.IsNil() && v.Slashed() {
-			setIndices = append(setIndices[:i], setIndices[i+1:]...)
-		}
-	}
-
-	return setIndices, nil
-}

beacon-chain/core/epoch/epoch_processing_test.go

@@ -6,7 +6,6 @@ import (
 	"math"
 	"testing"
 
-	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
@@ -24,131 +23,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
-	// Generate 2 attestations.
-	atts := make([]*ethpb.PendingAttestation, 2)
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
-			},
-			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
-		}
-	}
-
-	// Generate validators and state for the 2 attestations.
-	validatorCount := 1000
-	validators := make([]*ethpb.Validator, validatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-	base := &ethpb.BeaconState{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-
-	indices, err := epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	for i := 0; i < len(indices)-1; i++ {
-		if indices[i] >= indices[i+1] {
-			t.Error("sorted indices not sorted or duplicated")
-		}
-	}
-
-	// Verify the slashed validator is filtered.
-	slashedValidator := indices[0]
-	validators = beaconState.Validators()
-	validators[slashedValidator].Slashed = true
-	require.NoError(t, beaconState.SetValidators(validators))
-	indices, err = epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	for i := 0; i < len(indices); i++ {
-		assert.NotEqual(t, slashedValidator, indices[i], "Slashed validator %d is not filtered", slashedValidator)
-	}
-}
-
-func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
-	// Generate 5 of the same attestations.
-	atts := make([]*ethpb.PendingAttestation, 5)
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Target: &ethpb.Checkpoint{Epoch: 0}},
-			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
-		}
-	}
-
-	// Generate validators and state for the 5 attestations.
-	validatorCount := 1000
-	validators := make([]*ethpb.Validator, validatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-	base := &ethpb.BeaconState{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-
-	indices, err := epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-
-	for i := 0; i < len(indices)-1; i++ {
-		if indices[i] >= indices[i+1] {
-			t.Error("sorted indices not sorted or duplicated")
-		}
-	}
-}
-
-func TestAttestingBalance_CorrectBalance(t *testing.T) {
-	helpers.ClearCache()
-	// Generate 2 attestations.
-	atts := make([]*ethpb.PendingAttestation, 2)
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				Slot:   primitives.Slot(i),
-			},
-			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01},
-		}
-	}
-
-	// Generate validators with balances and state for the 2 attestations.
-	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	balances := make([]uint64, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-		}
-		balances[i] = params.BeaconConfig().MaxEffectiveBalance
-	}
-	base := &ethpb.BeaconState{
-		Slot:        2,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-
-		Validators: validators,
-		Balances:   balances,
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-
-	balance, err := epoch.AttestingBalance(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
-	assert.Equal(t, wanted, balance)
-}
-
 func TestProcessSlashings_NotSlashed(t *testing.T) {
 	base := &ethpb.BeaconState{
 		Slot:       0,

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -47,7 +47,6 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -59,90 +58,6 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	assert.Equal(t, wanted, beaconState.Balances()[0], "Unexpected balance")
 }
 
-func TestAttestationDeltaPrecompute(t *testing.T) {
-	e := params.BeaconConfig().SlotsPerEpoch
-	validatorCount := uint64(2048)
-	base := buildState(e+2, validatorCount)
-	atts := make([]*ethpb.PendingAttestation, 3)
-	var emptyRoot [32]byte
-	for i := 0; i < len(atts); i++ {
-		atts[i] = &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{
-					Root: emptyRoot[:],
-				},
-				Source: &ethpb.Checkpoint{
-					Root: emptyRoot[:],
-				},
-				BeaconBlockRoot: emptyRoot[:],
-			},
-			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x01},
-			InclusionDelay:  1,
-		}
-	}
-	base.PreviousEpochAttestations = atts
-	beaconState, err := state_native.InitializeFromProtoPhase0(base)
-	require.NoError(t, err)
-	slashedAttestedIndices := []primitives.ValidatorIndex{1413}
-	for _, i := range slashedAttestedIndices {
-		vs := beaconState.Validators()
-		vs[i].Slashed = true
-		require.Equal(t, nil, beaconState.SetValidators(vs))
-	}
-
-	vp, bp, err := New(context.Background(), beaconState)
-	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
-	require.NoError(t, err)
-
-	// Add some variances to target and head balances.
-	// See: https://github.com/prysmaticlabs/prysm/issues/5593
-	bp.PrevEpochTargetAttested /= 2
-	bp.PrevEpochHeadAttested = bp.PrevEpochHeadAttested * 2 / 3
-	rewards, penalties, err := AttestationsDelta(beaconState, bp, vp)
-	require.NoError(t, err)
-	attestedBalance, err := epoch.AttestingBalance(context.Background(), beaconState, atts)
-	require.NoError(t, err)
-	totalBalance, err := helpers.TotalActiveBalance(beaconState)
-	require.NoError(t, err)
-
-	attestedIndices := []primitives.ValidatorIndex{55, 1339, 1746, 1811, 1569}
-	for _, i := range attestedIndices {
-		base, err := baseReward(beaconState, i)
-		require.NoError(t, err, "Could not get base reward")
-
-		// Base rewards for getting source right
-		wanted := attestedBalance*base/totalBalance +
-			bp.PrevEpochTargetAttested*base/totalBalance +
-			bp.PrevEpochHeadAttested*base/totalBalance
-		// Base rewards for proposer and attesters working together getting attestation
-		// on chain in the fatest manner
-		proposerReward := base / params.BeaconConfig().ProposerRewardQuotient
-		wanted += (base-proposerReward)*uint64(params.BeaconConfig().MinAttestationInclusionDelay) - 1
-		assert.Equal(t, wanted, rewards[i], "Unexpected reward balance for validator with index %d", i)
-		// Since all these validators attested, they shouldn't get penalized.
-		assert.Equal(t, uint64(0), penalties[i], "Unexpected penalty balance")
-	}
-
-	for _, i := range slashedAttestedIndices {
-		base, err := baseReward(beaconState, i)
-		assert.NoError(t, err, "Could not get base reward")
-		assert.Equal(t, uint64(0), rewards[i], "Unexpected slashed indices reward balance")
-		assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance")
-	}
-
-	nonAttestedIndices := []primitives.ValidatorIndex{434, 677, 872, 791}
-	for _, i := range nonAttestedIndices {
-		base, err := baseReward(beaconState, i)
-		assert.NoError(t, err, "Could not get base reward")
-		wanted := 3 * base
-		// Since all these validators did not attest, they shouldn't get rewarded.
-		assert.Equal(t, uint64(0), rewards[i], "Unexpected reward balance")
-		// Base penalties for not attesting.
-		assert.Equal(t, wanted, penalties[i], "Unexpected penalty balance")
-	}
-}
-
 func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 	e := params.BeaconConfig().SlotsPerEpoch
 	validatorCount := uint64(2048)

beacon-chain/core/helpers/beacon_committee.go

@@ -82,6 +82,47 @@ func AttestationCommittees(ctx context.Context, st state.ReadOnlyBeaconState, at
 	return committees, nil
 }
 
+// BeaconCommittees returns the list of all beacon committees for a given state at a given slot.
+func BeaconCommittees(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) ([][]primitives.ValidatorIndex, error) {
+	epoch := slots.ToEpoch(slot)
+	activeCount, err := ActiveValidatorCount(ctx, state, epoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute active validator count")
+	}
+	committeesPerSlot := SlotCommitteeCount(activeCount)
+	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get seed")
+	}
+
+	committees := make([][]primitives.ValidatorIndex, committeesPerSlot)
+	var activeIndices []primitives.ValidatorIndex
+
+	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
+		committee, err := committeeCache.Committee(ctx, slot, seed, idx)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not interface with committee cache")
+		}
+		if committee != nil {
+			committees[idx] = committee
+			continue
+		}
+
+		if len(activeIndices) == 0 {
+			activeIndices, err = ActiveValidatorIndices(ctx, state, epoch)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get active indices")
+			}
+		}
+		committee, err = BeaconCommittee(ctx, activeIndices, seed, slot, idx)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not compute beacon committee")
+		}
+		committees[idx] = committee
+	}
+	return committees, nil
+}
+
 // BeaconCommitteeFromState returns the crosslink committee of a given slot and committee index. This
 // is a spec implementation where state is used as an argument. In case of state retrieval
 // becomes expensive, consider using BeaconCommittee below.
@@ -253,36 +294,22 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	if err := verifyAssignmentEpoch(epoch, state); err != nil {
 		return nil, err
 	}
-
-	// Retrieve active validator count for the specified epoch.
-	activeValidatorCount, err := ActiveValidatorCount(ctx, state, epoch)
-	if err != nil {
-		return nil, err
-	}
-
-	// Determine the number of committees per slot based on the number of active validator indices.
-	numCommitteesPerSlot := SlotCommitteeCount(activeValidatorCount)
-
 	startSlot, err := slots.EpochStart(epoch)
 	if err != nil {
 		return nil, err
 	}
-
-	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
 	vals := make(map[primitives.ValidatorIndex]struct{})
 	for _, v := range validators {
 		vals[v] = struct{}{}
 	}
-
+	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
 	// Compute committee assignments for each slot in the epoch.
 	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
-		// Compute committees for the current slot.
-		for j := uint64(0); j < numCommitteesPerSlot; j++ {
-			committee, err := BeaconCommitteeFromState(ctx, state, slot, primitives.CommitteeIndex(j))
-			if err != nil {
-				return nil, err
-			}
-
+		committees, err := BeaconCommittees(ctx, state, slot)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not compute beacon committees")
+		}
+		for j, committee := range committees {
 			for _, vIndex := range committee {
 				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
 					continue
@@ -296,7 +323,6 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 			}
 		}
 	}
-
 	return assignments, nil
 }
 
@@ -311,24 +337,6 @@ func VerifyBitfieldLength(bf bitfield.Bitfield, committeeSize uint64) error {
 	return nil
 }
 
-// VerifyAttestationBitfieldLengths verifies that an attestations aggregation bitfields is
-// a valid length matching the size of the committee.
-func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att ethpb.Att) error {
-	committee, err := BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
-	if err != nil {
-		return errors.Wrap(err, "could not retrieve beacon committees")
-	}
-
-	if committee == nil {
-		return errors.New("no committee exist for this attestation")
-	}
-
-	if err := VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
-		return errors.Wrap(err, "failed to verify aggregation bitfield")
-	}
-	return nil
-}
-
 // ShuffledIndices uses input beacon state and returns the shuffled indices of the input epoch,
 // the shuffled indices then can be used to break up into committees.
 func ShuffledIndices(s state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]primitives.ValidatorIndex, error) {

beacon-chain/core/helpers/beacon_committee_test.go

@@ -18,6 +18,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -402,7 +403,12 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 		helpers.ClearCache()
 
 		require.NoError(t, state.SetSlot(tt.stateSlot))
-		err := helpers.VerifyAttestationBitfieldLengths(context.Background(), state, tt.attestation)
+		att := tt.attestation
+		// Verify attesting indices are correct.
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, att.GetData().Slot, att.GetData().CommitteeIndex)
+		require.NoError(t, err)
+		require.NotNil(t, committee)
+		err = helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee)))
 		if tt.verificationFailure {
 			assert.NotNil(t, err, "Verification succeeded when it was supposed to fail")
 		} else {
@@ -749,3 +755,27 @@ func TestAttestationCommittees(t *testing.T) {
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[1])))
 	})
 }
+
+func TestBeaconCommittees(t *testing.T) {
+	prevConfig := params.BeaconConfig().Copy()
+	defer params.OverrideBeaconConfig(prevConfig)
+	c := params.BeaconConfig().Copy()
+	c.MinGenesisActiveValidatorCount = 128
+	c.SlotsPerEpoch = 4
+	c.TargetCommitteeSize = 16
+	params.OverrideBeaconConfig(c)
+
+	state, _ := util.DeterministicGenesisState(t, 256)
+
+	activeCount, err := helpers.ActiveValidatorCount(context.Background(), state, 0)
+	require.NoError(t, err)
+	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
+	committees, err := helpers.BeaconCommittees(context.Background(), state, 0)
+	require.NoError(t, err)
+	require.Equal(t, committeesPerSlot, uint64(len(committees)))
+	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, 0, idx)
+		require.NoError(t, err)
+		require.DeepEqual(t, committees[idx], committee)
+	}
+}

beacon-chain/core/light-client/BUILD.bazel

@@ -0,0 +1,31 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["lightclient.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/state:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
+        "//time/slots:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["lightclient_test.go"],
+    deps = [
+        ":go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+    ],
+)

beacon-chain/core/light-client/lightclient.go

@@ -1,18 +1,20 @@
-package blockchain
+package light_client
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v5/proto/migration"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 )
 
 const (

beacon-chain/core/light-client/lightclient_test.go

@@ -0,0 +1,54 @@
+package light_client_test
+
+import (
+	"testing"
+
+	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+
+	v1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
+)
+
+func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTest()
+
+	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
+	require.NoError(t, err)
+	require.NotNil(t, update, "update is nil")
+
+	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
+
+	l.CheckSyncAggregate(update)
+	l.CheckAttestedHeader(update)
+
+	require.Equal(t, (*v1.BeaconBlockHeader)(nil), update.FinalizedHeader, "Finalized header is not nil")
+	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
+}
+
+func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTest()
+
+	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
+	require.NoError(t, err)
+	require.NotNil(t, update, "update is nil")
+
+	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
+
+	l.CheckSyncAggregate(update)
+	l.CheckAttestedHeader(update)
+
+	zeroHash := params.BeaconConfig().ZeroHash[:]
+	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
+	require.Equal(t, primitives.Slot(0), update.FinalizedHeader.Slot, "Finalized header slot is not zero")
+	require.Equal(t, primitives.ValidatorIndex(0), update.FinalizedHeader.ProposerIndex, "Finalized header proposer index is not zero")
+	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.ParentRoot, "Finalized header parent root is not zero")
+	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.StateRoot, "Finalized header state root is not zero")
+	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.BodyRoot, "Finalized header body root is not zero")
+	require.Equal(t, lightClient.FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
+	for _, leaf := range update.FinalityBranch {
+		require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
+	}
+}

beacon-chain/core/transition/transition.go

@@ -29,6 +29,8 @@ import (
 	"go.opencensus.io/trace"
 )
 
+type customProcessingFn func(context.Context, state.BeaconState) error
+
 // ExecuteStateTransition defines the procedure for a state transition function.
 //
 // Note: This method differs from the spec pseudocode as it uses a batch signature verification.
@@ -173,18 +175,7 @@ func ProcessSlotsIfPossible(ctx context.Context, state state.BeaconState, target
 	return state, nil
 }
 
-// ProcessSlots process through skip slots and apply epoch transition when it's needed
-//
-// Spec pseudocode definition:
-//
-//	def process_slots(state: BeaconState, slot: Slot) -> None:
-//	  assert state.slot < slot
-//	  while state.slot < slot:
-//	      process_slot(state)
-//	      # Process epoch on the start slot of the next epoch
-//	      if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
-//	          process_epoch(state)
-//	      state.slot = Slot(state.slot + 1)
+// ProcessSlots includes core slot processing as well as a cache
 func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.Slot) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlots")
 	defer span.End()
@@ -231,42 +222,63 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.
 	defer func() {
 		SkipSlotCache.MarkNotInProgress(key)
 	}()
+	state, err = ProcessSlotsCore(ctx, span, state, slot, cacheBestBeaconStateOnErrFn(highestSlot, key))
+	if err != nil {
+		return nil, err
+	}
+	if highestSlot < state.Slot() {
+		SkipSlotCache.Put(ctx, key, state)
+	}
 
-	for state.Slot() < slot {
+	return state, nil
+}
+
+func cacheBestBeaconStateOnErrFn(highestSlot primitives.Slot, key [32]byte) customProcessingFn {
+	return func(ctx context.Context, state state.BeaconState) error {
 		if ctx.Err() != nil {
-			tracing.AnnotateError(span, ctx.Err())
 			// Cache last best value.
 			if highestSlot < state.Slot() {
-				if SkipSlotCache.Put(ctx, key, state); err != nil {
-					log.WithError(err).Error("Failed to put skip slot cache value")
-				}
+				SkipSlotCache.Put(ctx, key, state)
+			}
+			return ctx.Err()
+		}
+		return nil
+	}
+}
+
+// ProcessSlotsCore process through skip slots and apply epoch transition when it's needed
+//
+// Spec pseudocode definition:
+//
+//	def process_slots(state: BeaconState, slot: Slot) -> None:
+//	  assert state.slot < slot
+//	  while state.slot < slot:
+//	      process_slot(state)
+//	      # Process epoch on the start slot of the next epoch
+//	      if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
+//	          process_epoch(state)
+//	      state.slot = Slot(state.slot + 1)
+func ProcessSlotsCore(ctx context.Context, span *trace.Span, state state.BeaconState, slot primitives.Slot, fn customProcessingFn) (state.BeaconState, error) {
+	var err error
+	for state.Slot() < slot {
+		if fn != nil {
+			if err = fn(ctx, state); err != nil {
+				tracing.AnnotateError(span, err)
+				return nil, err
 			}
-			return nil, ctx.Err()
 		}
 		state, err = ProcessSlot(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, errors.Wrap(err, "could not process slot")
 		}
-		if time.CanProcessEpoch(state) {
-			if state.Version() == version.Phase0 {
-				state, err = ProcessEpochPrecompute(ctx, state)
-				if err != nil {
-					tracing.AnnotateError(span, err)
-					return nil, errors.Wrap(err, "could not process epoch with optimizations")
-				}
-			} else if state.Version() <= version.Deneb {
-				if err = altair.ProcessEpoch(ctx, state); err != nil {
-					tracing.AnnotateError(span, err)
-					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
-				}
-			} else {
-				if err = electra.ProcessEpoch(ctx, state); err != nil {
-					tracing.AnnotateError(span, err)
-					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
-				}
-			}
+
+		state, err = ProcessEpoch(ctx, state)
+		if err != nil {
+			tracing.AnnotateError(span, err)
+			return nil, err
 		}
+
 		if err := state.SetSlot(state.Slot() + 1); err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, errors.Wrap(err, "failed to increment state slot")
@@ -278,25 +290,46 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.
 			return nil, errors.Wrap(err, "failed to upgrade state")
 		}
 	}
-
-	if highestSlot < state.Slot() {
-		SkipSlotCache.Put(ctx, key, state)
-	}
-
 	return state, nil
 }
 
+// ProcessEpoch is a wrapper on fork specific epoch processing
+func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+	var err error
+	if time.CanProcessEpoch(state) {
+		if state.Version() == version.Electra {
+			if err = electra.ProcessEpoch(ctx, state); err != nil {
+				return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
+			}
+		} else if state.Version() >= version.Altair {
+			if err = altair.ProcessEpoch(ctx, state); err != nil {
+				return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
+			}
+		} else {
+			state, err = ProcessEpochPrecompute(ctx, state)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not process epoch with optimizations")
+			}
+		}
+	}
+	return state, err
+}
+
 // UpgradeState upgrades the state to the next version if possible.
 func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.UpgradeState")
 	defer span.End()
+
 	var err error
+	upgraded := false
+
 	if time.CanUpgradeToAltair(state.Slot()) {
 		state, err = altair.UpgradeToAltair(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToBellatrix(state.Slot()) {
@@ -305,6 +338,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToCapella(state.Slot()) {
@@ -313,6 +347,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToDeneb(state.Slot()) {
@@ -321,6 +356,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
 
 	if time.CanUpgradeToElectra(state.Slot()) {
@@ -329,7 +365,13 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
+		upgraded = true
 	}
+
+	if upgraded {
+		log.Debugf("upgraded state to %s", version.String(state.Version()))
+	}
+
 	return state, nil
 }
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
@@ -328,20 +327,18 @@ func ProcessBlockForStateRoot(
 		if err != nil {
 			return nil, err
 		}
-		if blk.IsBlinded() {
-			state, err = b.ProcessPayloadHeader(state, executionData)
-		} else {
-			state, err = b.ProcessPayload(state, executionData)
+		if state.Version() >= version.Capella {
+			state, err = b.ProcessWithdrawals(state, executionData)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not process withdrawals")
+			}
 		}
+		state, err = b.ProcessPayload(state, blk.Body())
 		if err != nil {
 			return nil, errors.Wrap(err, "could not process execution data")
 		}
 	}
 
-	if err := VerifyBlobCommitmentCount(blk); err != nil {
-		return nil, err
-	}
-
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	state, err = b.ProcessRandaoNoVerify(state, randaoReveal[:])
 	if err != nil {
@@ -377,20 +374,6 @@ func ProcessBlockForStateRoot(
 	return state, nil
 }
 
-func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
-	if blk.Version() < version.Deneb {
-		return nil
-	}
-	kzgs, err := blk.Body().BlobKzgCommitments()
-	if err != nil {
-		return err
-	}
-	if len(kzgs) > field_params.MaxBlobsPerBlock {
-		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
-	}
-	return nil
-}
-
 // This calls altair block operations.
 func altairOperations(
 	ctx context.Context,

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -2,13 +2,11 @@ package transition_test
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -212,15 +210,3 @@ func TestProcessBlockDifferentVersion(t *testing.T) {
 	_, _, err = transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "state and block are different version. 0 != 1", err)
 }
-
-func TestVerifyBlobCommitmentCount(t *testing.T) {
-	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
-	rb, err := blocks.NewBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, transition.VerifyBlobCommitmentCount(rb))
-
-	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, field_params.MaxBlobsPerBlock+1)}}
-	rb, err = blocks.NewBeaconBlock(b)
-	require.NoError(t, err)
-	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", field_params.MaxBlobsPerBlock+1), transition.VerifyBlobCommitmentCount(rb))
-}

beacon-chain/db/iface/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//monitoring/backup:go_default_library",
         "//proto/dbval:go_default_library",
+        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
     ],

beacon-chain/db/iface/interface.go

@@ -7,6 +7,8 @@ import (
 	"context"
 	"io"
 
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filters"
 	slashertypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
@@ -56,6 +58,9 @@ type ReadOnlyDatabase interface {
 	// Fee recipients operations.
 	FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error)
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
+	// light client operations
+	LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]*ethpbv2.LightClientUpdateWithVersion, error)
+	LightClientUpdate(ctx context.Context, period uint64) (*ethpbv2.LightClientUpdateWithVersion, error)
 
 	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
@@ -92,6 +97,8 @@ type NoHeadAccessDatabase interface {
 	// Fee recipients operations.
 	SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []primitives.ValidatorIndex, addrs []common.Address) error
 	SaveRegistrationsByValidatorIDs(ctx context.Context, ids []primitives.ValidatorIndex, regs []*ethpb.ValidatorRegistrationV1) error
+	// light client operations
+	SaveLightClientUpdate(ctx context.Context, period uint64, update *ethpbv2.LightClientUpdateWithVersion) error
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
 }

beacon-chain/db/kv/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "genesis.go",
         "key.go",
         "kv.go",
+        "lightclient.go",
         "log.go",
         "migration.go",
         "migration_archived_index.go",
@@ -51,6 +52,7 @@ go_library(
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//proto/dbval:go_default_library",
+        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
@@ -87,6 +89,7 @@ go_test(
         "genesis_test.go",
         "init_test.go",
         "kv_test.go",
+        "lightclient_test.go",
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
@@ -113,6 +116,7 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",
         "//runtime/version:go_default_library",

beacon-chain/db/kv/kv.go

@@ -107,6 +107,7 @@ var Buckets = [][]byte{
 	powchainBucket,
 	stateSummaryBucket,
 	stateValidatorsBucket,
+	lightClientUpdatesBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,

beacon-chain/db/kv/lightclient.go

@@ -0,0 +1,79 @@
+package kv
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update *ethpbv2.LightClientUpdateWithVersion) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.saveLightClientUpdate")
+	defer span.End()
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(lightClientUpdatesBucket)
+		updateMarshalled, err := encode(ctx, update)
+		if err != nil {
+			return err
+		}
+		return bkt.Put(bytesutil.Uint64ToBytesBigEndian(period), updateMarshalled)
+	})
+}
+
+func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]*ethpbv2.LightClientUpdateWithVersion, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdates")
+	defer span.End()
+
+	if startPeriod > endPeriod {
+		return nil, fmt.Errorf("start period %d is greater than end period %d", startPeriod, endPeriod)
+	}
+
+	updates := make(map[uint64]*ethpbv2.LightClientUpdateWithVersion)
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(lightClientUpdatesBucket)
+		c := bkt.Cursor()
+
+		firstPeriodInDb, _ := c.First()
+		if firstPeriodInDb == nil {
+			return nil
+		}
+
+		for k, v := c.Seek(bytesutil.Uint64ToBytesBigEndian(startPeriod)); k != nil && binary.BigEndian.Uint64(k) <= endPeriod; k, v = c.Next() {
+			currentPeriod := binary.BigEndian.Uint64(k)
+
+			var update ethpbv2.LightClientUpdateWithVersion
+			if err := decode(ctx, v, &update); err != nil {
+				return err
+			}
+			updates[currentPeriod] = &update
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	return updates, err
+}
+
+func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (*ethpbv2.LightClientUpdateWithVersion, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdate")
+	defer span.End()
+
+	var update ethpbv2.LightClientUpdateWithVersion
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(lightClientUpdatesBucket)
+		updateBytes := bkt.Get(bytesutil.Uint64ToBytesBigEndian(period))
+		if updateBytes == nil {
+			return nil
+		}
+		return decode(ctx, updateBytes, &update)
+	})
+	return &update, err
+}

beacon-chain/db/kv/lightclient_test.go

@@ -0,0 +1,648 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestStore_LightclientUpdate_CanSaveRetrieve(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	update := &ethpbv2.LightClientUpdate{
+		AttestedHeader:          nil,
+		NextSyncCommittee:       nil,
+		NextSyncCommitteeBranch: nil,
+		FinalizedHeader:         nil,
+		FinalityBranch:          nil,
+		SyncAggregate:           nil,
+		SignatureSlot:           7,
+	}
+
+	period := uint64(1)
+	err := db.SaveLightClientUpdate(ctx, period, &ethpbv2.LightClientUpdateWithVersion{
+		Version: 1,
+		Data:    update,
+	})
+	require.NoError(t, err)
+
+	// Retrieve the update
+	retrievedUpdate, err := db.LightClientUpdate(ctx, period)
+	require.NoError(t, err)
+	require.Equal(t, update.SignatureSlot, retrievedUpdate.Data.SignatureSlot, "retrieved update does not match saved update")
+
+}
+
+func TestStore_LightclientUpdates_canRetrieveRange(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdatesMap, err := db.LightClientUpdates(ctx, 1, 3)
+	require.NoError(t, err)
+	require.Equal(t, len(updates), len(retrievedUpdatesMap), "retrieved updates do not match saved updates")
+	for i, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdatesMap[uint64(i+1)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+
+}
+
+func TestStore_LightClientUpdate_EndPeriodSmallerThanStartPeriod(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 3, 1)
+	require.NotNil(t, err)
+	require.Equal(t, err.Error(), "start period 3 is greater than end period 1")
+	require.IsNil(t, retrievedUpdates)
+
+}
+
+func TestStore_LightClientUpdate_EndPeriodEqualToStartPeriod(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 2, 2)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(retrievedUpdates))
+	require.Equal(t, updates[1].Data.SignatureSlot, retrievedUpdates[2].Data.SignatureSlot, "retrieved update does not match saved update")
+}
+
+func TestStore_LightClientUpdate_StartPeriodBeforeFirstUpdate(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+2), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 0, 4)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	for i, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(i+2)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_EndPeriodAfterLastUpdate(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 6)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	for i, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(i+1)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_PartialUpdates(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 2)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(retrievedUpdates))
+	for i, update := range updates[:2] {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(i+1)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriods_SimpleData(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           11,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           12,
+			},
+		},
+	}
+
+	for _, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(update.Data.SignatureSlot), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 7, 12)
+	require.NoError(t, err)
+	require.Equal(t, 4, len(retrievedUpdates))
+	for _, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(update.Data.SignatureSlot)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+
+	// Retrieve the updates from the middle
+	retrievedUpdates, err = db.LightClientUpdates(ctx, 8, 12)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	require.Equal(t, updates[1].Data.SignatureSlot, retrievedUpdates[8].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[2].Data.SignatureSlot, retrievedUpdates[11].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[3].Data.SignatureSlot, retrievedUpdates[12].Data.SignatureSlot, "retrieved update does not match saved update")
+
+	// Retrieve the updates from after the missing period
+	retrievedUpdates, err = db.LightClientUpdates(ctx, 11, 12)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(retrievedUpdates))
+	require.Equal(t, updates[2].Data.SignatureSlot, retrievedUpdates[11].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[3].Data.SignatureSlot, retrievedUpdates[12].Data.SignatureSlot, "retrieved update does not match saved update")
+
+	//retrieve the updates from before the missing period to after the missing period
+	retrievedUpdates, err = db.LightClientUpdates(ctx, 3, 15)
+	require.NoError(t, err)
+	require.Equal(t, 4, len(retrievedUpdates))
+	require.Equal(t, updates[0].Data.SignatureSlot, retrievedUpdates[7].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[1].Data.SignatureSlot, retrievedUpdates[8].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[2].Data.SignatureSlot, retrievedUpdates[11].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[3].Data.SignatureSlot, retrievedUpdates[12].Data.SignatureSlot, "retrieved update does not match saved update")
+}
+
+func TestStore_LightClientUpdate_EmptyDB(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 3)
+	require.IsNil(t, err)
+	require.Equal(t, 0, len(retrievedUpdates))
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsAtTheEnd_SimpleData(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	for i := 1; i < 4; i++ {
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+	for i := 7; i < 10; i++ {
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates from 1 to 5
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 5)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	require.Equal(t, primitives.Slot(1), retrievedUpdates[1].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, primitives.Slot(2), retrievedUpdates[2].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, primitives.Slot(3), retrievedUpdates[3].Data.SignatureSlot, "retrieved update does not match saved update")
+
+}
+
+func setupLightClientTestDB(t *testing.T) (*Store, context.Context) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	for i := 10; i < 101; i++ { // 10 to 100
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+
+	for i := 110; i < 201; i++ { // 110 to 200
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+
+	return db, ctx
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsInTheMiddleDistributed(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// Retrieve the updates - should fail because of missing periods in the middle
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 300)
+	require.NoError(t, err)
+	require.Equal(t, 91*2, len(retrievedUpdates))
+	for i := 10; i < 101; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+
+}
+
+func TestStore_LightClientUpdate_RetrieveValidRangeFromStart(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 1 to 100 - should work because all periods are present after the firstPeriodInDB > startPeriod
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 100)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 10; i < 101; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_RetrieveValidRangeInTheMiddle(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 110 to 200 - should work because all periods are present
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 110, 200)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriodInTheMiddleConcentrated(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 100 to 200
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 100, 200)
+	require.NoError(t, err)
+	require.Equal(t, 92, len(retrievedUpdates))
+	require.Equal(t, primitives.Slot(100), retrievedUpdates[100].Data.SignatureSlot, "retrieved update does not match saved update")
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsAtTheEnd(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 10 to 109
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 10, 109)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 10; i < 101; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsAtTheBeginning(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 105 to 200
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 105, 200)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_StartPeriodGreaterThanLastPeriod(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 300 to 400
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 300, 400)
+	require.NoError(t, err)
+	require.Equal(t, 0, len(retrievedUpdates))
+
+}

beacon-chain/db/kv/schema.go

@@ -17,6 +17,9 @@ var (
 	feeRecipientBucket    = []byte("fee-recipient")
 	registrationBucket    = []byte("registration")
 
+	// Light Client Updates Bucket
+	lightClientUpdatesBucket = []byte("light-client-updates")
+
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.

beacon-chain/execution/mock_test.go

@@ -84,11 +84,15 @@ func (s *mockEngine) callCount(method string) int {
 }
 
 func mockParseUintList(t *testing.T, data json.RawMessage) []uint64 {
-	var list []uint64
+	var list []string
 	if err := json.Unmarshal(data, &list); err != nil {
 		t.Fatalf("failed to parse uint list: %v", err)
 	}
-	return list
+	uints := make([]uint64, len(list))
+	for i, u := range list {
+		uints[i] = hexutil.MustDecodeUint64(u)
+	}
+	return uints
 }
 
 func mockParseHexByteList(t *testing.T, data json.RawMessage) []hexutil.Bytes {
@@ -117,7 +121,7 @@ func TestParseRequest(t *testing.T) {
 	ctx := context.Background()
 	cases := []struct {
 		method   string
-		uintArgs []uint64
+		hexArgs  []string // uint64 as hex
 		byteArgs []hexutil.Bytes
 	}{
 		{
@@ -135,26 +139,28 @@ func TestParseRequest(t *testing.T) {
 			},
 		},
 		{
-			method:   GetPayloadBodiesByRangeV1,
-			uintArgs: []uint64{0, 1},
+			method:  GetPayloadBodiesByRangeV1,
+			hexArgs: []string{hexutil.EncodeUint64(0), hexutil.EncodeUint64(1)},
 		},
 		{
-			method:   GetPayloadBodiesByRangeV2,
-			uintArgs: []uint64{math.MaxUint64, 1},
+			method:  GetPayloadBodiesByRangeV2,
+			hexArgs: []string{hexutil.EncodeUint64(math.MaxUint64), hexutil.EncodeUint64(1)},
 		},
 	}
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {
 			cli, srv := newMockEngine(t)
-			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, _ *http.Request) {
 				require.Equal(t, c.method, msg.Method)
 				nr := uint64(len(c.byteArgs))
 				if len(c.byteArgs) > 0 {
 					require.DeepEqual(t, c.byteArgs, mockParseHexByteList(t, msg.Params))
 				}
-				if len(c.uintArgs) > 0 {
+				if len(c.hexArgs) > 0 {
 					rang := mockParseUintList(t, msg.Params)
-					require.DeepEqual(t, c.uintArgs, rang)
+					for i, r := range rang {
+						require.Equal(t, c.hexArgs[i], hexutil.EncodeUint64(r))
+					}
 					nr = rang[1]
 				}
 				mockWriteResult(t, w, msg, make([]*pb.ExecutionPayloadBody, nr))
@@ -165,18 +171,18 @@ func TestParseRequest(t *testing.T) {
 			if len(c.byteArgs) > 0 {
 				args = []interface{}{c.byteArgs}
 			}
-			if len(c.uintArgs) > 0 {
-				args = make([]interface{}, len(c.uintArgs))
-				for i := range c.uintArgs {
-					args[i] = c.uintArgs[i]
+			if len(c.hexArgs) > 0 {
+				args = make([]interface{}, len(c.hexArgs))
+				for i := range c.hexArgs {
+					args[i] = c.hexArgs[i]
 				}
 			}
 			require.NoError(t, cli.CallContext(ctx, &result, c.method, args...))
 			if len(c.byteArgs) > 0 {
 				require.Equal(t, len(c.byteArgs), len(result))
 			}
-			if len(c.uintArgs) > 0 {
-				require.Equal(t, int(c.uintArgs[1]), len(result))
+			if len(c.hexArgs) > 0 {
+				require.Equal(t, int(hexutil.MustDecodeUint64(c.hexArgs[1])), len(result))
 			}
 		})
 	}
@@ -203,7 +209,7 @@ func TestCallCount(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {
 			cli, srv := newMockEngine(t)
-			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, _ *http.Request) {
 				mockWriteResult(t, w, msg, nil)
 			})
 			for i := 0; i < c.count; i++ {

beacon-chain/execution/payload_body.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -160,7 +161,7 @@ func computeRanges(hbns []hashBlockNumber) []byRangeReq {
 
 func (r *blindedBlockReconstructor) requestBodiesByRange(ctx context.Context, client RPCClient, method string, req byRangeReq) error {
 	result := make([]*pb.ExecutionPayloadBody, 0)
-	if err := client.CallContext(ctx, &result, method, req.start, req.count); err != nil {
+	if err := client.CallContext(ctx, &result, method, hexutil.EncodeUint64(req.start), hexutil.EncodeUint64(req.count)); err != nil {
 		return err
 	}
 	if uint64(len(result)) != req.count {

beacon-chain/forkchoice/doubly-linked-tree/forkchoice.go

@@ -676,3 +676,18 @@ func (f *ForkChoice) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch) (
 	}
 	return f.TargetRootForEpoch(targetNode.root, epoch)
 }
+
+// ParentRoot returns the block root of the parent node if it is in forkchoice.
+// The exception is for the finalized checkpoint root which we return the zero
+// hash.
+func (f *ForkChoice) ParentRoot(root [32]byte) ([32]byte, error) {
+	n, ok := f.store.nodeByRoot[root]
+	if !ok || n == nil {
+		return [32]byte{}, ErrNilNode
+	}
+	// Return the zero hash for the tree root
+	if n.parent == nil {
+		return [32]byte{}, nil
+	}
+	return n.parent.root, nil
+}

beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go

@@ -861,3 +861,29 @@ func TestForkChoiceSlot(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, primitives.Slot(3), slot)
 }
+
+func TestForkchoiceParentRoot(t *testing.T) {
+	f := setup(0, 0)
+	ctx := context.Background()
+	root1 := [32]byte{'a'}
+	st, root, err := prepareForkchoiceState(ctx, 3, root1, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+
+	root2 := [32]byte{'b'}
+	st, root, err = prepareForkchoiceState(ctx, 3, root2, root1, [32]byte{'A'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+
+	root, err = f.ParentRoot(root2)
+	require.NoError(t, err)
+	require.Equal(t, root1, root)
+
+	_, err = f.ParentRoot([32]byte{'c'})
+	require.ErrorIs(t, err, ErrNilNode)
+
+	zeroHash := [32]byte{}
+	root, err = f.ParentRoot(zeroHash)
+	require.NoError(t, err)
+	require.Equal(t, zeroHash, root)
+}

beacon-chain/forkchoice/interfaces.go

@@ -80,6 +80,7 @@ type FastGetter interface {
 	TargetRootForEpoch([32]byte, primitives.Epoch) ([32]byte, error)
 	UnrealizedJustifiedPayloadBlockHash() [32]byte
 	Weight(root [32]byte) (uint64, error)
+	ParentRoot(root [32]byte) ([32]byte, error)
 }
 
 // Setter allows to set forkchoice information

beacon-chain/forkchoice/ro.go

@@ -169,3 +169,10 @@ func (ro *ROForkChoice) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch
 	defer ro.l.RUnlock()
 	return ro.getter.TargetRootForEpoch(root, epoch)
 }
+
+// ParentRoot delegates to the underlying forkchoice call, under a lock.
+func (ro *ROForkChoice) ParentRoot(root [32]byte) ([32]byte, error) {
+	ro.l.RLock()
+	defer ro.l.RUnlock()
+	return ro.getter.ParentRoot(root)
+}

beacon-chain/forkchoice/ro_test.go

@@ -37,6 +37,7 @@ const (
 	slotCalled
 	lastRootCalled
 	targetRootForEpochCalled
+	parentRootCalled
 )
 
 func _discard(t *testing.T, e error) {
@@ -291,3 +292,8 @@ func (ro *mockROForkchoice) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) (
 	ro.calls = append(ro.calls, targetRootForEpochCalled)
 	return [32]byte{}, nil
 }
+
+func (ro *mockROForkchoice) ParentRoot(_ [32]byte) ([32]byte, error) {
+	ro.calls = append(ro.calls, parentRootCalled)
+	return [32]byte{}, nil
+}

beacon-chain/node/config.go

@@ -73,6 +73,21 @@ func configureBuilderCircuitBreaker(cliCtx *cli.Context) error {
 			return err
 		}
 	}
+	if cliCtx.IsSet(flags.MinBuilderBid.Name) {
+		c := params.BeaconConfig().Copy()
+		c.MinBuilderBid = cliCtx.Uint64(flags.MinBuilderBid.Name)
+		if err := params.SetActive(c); err != nil {
+			return err
+		}
+	}
+	if cliCtx.IsSet(flags.MinBuilderDiff.Name) {
+		c := params.BeaconConfig().Copy()
+		c.MinBuilderDiff = cliCtx.Uint64(flags.MinBuilderDiff.Name)
+		if err := params.SetActive(c); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
@@ -117,7 +132,7 @@ func configureEth1Config(cliCtx *cli.Context) error {
 }
 
 func configureNetwork(cliCtx *cli.Context) {
-	if len(cliCtx.StringSlice(cmd.BootstrapNode.Name)) > 0 {
+	if cliCtx.IsSet(cmd.BootstrapNode.Name) {
 		c := params.BeaconNetworkConfig()
 		c.BootstrapNodes = cliCtx.StringSlice(cmd.BootstrapNode.Name)
 		params.OverrideBeaconNetworkConfig(c)

beacon-chain/p2p/testing/mock_peersprovider.go

@@ -16,6 +16,11 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+const (
+	MockRawPeerId0 = "16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR"
+	MockRawPeerId1 = "16Uiu2HAm4HgJ9N1o222xK61o7LSgToYWoAy1wNTJRkh9gLZapVAy"
+)
+
 // MockPeersProvider implements PeersProvider for testing.
 type MockPeersProvider struct {
 	lock  sync.Mutex
@@ -50,7 +55,7 @@ func (m *MockPeersProvider) Peers() *peers.Status {
 			},
 		})
 		// Pretend we are connected to two peers
-		id0, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR")
+		id0, err := peer.Decode(MockRawPeerId0)
 		if err != nil {
 			log.WithError(err).Debug("Cannot decode")
 		}
@@ -61,7 +66,7 @@ func (m *MockPeersProvider) Peers() *peers.Status {
 		m.peers.Add(createENR(), id0, ma0, network.DirInbound)
 		m.peers.SetConnectionState(id0, peers.PeerConnected)
 		m.peers.SetChainState(id0, &pb.Status{FinalizedEpoch: 10})
-		id1, err := peer.Decode("16Uiu2HAm4HgJ9N1o222xK61o7LSgToYWoAy1wNTJRkh9gLZapVAy")
+		id1, err := peer.Decode(MockRawPeerId1)
 		if err != nil {
 			log.WithError(err).Debug("Cannot decode")
 		}

beacon-chain/rpc/core/BUILD.bazel

@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "beacon.go",
         "errors.go",
         "log.go",
         "service.go",
@@ -20,6 +21,8 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/p2p:go_default_library",
@@ -28,6 +31,7 @@ go_library(
         "//beacon-chain/sync: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",
         "//consensus-types/validator:go_default_library",
         "//crypto/bls:go_default_library",

beacon-chain/rpc/core/beacon.go

@@ -0,0 +1,128 @@
+package core
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+// Retrieve chain head information from the DB and the current beacon state.
+func (s *Service) ChainHead(ctx context.Context) (*ethpb.ChainHead, *RpcError) {
+	headBlock, err := s.HeadFetcher.HeadBlock(ctx)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "could not get head block"),
+			Reason: Internal,
+		}
+	}
+	if err := consensusblocks.BeaconBlockIsNil(headBlock); err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "head block of chain was nil"),
+			Reason: NotFound,
+		}
+	}
+	optimisticStatus, err := s.OptimisticModeFetcher.IsOptimistic(ctx)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "could not get optimistic status"),
+			Reason: Internal,
+		}
+	}
+	headBlockRoot, err := headBlock.Block().HashTreeRoot()
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "could not get head block root"),
+			Reason: Internal,
+		}
+	}
+
+	validGenesis := false
+	validateCP := func(cp *ethpb.Checkpoint, name string) error {
+		if bytesutil.ToBytes32(cp.Root) == params.BeaconConfig().ZeroHash && cp.Epoch == 0 {
+			if validGenesis {
+				return nil
+			}
+			// Retrieve genesis block in the event we have genesis checkpoints.
+			genBlock, err := s.BeaconDB.GenesisBlock(ctx)
+			if err != nil || consensusblocks.BeaconBlockIsNil(genBlock) != nil {
+				return errors.New("could not get genesis block")
+			}
+			validGenesis = true
+			return nil
+		}
+		b, err := s.BeaconDB.Block(ctx, bytesutil.ToBytes32(cp.Root))
+		if err != nil {
+			return errors.Errorf("could not get %s block: %v", name, err)
+		}
+		if err := consensusblocks.BeaconBlockIsNil(b); err != nil {
+			return errors.Errorf("could not get %s block: %v", name, err)
+		}
+		return nil
+	}
+
+	finalizedCheckpoint := s.FinalizedFetcher.FinalizedCheckpt()
+	if err := validateCP(finalizedCheckpoint, "finalized"); err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrap(err, "could not get finalized checkpoint"),
+			Reason: Internal,
+		}
+	}
+
+	justifiedCheckpoint := s.FinalizedFetcher.CurrentJustifiedCheckpt()
+	if err := validateCP(justifiedCheckpoint, "justified"); err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrap(err, "could not get current justified checkpoint"),
+			Reason: Internal,
+		}
+	}
+
+	prevJustifiedCheckpoint := s.FinalizedFetcher.PreviousJustifiedCheckpt()
+	if err := validateCP(prevJustifiedCheckpoint, "prev justified"); err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrap(err, "could not get previous justified checkpoint"),
+			Reason: Internal,
+		}
+	}
+
+	fSlot, err := slots.EpochStart(finalizedCheckpoint.Epoch)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "could not get epoch start slot from finalized checkpoint epoch"),
+			Reason: Internal,
+		}
+	}
+	jSlot, err := slots.EpochStart(justifiedCheckpoint.Epoch)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "could not get epoch start slot from justified checkpoint epoch"),
+			Reason: Internal,
+		}
+	}
+	pjSlot, err := slots.EpochStart(prevJustifiedCheckpoint.Epoch)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "could not get epoch start slot from prev justified checkpoint epoch"),
+			Reason: Internal,
+		}
+	}
+	return &ethpb.ChainHead{
+		HeadSlot:                   headBlock.Block().Slot(),
+		HeadEpoch:                  slots.ToEpoch(headBlock.Block().Slot()),
+		HeadBlockRoot:              headBlockRoot[:],
+		FinalizedSlot:              fSlot,
+		FinalizedEpoch:             finalizedCheckpoint.Epoch,
+		FinalizedBlockRoot:         finalizedCheckpoint.Root,
+		JustifiedSlot:              jSlot,
+		JustifiedEpoch:             justifiedCheckpoint.Epoch,
+		JustifiedBlockRoot:         justifiedCheckpoint.Root,
+		PreviousJustifiedSlot:      pjSlot,
+		PreviousJustifiedEpoch:     prevJustifiedCheckpoint.Epoch,
+		PreviousJustifiedBlockRoot: prevJustifiedCheckpoint.Root,
+		OptimisticStatus:           optimisticStatus,
+	}, nil
+}

beacon-chain/rpc/core/service.go

@@ -4,6 +4,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	opfeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/synccommittee"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
@@ -11,6 +12,8 @@ import (
 )
 
 type Service struct {
+	BeaconDB              db.ReadOnlyDatabase
+	ChainInfoFetcher      blockchain.ChainInfoFetcher
 	HeadFetcher           blockchain.HeadFetcher
 	FinalizedFetcher      blockchain.FinalizationFetcher
 	GenesisTimeFetcher    blockchain.TimeFetcher

beacon-chain/rpc/core/validator.go

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	beaconState "github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
@@ -752,3 +753,177 @@ func subnetsFromCommittee(pubkey []byte, comm *ethpb.SyncCommittee) []uint64 {
 	}
 	return positions
 }
+
+// ValidatorParticipation retrieves the validator participation information for a given epoch,
+// it returns the information about validator's participation rate in voting on the proof of stake
+// rules based on their balance compared to the total active validator balance.
+func (s *Service) ValidatorParticipation(
+	ctx context.Context,
+	requestedEpoch primitives.Epoch,
+) (
+	*ethpb.ValidatorParticipationResponse,
+	*RpcError,
+) {
+	currentSlot := s.GenesisTimeFetcher.CurrentSlot()
+	currentEpoch := slots.ToEpoch(currentSlot)
+
+	if requestedEpoch > currentEpoch {
+		return nil, &RpcError{
+			Err:    fmt.Errorf("cannot retrieve information about an epoch greater than current epoch, current epoch %d, requesting %d", currentEpoch, requestedEpoch),
+			Reason: BadRequest,
+		}
+	}
+	// Use the last slot of requested epoch to obtain current and previous epoch attestations.
+	// This ensures that we don't miss previous attestations when input requested epochs.
+	endSlot, err := slots.EpochEnd(requestedEpoch)
+	if err != nil {
+		return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not get slot from requested epoch")}
+	}
+	// Get as close as we can to the end of the current epoch without going past the current slot.
+	// The above check ensures a future *epoch* isn't requested, but the end slot of the requested epoch could still
+	// be past the current slot. In that case, use the current slot as the best approximation of the requested epoch.
+	// Replayer will make sure the slot ultimately used is canonical.
+	if endSlot > currentSlot {
+		endSlot = currentSlot
+	}
+
+	// ReplayerBuilder ensures that a canonical chain is followed to the slot
+	beaconSt, err := s.ReplayerBuilder.ReplayerForSlot(endSlot).ReplayBlocks(ctx)
+	if err != nil {
+		return nil, &RpcError{Reason: Internal, Err: errors.Wrapf(err, "error replaying blocks for state at slot %d", endSlot)}
+	}
+	var v []*precompute.Validator
+	var b *precompute.Balance
+
+	if beaconSt.Version() == version.Phase0 {
+		v, b, err = precompute.New(ctx, beaconSt)
+		if err != nil {
+			return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not set up pre compute instance")}
+		}
+		_, b, err = precompute.ProcessAttestations(ctx, beaconSt, v, b)
+		if err != nil {
+			return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not pre compute attestations")}
+		}
+	} else if beaconSt.Version() >= version.Altair {
+		v, b, err = altair.InitializePrecomputeValidators(ctx, beaconSt)
+		if err != nil {
+			return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not set up altair pre compute instance")}
+		}
+		_, b, err = altair.ProcessEpochParticipation(ctx, beaconSt, b, v)
+		if err != nil {
+			return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not pre compute attestations: %v")}
+		}
+	} else {
+		return nil, &RpcError{Reason: Internal, Err: fmt.Errorf("invalid state type retrieved with a version of %s", version.String(beaconSt.Version()))}
+	}
+
+	cp := s.FinalizedFetcher.FinalizedCheckpt()
+	p := &ethpb.ValidatorParticipationResponse{
+		Epoch:     requestedEpoch,
+		Finalized: requestedEpoch <= cp.Epoch,
+		Participation: &ethpb.ValidatorParticipation{
+			// TODO(7130): Remove these three deprecated fields.
+			GlobalParticipationRate:          float32(b.PrevEpochTargetAttested) / float32(b.ActivePrevEpoch),
+			VotedEther:                       b.PrevEpochTargetAttested,
+			EligibleEther:                    b.ActivePrevEpoch,
+			CurrentEpochActiveGwei:           b.ActiveCurrentEpoch,
+			CurrentEpochAttestingGwei:        b.CurrentEpochAttested,
+			CurrentEpochTargetAttestingGwei:  b.CurrentEpochTargetAttested,
+			PreviousEpochActiveGwei:          b.ActivePrevEpoch,
+			PreviousEpochAttestingGwei:       b.PrevEpochAttested,
+			PreviousEpochTargetAttestingGwei: b.PrevEpochTargetAttested,
+			PreviousEpochHeadAttestingGwei:   b.PrevEpochHeadAttested,
+		},
+	}
+	return p, nil
+}
+
+// ValidatorActiveSetChanges retrieves the active set changes for a given epoch.
+//
+// This data includes any activations, voluntary exits, and involuntary
+// ejections.
+func (s *Service) ValidatorActiveSetChanges(
+	ctx context.Context,
+	requestedEpoch primitives.Epoch,
+) (
+	*ethpb.ActiveSetChanges,
+	*RpcError,
+) {
+	currentEpoch := slots.ToEpoch(s.GenesisTimeFetcher.CurrentSlot())
+	if requestedEpoch > currentEpoch {
+		return nil, &RpcError{
+			Err:    errors.Errorf("cannot retrieve information about an epoch in the future, current epoch %d, requesting %d", currentEpoch, requestedEpoch),
+			Reason: BadRequest,
+		}
+	}
+
+	slot, err := slots.EpochStart(requestedEpoch)
+	if err != nil {
+		return nil, &RpcError{Err: err, Reason: BadRequest}
+	}
+	requestedState, err := s.ReplayerBuilder.ReplayerForSlot(slot).ReplayBlocks(ctx)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrapf(err, "error replaying blocks for state at slot %d", slot),
+			Reason: Internal,
+		}
+	}
+
+	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, requestedState, coreTime.CurrentEpoch(requestedState))
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrap(err, "could not get active validator count"),
+			Reason: Internal,
+		}
+	}
+	vs := requestedState.Validators()
+	activatedIndices := validators.ActivatedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs)
+	exitedIndices, err := validators.ExitedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs, activeValidatorCount)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrap(err, "could not determine exited validator indices"),
+			Reason: Internal,
+		}
+	}
+	slashedIndices := validators.SlashedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs)
+	ejectedIndices, err := validators.EjectedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs, activeValidatorCount)
+	if err != nil {
+		return nil, &RpcError{
+			Err:    errors.Wrap(err, "could not determine ejected validator indices"),
+			Reason: Internal,
+		}
+	}
+
+	// Retrieve public keys for the indices.
+	activatedKeys := make([][]byte, len(activatedIndices))
+	exitedKeys := make([][]byte, len(exitedIndices))
+	slashedKeys := make([][]byte, len(slashedIndices))
+	ejectedKeys := make([][]byte, len(ejectedIndices))
+	for i, idx := range activatedIndices {
+		pubkey := requestedState.PubkeyAtIndex(idx)
+		activatedKeys[i] = pubkey[:]
+	}
+	for i, idx := range exitedIndices {
+		pubkey := requestedState.PubkeyAtIndex(idx)
+		exitedKeys[i] = pubkey[:]
+	}
+	for i, idx := range slashedIndices {
+		pubkey := requestedState.PubkeyAtIndex(idx)
+		slashedKeys[i] = pubkey[:]
+	}
+	for i, idx := range ejectedIndices {
+		pubkey := requestedState.PubkeyAtIndex(idx)
+		ejectedKeys[i] = pubkey[:]
+	}
+	return &ethpb.ActiveSetChanges{
+		Epoch:               requestedEpoch,
+		ActivatedPublicKeys: activatedKeys,
+		ActivatedIndices:    activatedIndices,
+		ExitedPublicKeys:    exitedKeys,
+		ExitedIndices:       exitedIndices,
+		SlashedPublicKeys:   slashedKeys,
+		SlashedIndices:      slashedIndices,
+		EjectedPublicKeys:   ejectedKeys,
+		EjectedIndices:      ejectedIndices,
+	}, nil
+}

beacon-chain/rpc/endpoints.go

@@ -70,7 +70,7 @@ func (s *Service) endpoints(
 	endpoints = append(endpoints, s.eventsEndpoints()...)
 	endpoints = append(endpoints, s.prysmBeaconEndpoints(ch, stater, coreService)...)
 	endpoints = append(endpoints, s.prysmNodeEndpoints()...)
-	endpoints = append(endpoints, s.prysmValidatorEndpoints(coreService)...)
+	endpoints = append(endpoints, s.prysmValidatorEndpoints(stater, coreService)...)
 	if enableDebug {
 		endpoints = append(endpoints, s.debugEndpoints(stater)...)
 	}
@@ -815,6 +815,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 		Blocker:     blocker,
 		Stater:      stater,
 		HeadFetcher: s.cfg.HeadFetcher,
+		BeaconDB:    s.cfg.BeaconDB,
 	}
 
 	const namespace = "lightclient"
@@ -983,6 +984,15 @@ func (s *Service) prysmBeaconEndpoints(
 			handler: server.GetIndividualVotes,
 			methods: []string{http.MethodPost},
 		},
+		{
+			template: "/prysm/v1/beacon/chain_head",
+			name:     namespace + ".GetChainHead",
+			middleware: []mux.MiddlewareFunc{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetChainHead,
+			methods: []string{http.MethodGet},
+		},
 	}
 }
 
@@ -1060,32 +1070,52 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 	}
 }
 
-func (*Service) prysmValidatorEndpoints(coreService *core.Service) []endpoint {
+func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *core.Service) []endpoint {
 	server := &validatorprysm.Server{
-		CoreService: coreService,
+		ChainInfoFetcher: s.cfg.ChainInfoFetcher,
+		Stater:           stater,
+		CoreService:      coreService,
 	}
 
 	const namespace = "prysm.validator"
 	return []endpoint{
 		{
 			template: "/prysm/validators/performance",
-			name:     namespace + ".GetValidatorPerformance",
+			name:     namespace + ".GetPerformance",
 			middleware: []mux.MiddlewareFunc{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
-			handler: server.GetValidatorPerformance,
+			handler: server.GetPerformance,
 			methods: []string{http.MethodPost},
 		},
 		{
 			template: "/prysm/v1/validators/performance",
-			name:     namespace + ".GetValidatorPerformance",
+			name:     namespace + ".GetPerformance",
 			middleware: []mux.MiddlewareFunc{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
-			handler: server.GetValidatorPerformance,
+			handler: server.GetPerformance,
 			methods: []string{http.MethodPost},
 		},
+		{
+			template: "/prysm/v1/validators/participation",
+			name:     namespace + ".GetParticipation",
+			middleware: []mux.MiddlewareFunc{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetParticipation,
+			methods: []string{http.MethodGet},
+		},
+		{
+			template: "/prysm/v1/validators/active_set_changes",
+			name:     namespace + ".GetActiveSetChanges",
+			middleware: []mux.MiddlewareFunc{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetActiveSetChanges,
+			methods: []string{http.MethodGet},
+		},
 	}
 }

beacon-chain/rpc/endpoints_test.go

@@ -114,6 +114,7 @@ func Test_endpoints(t *testing.T) {
 		"/prysm/v1/beacon/weak_subjectivity":                 {http.MethodGet},
 		"/eth/v1/beacon/states/{state_id}/validator_count":   {http.MethodGet},
 		"/prysm/v1/beacon/states/{state_id}/validator_count": {http.MethodGet},
+		"/prysm/v1/beacon/chain_head":                        {http.MethodGet},
 	}
 
 	prysmNodeRoutes := map[string][]string{
@@ -124,8 +125,10 @@ func Test_endpoints(t *testing.T) {
 	}
 
 	prysmValidatorRoutes := map[string][]string{
-		"/prysm/validators/performance":    {http.MethodPost},
-		"/prysm/v1/validators/performance": {http.MethodPost},
+		"/prysm/validators/performance":           {http.MethodPost},
+		"/prysm/v1/validators/performance":        {http.MethodPost},
+		"/prysm/v1/validators/participation":      {http.MethodGet},
+		"/prysm/v1/validators/active_set_changes": {http.MethodGet},
 	}
 
 	s := &Service{cfg: &Config{}}

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

@@ -116,9 +116,11 @@ func (s *Server) getBlockV2Ssz(w http.ResponseWriter, blk interfaces.ReadOnlySig
 	result, err := s.getBlockResponseBodySsz(blk)
 	if err != nil {
 		httputil.HandleError(w, "Could not get signed beacon block: "+err.Error(), http.StatusInternalServerError)
+		return
 	}
 	if result == nil {
 		httputil.HandleError(w, fmt.Sprintf("Unknown block type %T", blk), http.StatusInternalServerError)
+		return
 	}
 	w.Header().Set(api.VersionHeader, version.String(blk.Version()))
 	httputil.WriteSsz(w, result, "beacon_block.ssz")
@@ -149,6 +151,11 @@ func (s *Server) getBlockV2Json(ctx context.Context, w http.ResponseWriter, blk
 	result, err := s.getBlockResponseBodyJson(ctx, blk)
 	if err != nil {
 		httputil.HandleError(w, "Error processing request: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if result == nil {
+		httputil.HandleError(w, fmt.Sprintf("Unknown block type %T", blk), http.StatusInternalServerError)
+		return
 	}
 	w.Header().Set(api.VersionHeader, result.Version)
 	httputil.WriteJson(w, result)
@@ -279,7 +286,7 @@ func (s *Server) PublishBlindedBlockV2(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body: "+err.Error(), http.StatusInternalServerError)
@@ -290,6 +297,29 @@ func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWrit
 		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
 	}
 
+	electraBlock := &eth.SignedBlindedBeaconBlockElectra{}
+	if err = electraBlock.UnmarshalSSZ(body); err == nil {
+		genericBlock := &eth.GenericSignedBeaconBlock{
+			Block: &eth.GenericSignedBeaconBlock_BlindedElectra{
+				BlindedElectra: electraBlock,
+			},
+		}
+		if err = s.validateBroadcast(ctx, r, genericBlock); err != nil {
+			httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		s.proposeBlock(ctx, w, genericBlock)
+		return
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	denebBlock := &eth.SignedBlindedBeaconBlockDeneb{}
 	if err = denebBlock.UnmarshalSSZ(body); err == nil {
 		genericBlock := &eth.GenericSignedBeaconBlock{
@@ -408,7 +438,7 @@ func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWrit
 	httputil.HandleError(w, "Body does not represent a valid block type", http.StatusBadRequest)
 }
 
-func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body", http.StatusInternalServerError)
@@ -421,6 +451,27 @@ func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter,
 
 	var consensusBlock *eth.GenericSignedBeaconBlock
 
+	var electraBlock *structs.SignedBlindedBeaconBlockElectra
+	if err = unmarshalStrict(body, &electraBlock); err == nil {
+		consensusBlock, err = electraBlock.ToGeneric()
+		if err == nil {
+			if err = s.validateBroadcast(ctx, r, consensusBlock); err != nil {
+				httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.proposeBlock(ctx, w, consensusBlock)
+			return
+		}
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	var denebBlock *structs.SignedBlindedBeaconBlockDeneb
 	if err = unmarshalStrict(body, &denebBlock); err == nil {
 		consensusBlock, err = denebBlock.ToGeneric()
@@ -572,7 +623,7 @@ func (s *Server) PublishBlockV2(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body", http.StatusInternalServerError)
@@ -584,6 +635,39 @@ func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *
 		return
 	}
 
+	electraBlock := &eth.SignedBeaconBlockContentsElectra{}
+	if err = electraBlock.UnmarshalSSZ(body); err == nil {
+		genericBlock := &eth.GenericSignedBeaconBlock{
+			Block: &eth.GenericSignedBeaconBlock_Electra{
+				Electra: electraBlock,
+			},
+		}
+		if err = s.validateBroadcast(ctx, r, genericBlock); err != nil {
+			if errors.Is(err, errEquivocatedBlock) {
+				b, err := blocks.NewSignedBeaconBlock(genericBlock)
+				if err != nil {
+					httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+					return
+				}
+				if err := s.broadcastSeenBlockSidecars(ctx, b, genericBlock.GetElectra().Blobs, genericBlock.GetElectra().KzgProofs); err != nil {
+					log.WithError(err).Error("Failed to broadcast blob sidecars")
+				}
+			}
+			httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		s.proposeBlock(ctx, w, genericBlock)
+		return
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	denebBlock := &eth.SignedBeaconBlockContentsDeneb{}
 	if err = denebBlock.UnmarshalSSZ(body); err == nil {
 		genericBlock := &eth.GenericSignedBeaconBlock{
@@ -712,7 +796,7 @@ func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *
 	httputil.HandleError(w, "Body does not represent a valid block type", http.StatusBadRequest)
 }
 
-func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body", http.StatusInternalServerError)
@@ -726,6 +810,37 @@ func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *htt
 
 	var consensusBlock *eth.GenericSignedBeaconBlock
 
+	var electraBlockContents *structs.SignedBeaconBlockContentsElectra
+	if err = unmarshalStrict(body, &electraBlockContents); err == nil {
+		consensusBlock, err = electraBlockContents.ToGeneric()
+		if err == nil {
+			if err = s.validateBroadcast(ctx, r, consensusBlock); err != nil {
+				if errors.Is(err, errEquivocatedBlock) {
+					b, err := blocks.NewSignedBeaconBlock(consensusBlock)
+					if err != nil {
+						httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+						return
+					}
+					if err := s.broadcastSeenBlockSidecars(ctx, b, consensusBlock.GetElectra().Blobs, consensusBlock.GetElectra().KzgProofs); err != nil {
+						log.WithError(err).Error("Failed to broadcast blob sidecars")
+					}
+				}
+				httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.proposeBlock(ctx, w, consensusBlock)
+			return
+		}
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	var denebBlockContents *structs.SignedBeaconBlockContentsDeneb
 	if err = unmarshalStrict(body, &denebBlockContents); err == nil {
 		consensusBlock, err = denebBlockContents.ToGeneric()

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

@@ -1071,6 +1071,29 @@ func TestPublishBlock(t *testing.T) {
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			converted, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBeaconBlockContentsElectra
+			err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.ElectraBlockContents)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1254,6 +1277,32 @@ func TestPublishBlockSSZ(t *testing.T) {
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1433,6 +1482,30 @@ func TestPublishBlindedBlock(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock.Message)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1617,6 +1690,32 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1788,6 +1887,30 @@ func TestPublishBlockV2(t *testing.T) {
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			converted, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBeaconBlockContentsElectra
+			err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.ElectraBlockContents)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1984,6 +2107,32 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -2176,6 +2325,30 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock.Message)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -2372,6 +2545,32 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},

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

@@ -488,7 +488,7 @@ func TestGetSpec(t *testing.T) {
 			case "MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT":
 				assert.Equal(t, "256000000000", v)
 			case "DATA_COLUMN_SIDECAR_SUBNET_COUNT":
-				assert.Equal(t, "32", v)
+				assert.Equal(t, "128", v)
 			case "MAX_REQUEST_DATA_COLUMN_SIDECARS":
 				assert.Equal(t, "16384", v)
 			case "MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA":

beacon-chain/rpc/eth/light-client/BUILD.bazel

@@ -12,6 +12,8 @@ go_library(
     deps = [
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -41,9 +43,9 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//api/server/structs:go_default_library",
-        "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",

beacon-chain/rpc/eth/light-client/handlers_test.go

@@ -73,7 +73,7 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 	resp := &structs.LightClientBootstrapResponse{}
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 	require.Equal(t, "capella", resp.Version)
-	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.BodyRoot)
+	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.Beacon.BodyRoot)
 	require.NotNil(t, resp.Data)
 }
 

beacon-chain/rpc/eth/light-client/helpers.go

@@ -6,9 +6,10 @@ import (
 	"reflect"
 	"strconv"
 
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -66,17 +67,20 @@ func createLightClientBootstrap(ctx context.Context, state state.BeaconState) (*
 		branch[i] = hexutil.Encode(proof)
 	}
 
-	header := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
-	if header == nil {
+	beacon := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
+	if beacon == nil {
 		return nil, fmt.Errorf("could not get beacon block header")
 	}
+	header := &structs.LightClientHeader{
+		Beacon: beacon,
+	}
 
 	// Above shared util function won't calculate state root, so we need to do it manually
 	stateRoot, err := state.HashTreeRoot(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not get state root: %s", err.Error())
 	}
-	header.StateRoot = hexutil.Encode(stateRoot[:])
+	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
 
 	// Return result
 	result := &structs.LightClientBootstrap{
@@ -152,7 +156,7 @@ func createLightClientUpdate(
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientUpdate, error) {
-	result, err := blockchain.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -210,7 +214,7 @@ func newLightClientFinalityUpdateFromBeaconState(
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientUpdate, error) {
-	result, err := blockchain.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -223,7 +227,7 @@ func newLightClientOptimisticUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState) (*structs.LightClientUpdate, error) {
-	result, err := blockchain.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState)
+	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState)
 	if err != nil {
 		return nil, err
 	}
@@ -236,7 +240,7 @@ func NewLightClientBootstrapFromJSON(bootstrapJSON *structs.LightClientBootstrap
 
 	var err error
 
-	v1Alpha1Header, err := bootstrapJSON.Header.ToConsensus()
+	v1Alpha1Header, err := bootstrapJSON.Header.Beacon.ToConsensus()
 	if err != nil {
 		return nil, err
 	}
@@ -319,7 +323,7 @@ func IsSyncCommitteeUpdate(update *v2.LightClientUpdate) bool {
 }
 
 func IsFinalityUpdate(update *v2.LightClientUpdate) bool {
-	finalityBranch := make([][]byte, blockchain.FinalityBranchNumOfLeaves)
+	finalityBranch := make([][]byte, lightclient.FinalityBranchNumOfLeaves)
 	return !reflect.DeepEqual(update.FinalityBranch, finalityBranch)
 }
 

beacon-chain/rpc/eth/light-client/helpers_test.go

@@ -3,7 +3,8 @@ package lightclient
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
@@ -19,7 +20,7 @@ func createNonEmptySyncCommitteeBranch() [][]byte {
 
 // When the update has finality
 func createNonEmptyFinalityBranch() [][]byte {
-	res := make([][]byte, blockchain.FinalityBranchNumOfLeaves)
+	res := make([][]byte, lightclient.FinalityBranchNumOfLeaves)
 	res[0] = []byte("xyz")
 	return res
 }
@@ -146,7 +147,7 @@ func TestIsBetterUpdate(t *testing.T) {
 				},
 				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
 				SignatureSlot:           9999,
-				FinalityBranch:          make([][]byte, blockchain.FinalityBranchNumOfLeaves),
+				FinalityBranch:          make([][]byte, lightclient.FinalityBranchNumOfLeaves),
 			},
 			newUpdate: &ethpbv2.LightClientUpdate{
 				SyncAggregate: &ethpbv1.SyncAggregate{
@@ -183,7 +184,7 @@ func TestIsBetterUpdate(t *testing.T) {
 				},
 				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
 				SignatureSlot:           9999,
-				FinalityBranch:          make([][]byte, blockchain.FinalityBranchNumOfLeaves),
+				FinalityBranch:          make([][]byte, lightclient.FinalityBranchNumOfLeaves),
 			},
 			expectedResult: false,
 		},

beacon-chain/rpc/eth/light-client/server.go

@@ -2,6 +2,7 @@ package lightclient
 
 import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
 )
 
@@ -9,4 +10,5 @@ type Server struct {
 	Blocker     lookup.Blocker
 	Stater      lookup.Stater
 	HeadFetcher blockchain.HeadFetcher
+	BeaconDB    db.HeadAccessDatabase
 }

beacon-chain/rpc/eth/shared/testing/BUILD.bazel

@@ -3,7 +3,11 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     testonly = True,
-    srcs = ["json.go"],
+    srcs = [
+        "json.go",
+        "json_mainnet.go",
+        "json_minimal.go",  # keep
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared/testing",
     visibility = ["//visibility:public"],
 )

beacon-chain/rpc/eth/shared/testing/json_mainnet.go

@@ -0,0 +1,5 @@
+//go:build !minimal
+
+package testing
+
+const attestationCommitteeBits = "0x0100000000000000"

beacon-chain/rpc/eth/shared/testing/json_minimal.go

@@ -0,0 +1,5 @@
+//go:build minimal
+
+package testing
+
+const attestationCommitteeBits = "0x01"

beacon-chain/rpc/prysm/beacon/BUILD.bazel

@@ -52,10 +52,14 @@ go_test(
         "//beacon-chain/rpc/lookup:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/state/stategen/mock: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",
+        "//encoding/bytesutil:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/rpc/prysm/beacon/handlers.go

@@ -154,3 +154,32 @@ func (s *Server) GetIndividualVotes(w http.ResponseWriter, r *http.Request) {
 	}
 	httputil.WriteJson(w, response)
 }
+
+// GetChainHead retrieves information about the head of the beacon chain from
+// the view of the beacon chain node.
+func (s *Server) GetChainHead(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetChainHead")
+	defer span.End()
+
+	ch, rpcError := s.CoreService.ChainHead(ctx)
+	if rpcError != nil {
+		httputil.HandleError(w, rpcError.Err.Error(), core.ErrorReasonToHTTP(rpcError.Reason))
+		return
+	}
+	response := &structs.ChainHead{
+		HeadSlot:                   fmt.Sprintf("%d", ch.HeadSlot),
+		HeadEpoch:                  fmt.Sprintf("%d", ch.HeadEpoch),
+		HeadBlockRoot:              hexutil.Encode(ch.HeadBlockRoot),
+		FinalizedSlot:              fmt.Sprintf("%d", ch.FinalizedSlot),
+		FinalizedEpoch:             fmt.Sprintf("%d", ch.FinalizedEpoch),
+		FinalizedBlockRoot:         hexutil.Encode(ch.FinalizedBlockRoot),
+		JustifiedSlot:              fmt.Sprintf("%d", ch.JustifiedSlot),
+		JustifiedEpoch:             fmt.Sprintf("%d", ch.JustifiedEpoch),
+		JustifiedBlockRoot:         hexutil.Encode(ch.JustifiedBlockRoot),
+		PreviousJustifiedSlot:      fmt.Sprintf("%d", ch.PreviousJustifiedSlot),
+		PreviousJustifiedEpoch:     fmt.Sprintf("%d", ch.PreviousJustifiedEpoch),
+		PreviousJustifiedBlockRoot: hexutil.Encode(ch.PreviousJustifiedBlockRoot),
+		OptimisticStatus:           ch.OptimisticStatus,
+	}
+	httputil.WriteJson(w, response)
+}

beacon-chain/rpc/prysm/beacon/handlers_test.go

@@ -19,11 +19,15 @@ import (
 	dbTest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	mockstategen "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen/mock"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -227,11 +231,11 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
 	require.NoError(t, beaconState.SetBlockRoots(br))
 	att2.Data.Target.Root = rt[:]
 	att2.Data.BeaconBlockRoot = newRt[:]
-	err = beaconState.AppendPreviousEpochAttestations(&eth.PendingAttestation{
+	err = beaconState.AppendPreviousEpochAttestations(&ethpb.PendingAttestation{
 		Data: att1.Data, AggregationBits: bf, InclusionDelay: 1,
 	})
 	require.NoError(t, err)
-	err = beaconState.AppendCurrentEpochAttestations(&eth.PendingAttestation{
+	err = beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{
 		Data: att2.Data, AggregationBits: bf, InclusionDelay: 1,
 	})
 	require.NoError(t, err)
@@ -658,3 +662,211 @@ func TestServer_GetIndividualVotes_CapellaEndOfEpoch(t *testing.T) {
 	}
 	assert.DeepEqual(t, want, resp, "Unexpected response")
 }
+
+// ensures that if any of the checkpoints are zero-valued, an error will be generated without genesis being present
+func TestServer_GetChainHead_NoGenesis(t *testing.T) {
+	db := dbTest.SetupDB(t)
+
+	s, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.SetSlot(1))
+
+	genBlock := util.NewBeaconBlock()
+	genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
+	util.SaveBlock(t, context.Background(), db, genBlock)
+	gRoot, err := genBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	cases := []struct {
+		name       string
+		zeroSetter func(val *ethpb.Checkpoint) error
+	}{
+		{
+			name:       "zero-value prev justified",
+			zeroSetter: s.SetPreviousJustifiedCheckpoint,
+		},
+		{
+			name:       "zero-value current justified",
+			zeroSetter: s.SetCurrentJustifiedCheckpoint,
+		},
+		{
+			name:       "zero-value finalized",
+			zeroSetter: s.SetFinalizedCheckpoint,
+		},
+	}
+	finalized := &ethpb.Checkpoint{Epoch: 1, Root: gRoot[:]}
+	prevJustified := &ethpb.Checkpoint{Epoch: 2, Root: gRoot[:]}
+	justified := &ethpb.Checkpoint{Epoch: 3, Root: gRoot[:]}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			require.NoError(t, s.SetPreviousJustifiedCheckpoint(prevJustified))
+			require.NoError(t, s.SetCurrentJustifiedCheckpoint(justified))
+			require.NoError(t, s.SetFinalizedCheckpoint(finalized))
+			require.NoError(t, c.zeroSetter(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}))
+		})
+		wsb, err := blocks.NewSignedBeaconBlock(genBlock)
+		require.NoError(t, err)
+		s := &Server{
+			CoreService: &core.Service{
+				BeaconDB:    db,
+				HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
+				FinalizedFetcher: &chainMock.ChainService{
+					FinalizedCheckPoint:         s.FinalizedCheckpoint(),
+					CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
+					PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint(),
+				},
+				OptimisticModeFetcher: &chainMock.ChainService{},
+			},
+		}
+		url := "http://example.com"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetChainHead(writer, request)
+		require.Equal(t, http.StatusInternalServerError, writer.Code)
+		require.StringContains(t, "could not get genesis block", writer.Body.String())
+	}
+}
+
+func TestServer_GetChainHead_NoFinalizedBlock(t *testing.T) {
+	db := dbTest.SetupDB(t)
+
+	bs, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, bs.SetSlot(1))
+	require.NoError(t, bs.SetPreviousJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 3, Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)}))
+	require.NoError(t, bs.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength)}))
+	require.NoError(t, bs.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}))
+
+	genBlock := util.NewBeaconBlock()
+	genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
+	util.SaveBlock(t, context.Background(), db, genBlock)
+	gRoot, err := genBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot))
+
+	wsb, err := blocks.NewSignedBeaconBlock(genBlock)
+	require.NoError(t, err)
+
+	s := &Server{
+		CoreService: &core.Service{
+			BeaconDB:    db,
+			HeadFetcher: &chainMock.ChainService{Block: wsb, State: bs},
+			FinalizedFetcher: &chainMock.ChainService{
+				FinalizedCheckPoint:         bs.FinalizedCheckpoint(),
+				CurrentJustifiedCheckPoint:  bs.CurrentJustifiedCheckpoint(),
+				PreviousJustifiedCheckPoint: bs.PreviousJustifiedCheckpoint()},
+			OptimisticModeFetcher: &chainMock.ChainService{},
+		},
+	}
+
+	url := "http://example.com"
+	request := httptest.NewRequest(http.MethodGet, url, nil)
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetChainHead(writer, request)
+	require.Equal(t, http.StatusInternalServerError, writer.Code)
+	require.StringContains(t, "ould not get finalized block", writer.Body.String())
+}
+
+func TestServer_GetChainHead_NoHeadBlock(t *testing.T) {
+	s := &Server{
+		CoreService: &core.Service{
+			HeadFetcher:           &chainMock.ChainService{Block: nil},
+			OptimisticModeFetcher: &chainMock.ChainService{},
+		},
+	}
+	url := "http://example.com"
+	request := httptest.NewRequest(http.MethodGet, url, nil)
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetChainHead(writer, request)
+	require.Equal(t, http.StatusNotFound, writer.Code)
+	require.StringContains(t, "head block of chain was nil", writer.Body.String())
+}
+
+func TestServer_GetChainHead(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	params.OverrideBeaconConfig(params.MinimalSpecConfig())
+
+	db := dbTest.SetupDB(t)
+	genBlock := util.NewBeaconBlock()
+	genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
+	util.SaveBlock(t, context.Background(), db, genBlock)
+	gRoot, err := genBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot))
+
+	finalizedBlock := util.NewBeaconBlock()
+	finalizedBlock.Block.Slot = 1
+	finalizedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
+	util.SaveBlock(t, context.Background(), db, finalizedBlock)
+	fRoot, err := finalizedBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	justifiedBlock := util.NewBeaconBlock()
+	justifiedBlock.Block.Slot = 2
+	justifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength)
+	util.SaveBlock(t, context.Background(), db, justifiedBlock)
+	jRoot, err := justifiedBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	prevJustifiedBlock := util.NewBeaconBlock()
+	prevJustifiedBlock.Block.Slot = 3
+	prevJustifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)
+	util.SaveBlock(t, context.Background(), db, prevJustifiedBlock)
+	pjRoot, err := prevJustifiedBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Slot:                        1,
+		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 3, Root: pjRoot[:]},
+		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{Epoch: 2, Root: jRoot[:]},
+		FinalizedCheckpoint:         &ethpb.Checkpoint{Epoch: 1, Root: fRoot[:]},
+	})
+	require.NoError(t, err)
+
+	b := util.NewBeaconBlock()
+	b.Block.Slot, err = slots.EpochStart(st.PreviousJustifiedCheckpoint().Epoch)
+	require.NoError(t, err)
+	b.Block.Slot++
+	wsb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	s := &Server{
+		CoreService: &core.Service{
+			BeaconDB:              db,
+			HeadFetcher:           &chainMock.ChainService{Block: wsb, State: st},
+			OptimisticModeFetcher: &chainMock.ChainService{},
+			FinalizedFetcher: &chainMock.ChainService{
+				FinalizedCheckPoint:         st.FinalizedCheckpoint(),
+				CurrentJustifiedCheckPoint:  st.CurrentJustifiedCheckpoint(),
+				PreviousJustifiedCheckPoint: st.PreviousJustifiedCheckpoint()},
+		},
+	}
+
+	url := "http://example.com"
+	request := httptest.NewRequest(http.MethodGet, url, nil)
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetChainHead(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+
+	var ch *structs.ChainHead
+	err = json.NewDecoder(writer.Body).Decode(&ch)
+	require.NoError(t, err)
+
+	assert.Equal(t, "3", ch.PreviousJustifiedEpoch, "Unexpected PreviousJustifiedEpoch")
+	assert.Equal(t, "2", ch.JustifiedEpoch, "Unexpected JustifiedEpoch")
+	assert.Equal(t, "1", ch.FinalizedEpoch, "Unexpected FinalizedEpoch")
+	assert.Equal(t, "24", ch.PreviousJustifiedSlot, "Unexpected PreviousJustifiedSlot")
+	assert.Equal(t, "16", ch.JustifiedSlot, "Unexpected JustifiedSlot")
+	assert.Equal(t, "8", ch.FinalizedSlot, "Unexpected FinalizedSlot")
+	assert.DeepEqual(t, hexutil.Encode(pjRoot[:]), ch.PreviousJustifiedBlockRoot, "Unexpected PreviousJustifiedBlockRoot")
+	assert.DeepEqual(t, hexutil.Encode(jRoot[:]), ch.JustifiedBlockRoot, "Unexpected JustifiedBlockRoot")
+	assert.DeepEqual(t, hexutil.Encode(fRoot[:]), ch.FinalizedBlockRoot, "Unexpected FinalizedBlockRoot")
+	assert.Equal(t, false, ch.OptimisticStatus)
+}

beacon-chain/rpc/prysm/v1alpha1/beacon/BUILD.bazel

@@ -19,15 +19,12 @@ go_library(
         "//api/pagination:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/execution:go_default_library",

beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go

@@ -7,13 +7,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/pagination"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filters"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
-	"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/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -244,91 +243,9 @@ func (bs *Server) listBlocksForGenesis(ctx context.Context, _ *ethpb.ListBlocksR
 // the most recent finalized and justified slots.
 // DEPRECATED: This endpoint is superseded by the /eth/v1/beacon API endpoint
 func (bs *Server) GetChainHead(ctx context.Context, _ *emptypb.Empty) (*ethpb.ChainHead, error) {
-	return bs.chainHeadRetrieval(ctx)
-}
-
-// Retrieve chain head information from the DB and the current beacon state.
-func (bs *Server) chainHeadRetrieval(ctx context.Context) (*ethpb.ChainHead, error) {
-	headBlock, err := bs.HeadFetcher.HeadBlock(ctx)
-	if err != nil {
-		return nil, status.Error(codes.Internal, "Could not get head block")
-	}
-	optimisticStatus, err := bs.OptimisticModeFetcher.IsOptimistic(ctx)
-	if err != nil {
-		return nil, status.Error(codes.Internal, "Could not get optimistic status")
-	}
-	if err := consensusblocks.BeaconBlockIsNil(headBlock); err != nil {
-		return nil, status.Errorf(codes.NotFound, "Head block of chain was nil: %v", err)
-	}
-	headBlockRoot, err := headBlock.Block().HashTreeRoot()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get head block root: %v", err)
-	}
-
-	validGenesis := false
-	validateCP := func(cp *ethpb.Checkpoint, name string) error {
-		if bytesutil.ToBytes32(cp.Root) == params.BeaconConfig().ZeroHash && cp.Epoch == 0 {
-			if validGenesis {
-				return nil
-			}
-			// Retrieve genesis block in the event we have genesis checkpoints.
-			genBlock, err := bs.BeaconDB.GenesisBlock(ctx)
-			if err != nil || consensusblocks.BeaconBlockIsNil(genBlock) != nil {
-				return status.Error(codes.Internal, "Could not get genesis block")
-			}
-			validGenesis = true
-			return nil
-		}
-		b, err := bs.BeaconDB.Block(ctx, bytesutil.ToBytes32(cp.Root))
-		if err != nil {
-			return status.Errorf(codes.Internal, "Could not get %s block: %v", name, err)
-		}
-		if err := consensusblocks.BeaconBlockIsNil(b); err != nil {
-			return status.Errorf(codes.Internal, "Could not get %s block: %v", name, err)
-		}
-		return nil
-	}
-
-	finalizedCheckpoint := bs.FinalizationFetcher.FinalizedCheckpt()
-	if err := validateCP(finalizedCheckpoint, "finalized"); err != nil {
-		return nil, err
-	}
-
-	justifiedCheckpoint := bs.FinalizationFetcher.CurrentJustifiedCheckpt()
-	if err := validateCP(justifiedCheckpoint, "justified"); err != nil {
-		return nil, err
-	}
-
-	prevJustifiedCheckpoint := bs.FinalizationFetcher.PreviousJustifiedCheckpt()
-	if err := validateCP(prevJustifiedCheckpoint, "prev justified"); err != nil {
-		return nil, err
-	}
-
-	fSlot, err := slots.EpochStart(finalizedCheckpoint.Epoch)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get epoch start slot from finalized checkpoint epoch")
-	}
-	jSlot, err := slots.EpochStart(justifiedCheckpoint.Epoch)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get epoch start slot from justified checkpoint epoch")
-	}
-	pjSlot, err := slots.EpochStart(prevJustifiedCheckpoint.Epoch)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get epoch start slot from prev justified checkpoint epoch")
-	}
-	return &ethpb.ChainHead{
-		HeadSlot:                   headBlock.Block().Slot(),
-		HeadEpoch:                  slots.ToEpoch(headBlock.Block().Slot()),
-		HeadBlockRoot:              headBlockRoot[:],
-		FinalizedSlot:              fSlot,
-		FinalizedEpoch:             finalizedCheckpoint.Epoch,
-		FinalizedBlockRoot:         finalizedCheckpoint.Root,
-		JustifiedSlot:              jSlot,
-		JustifiedEpoch:             justifiedCheckpoint.Epoch,
-		JustifiedBlockRoot:         justifiedCheckpoint.Root,
-		PreviousJustifiedSlot:      pjSlot,
-		PreviousJustifiedEpoch:     prevJustifiedCheckpoint.Epoch,
-		PreviousJustifiedBlockRoot: prevJustifiedCheckpoint.Root,
-		OptimisticStatus:           optimisticStatus,
-	}, nil
+	ch, err := bs.CoreService.ChainHead(ctx)
+	if err != nil {
+		return nil, status.Errorf(core.ErrorReasonToGRPC(err.Reason), "Could not retrieve chain head: %v", err.Err)
+	}
+	return ch, nil
 }

beacon-chain/rpc/prysm/v1alpha1/beacon/blocks_test.go

@@ -8,6 +8,7 @@ import (
 
 	chainMock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	dbTest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
@@ -68,16 +69,19 @@ func TestServer_GetChainHead_NoGenesis(t *testing.T) {
 		wsb, err := blocks.NewSignedBeaconBlock(genBlock)
 		require.NoError(t, err)
 		bs := &Server{
-			BeaconDB:    db,
-			HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
-			FinalizationFetcher: &chainMock.ChainService{
-				FinalizedCheckPoint:         s.FinalizedCheckpoint(),
-				CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
-				PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
-			OptimisticModeFetcher: &chainMock.ChainService{},
+			CoreService: &core.Service{
+				BeaconDB:    db,
+				HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
+				FinalizedFetcher: &chainMock.ChainService{
+					FinalizedCheckPoint:         s.FinalizedCheckpoint(),
+					CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
+					PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint(),
+				},
+				OptimisticModeFetcher: &chainMock.ChainService{},
+			},
 		}
 		_, err = bs.GetChainHead(context.Background(), nil)
-		require.ErrorContains(t, "Could not get genesis block", err)
+		require.ErrorContains(t, "could not get genesis block", err)
 	}
 }
 
@@ -102,26 +106,30 @@ func TestServer_GetChainHead_NoFinalizedBlock(t *testing.T) {
 	require.NoError(t, err)
 
 	bs := &Server{
-		BeaconDB:    db,
-		HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
-		FinalizationFetcher: &chainMock.ChainService{
-			FinalizedCheckPoint:         s.FinalizedCheckpoint(),
-			CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
-			PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
-		OptimisticModeFetcher: &chainMock.ChainService{},
+		CoreService: &core.Service{
+			BeaconDB:    db,
+			HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
+			FinalizedFetcher: &chainMock.ChainService{
+				FinalizedCheckPoint:         s.FinalizedCheckpoint(),
+				CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
+				PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
+			OptimisticModeFetcher: &chainMock.ChainService{},
+		},
 	}
 
 	_, err = bs.GetChainHead(context.Background(), nil)
-	require.ErrorContains(t, "Could not get finalized block", err)
+	require.ErrorContains(t, "could not get finalized block", err)
 }
 
 func TestServer_GetChainHead_NoHeadBlock(t *testing.T) {
 	bs := &Server{
-		HeadFetcher:           &chainMock.ChainService{Block: nil},
-		OptimisticModeFetcher: &chainMock.ChainService{},
+		CoreService: &core.Service{
+			HeadFetcher:           &chainMock.ChainService{Block: nil},
+			OptimisticModeFetcher: &chainMock.ChainService{},
+		},
 	}
 	_, err := bs.GetChainHead(context.Background(), nil)
-	assert.ErrorContains(t, "Head block of chain was nil", err)
+	assert.ErrorContains(t, "head block of chain was nil", err)
 }
 
 func TestServer_GetChainHead(t *testing.T) {
@@ -172,13 +180,15 @@ func TestServer_GetChainHead(t *testing.T) {
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
 	bs := &Server{
-		BeaconDB:              db,
-		HeadFetcher:           &chainMock.ChainService{Block: wsb, State: s},
-		OptimisticModeFetcher: &chainMock.ChainService{},
-		FinalizationFetcher: &chainMock.ChainService{
-			FinalizedCheckPoint:         s.FinalizedCheckpoint(),
-			CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
-			PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
+		CoreService: &core.Service{
+			BeaconDB:              db,
+			HeadFetcher:           &chainMock.ChainService{Block: wsb, State: s},
+			OptimisticModeFetcher: &chainMock.ChainService{},
+			FinalizedFetcher: &chainMock.ChainService{
+				FinalizedCheckPoint:         s.FinalizedCheckpoint(),
+				CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
+				PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
+		},
 	}
 
 	head, err := bs.GetChainHead(context.Background(), nil)

beacon-chain/rpc/prysm/v1alpha1/beacon/validators.go

@@ -7,12 +7,9 @@ import (
 	"strconv"
 
 	"github.com/prysmaticlabs/prysm/v5/api/pagination"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
@@ -392,7 +389,7 @@ func (bs *Server) GetValidator(
 func (bs *Server) GetValidatorActiveSetChanges(
 	ctx context.Context, req *ethpb.GetValidatorActiveSetChangesRequest,
 ) (*ethpb.ActiveSetChanges, error) {
-	currentEpoch := slots.ToEpoch(bs.GenesisTimeFetcher.CurrentSlot())
+	currentEpoch := slots.ToEpoch(bs.CoreService.GenesisTimeFetcher.CurrentSlot())
 
 	var requestedEpoch primitives.Epoch
 	switch q := req.QueryFilter.(type) {
@@ -403,72 +400,12 @@ func (bs *Server) GetValidatorActiveSetChanges(
 	default:
 		requestedEpoch = currentEpoch
 	}
-	if requestedEpoch > currentEpoch {
-		return nil, status.Errorf(
-			codes.InvalidArgument,
-			errEpoch,
-			currentEpoch,
-			requestedEpoch,
-		)
-	}
 
-	s, err := slots.EpochStart(requestedEpoch)
+	as, err := bs.CoreService.ValidatorActiveSetChanges(ctx, requestedEpoch)
 	if err != nil {
-		return nil, err
+		return nil, status.Errorf(core.ErrorReasonToGRPC(err.Reason), "Could not retrieve validator active set changes: %v", err.Err)
 	}
-	requestedState, err := bs.ReplayerBuilder.ReplayerForSlot(s).ReplayBlocks(ctx)
-	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", s, err))
-	}
-
-	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, requestedState, coreTime.CurrentEpoch(requestedState))
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get active validator count: %v", err)
-	}
-	vs := requestedState.Validators()
-	activatedIndices := validators.ActivatedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs)
-	exitedIndices, err := validators.ExitedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs, activeValidatorCount)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not determine exited validator indices: %v", err)
-	}
-	slashedIndices := validators.SlashedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs)
-	ejectedIndices, err := validators.EjectedValidatorIndices(coreTime.CurrentEpoch(requestedState), vs, activeValidatorCount)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not determine ejected validator indices: %v", err)
-	}
-
-	// Retrieve public keys for the indices.
-	activatedKeys := make([][]byte, len(activatedIndices))
-	exitedKeys := make([][]byte, len(exitedIndices))
-	slashedKeys := make([][]byte, len(slashedIndices))
-	ejectedKeys := make([][]byte, len(ejectedIndices))
-	for i, idx := range activatedIndices {
-		pubkey := requestedState.PubkeyAtIndex(idx)
-		activatedKeys[i] = pubkey[:]
-	}
-	for i, idx := range exitedIndices {
-		pubkey := requestedState.PubkeyAtIndex(idx)
-		exitedKeys[i] = pubkey[:]
-	}
-	for i, idx := range slashedIndices {
-		pubkey := requestedState.PubkeyAtIndex(idx)
-		slashedKeys[i] = pubkey[:]
-	}
-	for i, idx := range ejectedIndices {
-		pubkey := requestedState.PubkeyAtIndex(idx)
-		ejectedKeys[i] = pubkey[:]
-	}
-	return &ethpb.ActiveSetChanges{
-		Epoch:               requestedEpoch,
-		ActivatedPublicKeys: activatedKeys,
-		ActivatedIndices:    activatedIndices,
-		ExitedPublicKeys:    exitedKeys,
-		ExitedIndices:       exitedIndices,
-		SlashedPublicKeys:   slashedKeys,
-		SlashedIndices:      slashedIndices,
-		EjectedPublicKeys:   ejectedKeys,
-		EjectedIndices:      ejectedIndices,
-	}, nil
+	return as, nil
 }
 
 // GetValidatorParticipation retrieves the validator participation information for a given epoch,
@@ -477,7 +414,7 @@ func (bs *Server) GetValidatorActiveSetChanges(
 func (bs *Server) GetValidatorParticipation(
 	ctx context.Context, req *ethpb.GetValidatorParticipationRequest,
 ) (*ethpb.ValidatorParticipationResponse, error) {
-	currentSlot := bs.GenesisTimeFetcher.CurrentSlot()
+	currentSlot := bs.CoreService.GenesisTimeFetcher.CurrentSlot()
 	currentEpoch := slots.ToEpoch(currentSlot)
 
 	var requestedEpoch primitives.Epoch
@@ -489,79 +426,11 @@ func (bs *Server) GetValidatorParticipation(
 	default:
 		requestedEpoch = currentEpoch
 	}
-
-	if requestedEpoch > currentEpoch {
-		return nil, status.Errorf(
-			codes.InvalidArgument,
-			"Cannot retrieve information about an epoch greater than current epoch, current epoch %d, requesting %d",
-			currentEpoch,
-			requestedEpoch,
-		)
-	}
-	// Use the last slot of requested epoch to obtain current and previous epoch attestations.
-	// This ensures that we don't miss previous attestations when input requested epochs.
-	endSlot, err := slots.EpochEnd(requestedEpoch)
+	vp, err := bs.CoreService.ValidatorParticipation(ctx, requestedEpoch)
 	if err != nil {
-		return nil, err
+		return nil, status.Errorf(core.ErrorReasonToGRPC(err.Reason), "Could not retrieve validator participation: %v", err.Err)
 	}
-	// Get as close as we can to the end of the current epoch without going past the current slot.
-	// The above check ensures a future *epoch* isn't requested, but the end slot of the requested epoch could still
-	// be past the current slot. In that case, use the current slot as the best approximation of the requested epoch.
-	// Replayer will make sure the slot ultimately used is canonical.
-	if endSlot > currentSlot {
-		endSlot = currentSlot
-	}
-
-	// ReplayerBuilder ensures that a canonical chain is followed to the slot
-	beaconState, err := bs.ReplayerBuilder.ReplayerForSlot(endSlot).ReplayBlocks(ctx)
-	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", endSlot, err))
-	}
-	var v []*precompute.Validator
-	var b *precompute.Balance
-
-	if beaconState.Version() == version.Phase0 {
-		v, b, err = precompute.New(ctx, beaconState)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not set up pre compute instance: %v", err)
-		}
-		_, b, err = precompute.ProcessAttestations(ctx, beaconState, v, b)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not pre compute attestations: %v", err)
-		}
-	} else if beaconState.Version() >= version.Altair {
-		v, b, err = altair.InitializePrecomputeValidators(ctx, beaconState)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not set up altair pre compute instance: %v", err)
-		}
-		_, b, err = altair.ProcessEpochParticipation(ctx, beaconState, b, v)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not pre compute attestations: %v", err)
-		}
-	} else {
-		return nil, status.Errorf(codes.Internal, "Invalid state type retrieved with a version of %d", beaconState.Version())
-	}
-
-	cp := bs.FinalizationFetcher.FinalizedCheckpt()
-	p := &ethpb.ValidatorParticipationResponse{
-		Epoch:     requestedEpoch,
-		Finalized: requestedEpoch <= cp.Epoch,
-		Participation: &ethpb.ValidatorParticipation{
-			// TODO(7130): Remove these three deprecated fields.
-			GlobalParticipationRate:          float32(b.PrevEpochTargetAttested) / float32(b.ActivePrevEpoch),
-			VotedEther:                       b.PrevEpochTargetAttested,
-			EligibleEther:                    b.ActivePrevEpoch,
-			CurrentEpochActiveGwei:           b.ActiveCurrentEpoch,
-			CurrentEpochAttestingGwei:        b.CurrentEpochAttested,
-			CurrentEpochTargetAttestingGwei:  b.CurrentEpochTargetAttested,
-			PreviousEpochActiveGwei:          b.ActivePrevEpoch,
-			PreviousEpochAttestingGwei:       b.PrevEpochAttested,
-			PreviousEpochTargetAttestingGwei: b.PrevEpochTargetAttested,
-			PreviousEpochHeadAttestingGwei:   b.PrevEpochHeadAttested,
-		},
-	}
-
-	return p, nil
+	return vp, nil
 }
 
 // GetValidatorQueue retrieves the current validator queue information.

beacon-chain/rpc/prysm/v1alpha1/beacon/validators_test.go

@@ -54,11 +54,13 @@ func TestServer_GetValidatorActiveSetChanges_CannotRequestFutureEpoch(t *testing
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(0))
 	bs := &Server{
-		GenesisTimeFetcher: &mock.ChainService{},
-		HeadFetcher: &mock.ChainService{
-			State: st,
+		CoreService: &core.Service{
+			BeaconDB:           beaconDB,
+			GenesisTimeFetcher: &mock.ChainService{},
+			HeadFetcher: &mock.ChainService{
+				State: st,
+			},
 		},
-		BeaconDB: beaconDB,
 	}
 
 	wanted := errNoEpochInfoError
@@ -66,7 +68,7 @@ func TestServer_GetValidatorActiveSetChanges_CannotRequestFutureEpoch(t *testing
 		ctx,
 		&ethpb.GetValidatorActiveSetChangesRequest{
 			QueryFilter: &ethpb.GetValidatorActiveSetChangesRequest_Epoch{
-				Epoch: slots.ToEpoch(bs.GenesisTimeFetcher.CurrentSlot()) + 1,
+				Epoch: slots.ToEpoch(bs.CoreService.GenesisTimeFetcher.CurrentSlot()) + 1,
 			},
 		},
 	)
@@ -1029,7 +1031,7 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
 
 	ctx := context.Background()
 	slot := primitives.Slot(0)
-	epochs := 10
+	epochs := primitives.Epoch(10)
 	numVals := uint64(10)
 
 	beaconDB := dbTest.SetupDB(t)
@@ -1065,7 +1067,7 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
 	}
 	res, err := bs.ListValidators(context.Background(), req)
 	require.NoError(t, err)
-	assert.Equal(t, epochs, len(res.ValidatorList))
+	assert.Equal(t, int(numVals), len(res.ValidatorList))
 
 	vals := st.Validators()
 	want := make([]*ethpb.Validators_ValidatorContainer, 0)
@@ -1077,7 +1079,7 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
 	}
 	req = &ethpb.ListValidatorsRequest{
 		QueryFilter: &ethpb.ListValidatorsRequest_Epoch{
-			Epoch: 10,
+			Epoch: epochs,
 		},
 	}
 	res, err = bs.ListValidators(context.Background(), req)
@@ -1283,10 +1285,12 @@ func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
 
 	bs := &Server{
-		FinalizationFetcher: &mock.ChainService{
-			FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
+		CoreService: &core.Service{
+			FinalizedFetcher: &mock.ChainService{
+				FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
+			},
+			GenesisTimeFetcher: &mock.ChainService{},
 		},
-		GenesisTimeFetcher: &mock.ChainService{},
 	}
 	addDefaultReplayerBuilder(bs, beaconDB)
 	res, err := bs.GetValidatorActiveSetChanges(ctx, &ethpb.GetValidatorActiveSetChangesRequest{
@@ -1476,27 +1480,25 @@ func TestServer_GetValidatorQueue_PendingExit(t *testing.T) {
 }
 
 func TestServer_GetValidatorParticipation_CannotRequestFutureEpoch(t *testing.T) {
-	beaconDB := dbTest.SetupDB(t)
-
 	ctx := context.Background()
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(0))
 	bs := &Server{
-		BeaconDB: beaconDB,
-		HeadFetcher: &mock.ChainService{
-			State: headState,
+		CoreService: &core.Service{
+			HeadFetcher: &mock.ChainService{
+				State: headState,
+			},
+			GenesisTimeFetcher: &mock.ChainService{},
 		},
-		GenesisTimeFetcher: &mock.ChainService{},
-		StateGen:           stategen.New(beaconDB, doublylinkedtree.New()),
 	}
 
-	wanted := "Cannot retrieve information about an epoch"
+	wanted := "cannot retrieve information about an epoch"
 	_, err = bs.GetValidatorParticipation(
 		ctx,
 		&ethpb.GetValidatorParticipationRequest{
 			QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{
-				Epoch: slots.ToEpoch(bs.GenesisTimeFetcher.CurrentSlot()) + 1,
+				Epoch: slots.ToEpoch(bs.CoreService.GenesisTimeFetcher.CurrentSlot()) + 1,
 			},
 		},
 	)
@@ -1549,18 +1551,20 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
 	m := &mock.ChainService{State: headState}
 	offset := int64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	bs := &Server{
-		BeaconDB:    beaconDB,
-		HeadFetcher: m,
-		StateGen:    stategen.New(beaconDB, doublylinkedtree.New()),
-		GenesisTimeFetcher: &mock.ChainService{
-			Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB, doublylinkedtree.New()),
+		CoreService: &core.Service{
+			HeadFetcher: m,
+			GenesisTimeFetcher: &mock.ChainService{
+				Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
+			},
+			FinalizedFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 		},
 		CanonicalFetcher: &mock.ChainService{
 			CanonicalRoots: map[[32]byte]bool{
 				bRoot: true,
 			},
 		},
-		FinalizationFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 	}
 	addDefaultReplayerBuilder(bs, beaconDB)
 
@@ -1628,18 +1632,20 @@ func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
 	m := &mock.ChainService{State: headState}
 	offset := int64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	bs := &Server{
-		BeaconDB:    beaconDB,
-		HeadFetcher: m,
-		StateGen:    stategen.New(beaconDB, doublylinkedtree.New()),
-		GenesisTimeFetcher: &mock.ChainService{
-			Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB, doublylinkedtree.New()),
+		CoreService: &core.Service{
+			HeadFetcher: m,
+			GenesisTimeFetcher: &mock.ChainService{
+				Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
+			},
+			FinalizedFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 		},
 		CanonicalFetcher: &mock.ChainService{
 			CanonicalRoots: map[[32]byte]bool{
 				bRoot: true,
 			},
 		},
-		FinalizationFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 	}
 	addDefaultReplayerBuilder(bs, beaconDB)
 
@@ -1744,13 +1750,15 @@ func runGetValidatorParticipationCurrentAndPrevEpoch(t *testing.T, genState stat
 	m := &mock.ChainService{State: genState}
 	offset := int64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	bs := &Server{
-		BeaconDB:    beaconDB,
+		BeaconDB: beaconDB,
+		CoreService: &core.Service{
+			GenesisTimeFetcher: &mock.ChainService{
+				Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
+			},
+			FinalizedFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
+		},
 		HeadFetcher: m,
 		StateGen:    stategen.New(beaconDB, doublylinkedtree.New()),
-		GenesisTimeFetcher: &mock.ChainService{
-			Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
-		},
-		FinalizationFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 	}
 	addDefaultReplayerBuilder(bs, beaconDB)
 

beacon-chain/rpc/prysm/v1alpha1/node/server_test.go

@@ -128,13 +128,12 @@ func TestNodeServer_GetPeer(t *testing.T) {
 	}
 	ethpb.RegisterNodeServer(server, ns)
 	reflection.Register(server)
-	firstPeer := peersProvider.Peers().All()[0]
 
-	res, err := ns.GetPeer(context.Background(), &ethpb.PeerRequest{PeerId: firstPeer.String()})
+	res, err := ns.GetPeer(context.Background(), &ethpb.PeerRequest{PeerId: mockP2p.MockRawPeerId0})
 	require.NoError(t, err)
-	assert.Equal(t, firstPeer.String(), res.PeerId, "Unexpected peer ID")
+	assert.Equal(t, "16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR" /* first peer's raw id */, res.PeerId, "Unexpected peer ID")
 	assert.Equal(t, int(ethpb.PeerDirection_INBOUND), int(res.Direction), "Expected 1st peer to be an inbound connection")
-	assert.Equal(t, ethpb.ConnectionState_CONNECTED, res.ConnectionState, "Expected peer to be connected")
+	assert.Equal(t, int(ethpb.ConnectionState_CONNECTED), int(res.ConnectionState), "Expected peer to be connected")
 }
 
 func TestNodeServer_ListPeers(t *testing.T) {
@@ -149,8 +148,25 @@ func TestNodeServer_ListPeers(t *testing.T) {
 	res, err := ns.ListPeers(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
 	assert.Equal(t, 2, len(res.Peers))
-	assert.Equal(t, int(ethpb.PeerDirection_INBOUND), int(res.Peers[0].Direction))
-	assert.Equal(t, ethpb.PeerDirection_OUTBOUND, res.Peers[1].Direction)
+
+	var (
+		firstPeer  *ethpb.Peer
+		secondPeer *ethpb.Peer
+	)
+
+	for _, p := range res.Peers {
+		if p.PeerId == mockP2p.MockRawPeerId0 {
+			firstPeer = p
+		}
+		if p.PeerId == mockP2p.MockRawPeerId1 {
+			secondPeer = p
+		}
+	}
+
+	assert.NotNil(t, firstPeer)
+	assert.NotNil(t, secondPeer)
+	assert.Equal(t, int(ethpb.PeerDirection_INBOUND), int(firstPeer.Direction))
+	assert.Equal(t, int(ethpb.PeerDirection_OUTBOUND), int(secondPeer.Direction))
 }
 
 func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {

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

@@ -23,49 +23,10 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("slot", int64(req.Slot)))
 
-	if vs.SyncChecker.Syncing() {
-		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
-	}
-
-	// An optimistic validator MUST NOT participate in attestation
-	// (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
-	if err := vs.optimisticStatus(ctx); err != nil {
-		return nil, err
-	}
-
-	st, err := vs.HeadFetcher.HeadStateReadOnly(ctx)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
-	}
-
-	validatorIndex, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
-	if !exists {
-		return nil, status.Error(codes.Internal, "Could not locate validator index in DB")
-	}
-
-	epoch := slots.ToEpoch(req.Slot)
-	activeValidatorIndices, err := helpers.ActiveValidatorIndices(ctx, st, epoch)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get validators: %v", err)
-	}
-	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get seed: %v", err)
-	}
-	committee, err := helpers.BeaconCommittee(ctx, activeValidatorIndices, seed, req.Slot, req.CommitteeIndex)
+	indexInCommittee, validatorIndex, err := vs.processAggregateSelection(ctx, req)
 	if err != nil {
 		return nil, err
 	}
-
-	// Check if the validator is an aggregator
-	isAggregator, err := helpers.IsAggregator(uint64(len(committee)), req.SlotSignature)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get aggregator status: %v", err)
-	}
-	if !isAggregator {
-		return nil, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
-	}
-
 	atts := vs.AttPool.AggregatedAttestationsBySlotIndex(ctx, req.Slot, req.CommitteeIndex)
 	// Filter out the best aggregated attestation (ie. the one with the most aggregated bits).
 	if len(atts) == 0 {
@@ -74,14 +35,6 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 			return nil, status.Errorf(codes.NotFound, "Could not find attestation for slot and committee in pool")
 		}
 	}
-
-	var indexInCommittee uint64
-	for i, idx := range committee {
-		if idx == validatorIndex {
-			indexInCommittee = uint64(i)
-		}
-	}
-
 	best := bestAggregate(atts, req.CommitteeIndex, indexInCommittee)
 	attAndProof := &ethpb.AggregateAttestationAndProof{
 		Aggregate:       best,
@@ -102,49 +55,10 @@ func (vs *Server) SubmitAggregateSelectionProofElectra(
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("slot", int64(req.Slot)))
 
-	if vs.SyncChecker.Syncing() {
-		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
-	}
-
-	// An optimistic validator MUST NOT participate in attestation
-	// (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
-	if err := vs.optimisticStatus(ctx); err != nil {
-		return nil, err
-	}
-
-	st, err := vs.HeadFetcher.HeadStateReadOnly(ctx)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
-	}
-
-	validatorIndex, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
-	if !exists {
-		return nil, status.Error(codes.Internal, "Could not locate validator index in DB")
-	}
-
-	epoch := slots.ToEpoch(req.Slot)
-	activeValidatorIndices, err := helpers.ActiveValidatorIndices(ctx, st, epoch)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get validators: %v", err)
-	}
-	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get seed: %v", err)
-	}
-	committee, err := helpers.BeaconCommittee(ctx, activeValidatorIndices, seed, req.Slot, req.CommitteeIndex)
+	indexInCommittee, validatorIndex, err := vs.processAggregateSelection(ctx, req)
 	if err != nil {
 		return nil, err
 	}
-
-	// Check if the validator is an aggregator
-	isAggregator, err := helpers.IsAggregator(uint64(len(committee)), req.SlotSignature)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get aggregator status: %v", err)
-	}
-	if !isAggregator {
-		return nil, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
-	}
-
 	atts := vs.AttPool.AggregatedAttestationsBySlotIndexElectra(ctx, req.Slot, req.CommitteeIndex)
 	if len(atts) == 0 {
 		atts = vs.AttPool.UnaggregatedAttestationsBySlotIndexElectra(ctx, req.Slot, req.CommitteeIndex)
@@ -152,6 +66,58 @@ func (vs *Server) SubmitAggregateSelectionProofElectra(
 			return nil, status.Errorf(codes.NotFound, "No attestations found in pool")
 		}
 	}
+	best := bestAggregate(atts, req.CommitteeIndex, indexInCommittee)
+	attAndProof := &ethpb.AggregateAttestationAndProofElectra{
+		Aggregate:       best,
+		SelectionProof:  req.SlotSignature,
+		AggregatorIndex: validatorIndex,
+	}
+	return &ethpb.AggregateSelectionElectraResponse{AggregateAndProof: attAndProof}, nil
+}
+
+func (vs *Server) processAggregateSelection(ctx context.Context, req *ethpb.AggregateSelectionRequest) (uint64, primitives.ValidatorIndex, error) {
+	if vs.SyncChecker.Syncing() {
+		return 0, 0, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
+	}
+
+	// An optimistic validator MUST NOT participate in attestation
+	// (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
+	if err := vs.optimisticStatus(ctx); err != nil {
+		return 0, 0, err
+	}
+
+	st, err := vs.HeadFetcher.HeadStateReadOnly(ctx)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
+	}
+
+	validatorIndex, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
+	if !exists {
+		return 0, 0, status.Error(codes.Internal, "Could not locate validator index in DB")
+	}
+
+	epoch := slots.ToEpoch(req.Slot)
+	activeValidatorIndices, err := helpers.ActiveValidatorIndices(ctx, st, epoch)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not get validators: %v", err)
+	}
+	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not get seed: %v", err)
+	}
+	committee, err := helpers.BeaconCommittee(ctx, activeValidatorIndices, seed, req.Slot, req.CommitteeIndex)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// Check if the validator is an aggregator
+	isAggregator, err := helpers.IsAggregator(uint64(len(committee)), req.SlotSignature)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not get aggregator status: %v", err)
+	}
+	if !isAggregator {
+		return 0, 0, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
+	}
 
 	var indexInCommittee uint64
 	for i, idx := range committee {
@@ -159,14 +125,7 @@ func (vs *Server) SubmitAggregateSelectionProofElectra(
 			indexInCommittee = uint64(i)
 		}
 	}
-
-	best := bestAggregate(atts, req.CommitteeIndex, indexInCommittee)
-	attAndProof := &ethpb.AggregateAttestationAndProofElectra{
-		Aggregate:       best,
-		SelectionProof:  req.SlotSignature,
-		AggregatorIndex: validatorIndex,
-	}
-	return &ethpb.AggregateSelectionElectraResponse{AggregateAndProof: attAndProof}, nil
+	return indexInCommittee, validatorIndex, nil
 }
 
 // SubmitSignedAggregateSelectionProof is called by a validator to broadcast a signed

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

@@ -66,18 +66,12 @@ func (vs *Server) ProposeAttestationElectra(ctx context.Context, att *ethpb.Atte
 	ctx, span := trace.StartSpan(ctx, "AttesterServer.ProposeAttestationElectra")
 	defer span.End()
 
-	if att.GetData().CommitteeIndex != 0 {
-		return nil, status.Errorf(codes.InvalidArgument, "Committee index must be set to 0")
-	}
-	committeeIndices := helpers.CommitteeIndices(att.CommitteeBits)
-	if len(committeeIndices) == 0 {
-		return nil, status.Errorf(codes.InvalidArgument, "Committee bits has no bit set")
-	}
-	if len(committeeIndices) > 1 {
-		return nil, status.Errorf(codes.InvalidArgument, "Committee bits has more than one bit set")
+	committeeIndex, err := att.GetCommitteeIndex()
+	if err != nil {
+		return nil, err
 	}
 
-	resp, err := vs.proposeAtt(ctx, att, committeeIndices[0])
+	resp, err := vs.proposeAtt(ctx, att, committeeIndex)
 	if err != nil {
 		return nil, err
 	}

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

@@ -113,7 +113,7 @@ func TestProposeAttestation(t *testing.T) {
 			CommitteeBits: cb,
 		}
 		_, err = attesterServer.ProposeAttestationElectra(context.Background(), req)
-		assert.ErrorContains(t, "Committee index must be set to 0", err)
+		assert.ErrorContains(t, "attestation data's committee index must be 0 but was 1", err)
 	})
 	t.Run("Electra - no committee bit set", func(t *testing.T) {
 		state, err := util.NewBeaconStateElectra()
@@ -131,7 +131,7 @@ func TestProposeAttestation(t *testing.T) {
 			CommitteeBits: primitives.NewAttestationCommitteeBits(),
 		}
 		_, err = attesterServer.ProposeAttestationElectra(context.Background(), req)
-		assert.ErrorContains(t, "Committee bits has no bit set", err)
+		assert.ErrorContains(t, "exactly 1 committee index must be set but 0 were set", err)
 	})
 	t.Run("Electra - multiple committee bits set", func(t *testing.T) {
 		state, err := util.NewBeaconStateElectra()
@@ -152,7 +152,7 @@ func TestProposeAttestation(t *testing.T) {
 			CommitteeBits: cb,
 		}
 		_, err = attesterServer.ProposeAttestationElectra(context.Background(), req)
-		assert.ErrorContains(t, "Committee bits has more than one bit set", err)
+		assert.ErrorContains(t, "exactly 1 committee index must be set but 2 were set", err)
 	})
 }
 

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

@@ -277,8 +277,8 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 	var sidecars []*ethpb.BlobSidecar
 	if block.IsBlinded() {
 		block, sidecars, err = vs.handleBlindedBlock(ctx, block)
-	} else {
-		sidecars, err = vs.handleUnblindedBlock(block, req)
+	} else if block.Version() >= version.Deneb {
+		sidecars, err = vs.blobSidecarsFromUnblindedBlock(block, req)
 	}
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "%s: %v", "handle block failed", err)
@@ -345,13 +345,12 @@ func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.Signe
 	return copiedBlock, sidecars, nil
 }
 
-// handleUnblindedBlock processes unblinded beacon blocks.
-func (vs *Server) handleUnblindedBlock(block interfaces.SignedBeaconBlock, req *ethpb.GenericSignedBeaconBlock) ([]*ethpb.BlobSidecar, error) {
-	dbBlockContents := req.GetDeneb()
-	if dbBlockContents == nil {
-		return nil, nil
+func (vs *Server) blobSidecarsFromUnblindedBlock(block interfaces.SignedBeaconBlock, req *ethpb.GenericSignedBeaconBlock) ([]*ethpb.BlobSidecar, error) {
+	rawBlobs, proofs, err := blobsAndProofs(req)
+	if err != nil {
+		return nil, err
 	}
-	return BuildBlobSidecars(block, dbBlockContents.Blobs, dbBlockContents.KzgProofs)
+	return BuildBlobSidecars(block, rawBlobs, proofs)
 }
 
 // broadcastReceiveBlock broadcasts a block and handles its reception.
@@ -502,3 +501,16 @@ func (vs *Server) SubmitValidatorRegistrations(ctx context.Context, reg *ethpb.S
 
 	return &emptypb.Empty{}, nil
 }
+
+func blobsAndProofs(req *ethpb.GenericSignedBeaconBlock) ([][]byte, [][]byte, error) {
+	switch {
+	case req.GetDeneb() != nil:
+		dbBlockContents := req.GetDeneb()
+		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
+	case req.GetElectra() != nil:
+		dbBlockContents := req.GetElectra()
+		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
+	default:
+		return nil, nil, errors.Errorf("unknown request type provided: %T", req)
+	}
+}

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

@@ -11,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -112,18 +113,12 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 	if err != nil {
 		return nil, err
 	}
-	sorted, err := deduped.sortByProfitability()
+	sorted, err := deduped.sort()
 	if err != nil {
 		return nil, err
 	}
 	atts = sorted.limitToMaxAttestations()
-
-	atts, err = vs.filterAttestationBySignature(ctx, atts, latestState)
-	if err != nil {
-		return nil, err
-	}
-
-	return atts, nil
+	return vs.filterAttestationBySignature(ctx, atts, latestState)
 }
 
 // filter separates attestation list into two groups: valid and invalid attestations.
@@ -143,14 +138,6 @@ func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (propose
 	return validAtts, invalidAtts
 }
 
-// sortByProfitability orders attestations by highest slot and by highest aggregation bit count.
-func (a proposerAtts) sortByProfitability() (proposerAtts, error) {
-	if len(a) < 2 {
-		return a, nil
-	}
-	return a.sortByProfitabilityUsingMaxCover()
-}
-
 // sortByProfitabilityUsingMaxCover orders attestations by highest slot and by highest aggregation bit count.
 // Duplicate bits are counted only once, using max-cover algorithm.
 func (a proposerAtts) sortByProfitabilityUsingMaxCover() (proposerAtts, error) {
@@ -218,6 +205,143 @@ func (a proposerAtts) sortByProfitabilityUsingMaxCover() (proposerAtts, error) {
 	return sortedAtts, nil
 }
 
+// sort attestations as follows:
+//
+//   - all attestations selected by max-cover are taken, leftover attestations are discarded
+//     (with current parameters all bits of a leftover attestation are already covered by selected attestations)
+//   - selected attestations are ordered by slot, with higher slot coming first
+//   - within a slot, all top attestations (one per committee) are ordered before any second-best attestations, second-best before third-best etc.
+//   - within top/second-best/etc. attestations (one per committee), attestations are ordered by bit count, with higher bit count coming first
+func (a proposerAtts) sort() (proposerAtts, error) {
+	if len(a) < 2 {
+		return a, nil
+	}
+
+	if features.Get().EnableCommitteeAwarePacking {
+		return a.sortBySlotAndCommittee()
+	}
+	return a.sortByProfitabilityUsingMaxCover()
+}
+
+// Separate attestations by slot, as slot number takes higher precedence when sorting.
+// Also separate by committee index because maxcover will prefer attestations for the same
+// committee with disjoint bits over attestations for different committees with overlapping
+// bits, even though same bits for different committees are separate votes.
+func (a proposerAtts) sortBySlotAndCommittee() (proposerAtts, error) {
+	type slotAtts struct {
+		candidates map[primitives.CommitteeIndex]proposerAtts
+		selected   map[primitives.CommitteeIndex]proposerAtts
+		leftover   map[primitives.CommitteeIndex]proposerAtts
+	}
+
+	var slots []primitives.Slot
+	attsBySlot := map[primitives.Slot]*slotAtts{}
+	for _, att := range a {
+		slot := att.GetData().Slot
+		ci := att.GetData().CommitteeIndex
+		if _, ok := attsBySlot[slot]; !ok {
+			attsBySlot[slot] = &slotAtts{}
+			attsBySlot[slot].candidates = make(map[primitives.CommitteeIndex]proposerAtts)
+			slots = append(slots, slot)
+		}
+		attsBySlot[slot].candidates[ci] = append(attsBySlot[slot].candidates[ci], att)
+	}
+
+	var err error
+	for _, sa := range attsBySlot {
+		sa.selected = make(map[primitives.CommitteeIndex]proposerAtts)
+		sa.leftover = make(map[primitives.CommitteeIndex]proposerAtts)
+		for ci, committeeAtts := range sa.candidates {
+			sa.selected[ci], err = committeeAtts.sortByProfitabilityUsingMaxCover_committeeAwarePacking()
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	var sortedAtts proposerAtts
+	sort.Slice(slots, func(i, j int) bool {
+		return slots[i] > slots[j]
+	})
+	for _, slot := range slots {
+		sortedAtts = append(sortedAtts, sortSlotAttestations(attsBySlot[slot].selected)...)
+	}
+	for _, slot := range slots {
+		sortedAtts = append(sortedAtts, sortSlotAttestations(attsBySlot[slot].leftover)...)
+	}
+
+	return sortedAtts, nil
+}
+
+// sortByProfitabilityUsingMaxCover orders attestations by highest aggregation bit count.
+// Duplicate bits are counted only once, using max-cover algorithm.
+func (a proposerAtts) sortByProfitabilityUsingMaxCover_committeeAwarePacking() (proposerAtts, error) {
+	if len(a) < 2 {
+		return a, nil
+	}
+	candidates := make([]*bitfield.Bitlist64, len(a))
+	for i := 0; i < len(a); i++ {
+		var err error
+		candidates[i], err = a[i].GetAggregationBits().ToBitlist64()
+		if err != nil {
+			return nil, err
+		}
+	}
+	// Add selected candidates on top, those that are not selected - append at bottom.
+	selectedKeys, _, err := aggregation.MaxCover(candidates, len(candidates), true /* allowOverlaps */)
+	if err != nil {
+		log.WithError(err).Debug("MaxCover aggregation failed")
+		return a, nil
+	}
+
+	// Pick selected attestations first, leftover attestations will be appended at the end.
+	// Both lists will be sorted by number of bits set.
+	selected := make(proposerAtts, selectedKeys.Count())
+	for i, key := range selectedKeys.BitIndices() {
+		selected[i] = a[key]
+	}
+	sort.Slice(selected, func(i, j int) bool {
+		return selected[i].GetAggregationBits().Count() > selected[j].GetAggregationBits().Count()
+	})
+	return selected, nil
+}
+
+// sortSlotAttestations assumes each proposerAtts value in the map is ordered by profitability.
+// The function takes the first attestation from each value, orders these attestations by bit count
+// and places them at the start of the resulting slice. It then takes the second attestation for each value,
+// orders these attestations by bit count and appends them to the end.
+// It continues this pattern until all attestations are processed.
+func sortSlotAttestations(slotAtts map[primitives.CommitteeIndex]proposerAtts) proposerAtts {
+	attCount := 0
+	for _, committeeAtts := range slotAtts {
+		attCount += len(committeeAtts)
+	}
+
+	sorted := make([]ethpb.Att, 0, attCount)
+
+	processedCount := 0
+	index := 0
+	for processedCount < attCount {
+		var atts []ethpb.Att
+
+		for _, committeeAtts := range slotAtts {
+			if len(committeeAtts) > index {
+				atts = append(atts, committeeAtts[index])
+			}
+		}
+
+		sort.Slice(atts, func(i, j int) bool {
+			return atts[i].GetAggregationBits().Count() > atts[j].GetAggregationBits().Count()
+		})
+		sorted = append(sorted, atts...)
+
+		processedCount += len(atts)
+		index++
+	}
+
+	return sorted
+}
+
 // limitToMaxAttestations limits attestations to maximum attestations per block.
 func (a proposerAtts) limitToMaxAttestations() proposerAtts {
 	if len(a) == 0 {

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

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 	chainMock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls/blst"
@@ -19,31 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
-func TestProposer_ProposerAtts_sortByProfitability(t *testing.T) {
-	atts := proposerAtts([]ethpb.Att{
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11100000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11000000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b11100000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11110000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11100000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b11000000}}),
-	})
-	want := proposerAtts([]ethpb.Att{
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11110000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11100000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b11000000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b11100000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11100000}}),
-		util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11000000}}),
-	})
-	atts, err := atts.sortByProfitability()
-	if err != nil {
-		t.Error(err)
-	}
-	require.DeepEqual(t, want, atts)
-}
-
-func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
+func TestProposer_ProposerAtts_sort(t *testing.T) {
 	type testData struct {
 		slot primitives.Slot
 		bits bitfield.Bitlist
@@ -60,7 +37,7 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 	t.Run("no atts", func(t *testing.T) {
 		atts := getAtts([]testData{})
 		want := getAtts([]testData{})
-		atts, err := atts.sortByProfitability()
+		atts, err := atts.sort()
 		if err != nil {
 			t.Error(err)
 		}
@@ -74,7 +51,7 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 		want := getAtts([]testData{
 			{4, bitfield.Bitlist{0b11100000, 0b1}},
 		})
-		atts, err := atts.sortByProfitability()
+		atts, err := atts.sort()
 		if err != nil {
 			t.Error(err)
 		}
@@ -90,7 +67,7 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 			{4, bitfield.Bitlist{0b11100000, 0b1}},
 			{1, bitfield.Bitlist{0b11000000, 0b1}},
 		})
-		atts, err := atts.sortByProfitability()
+		atts, err := atts.sort()
 		if err != nil {
 			t.Error(err)
 		}
@@ -108,7 +85,7 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 			{4, bitfield.Bitlist{0b11100000, 0b1}},
 			{1, bitfield.Bitlist{0b11000000, 0b1}},
 		})
-		atts, err := atts.sortByProfitability()
+		atts, err := atts.sort()
 		if err != nil {
 			t.Error(err)
 		}
@@ -129,7 +106,7 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 				{1, bitfield.Bitlist{0b00001100, 0b1}},
 				{1, bitfield.Bitlist{0b11001000, 0b1}},
 			})
-			atts, err := atts.sortByProfitability()
+			atts, err := atts.sort()
 			if err != nil {
 				t.Error(err)
 			}
@@ -154,14 +131,14 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 			{1, bitfield.Bitlist{0b11100000, 0b1}},
 			{1, bitfield.Bitlist{0b11000000, 0b1}},
 		})
-		atts, err := atts.sortByProfitability()
+		atts, err := atts.sort()
 		if err != nil {
 			t.Error(err)
 		}
 		require.DeepEqual(t, want, atts)
 	})
 
-	t.Run("selected and non selected atts sorted by bit count", func(t *testing.T) {
+	t.Run("follows max-cover", func(t *testing.T) {
 		// Items at slot 4, must be first split into two lists by max-cover, with
 		// 0b10000011 scoring higher (as it provides more info in addition to already selected
 		// attestations) than 0b11100001 (despite naive bit count suggesting otherwise). Then,
@@ -186,7 +163,7 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 			{1, bitfield.Bitlist{0b11100000, 0b1}},
 			{1, bitfield.Bitlist{0b11000000, 0b1}},
 		})
-		atts, err := atts.sortByProfitability()
+		atts, err := atts.sort()
 		if err != nil {
 			t.Error(err)
 		}
@@ -194,6 +171,241 @@ func TestProposer_ProposerAtts_sortByProfitabilityUsingMaxCover(t *testing.T) {
 	})
 }
 
+func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
+	type testData struct {
+		slot primitives.Slot
+		bits bitfield.Bitlist
+	}
+	getAtts := func(data []testData) proposerAtts {
+		var atts proposerAtts
+		for _, att := range data {
+			atts = append(atts, util.HydrateAttestation(&ethpb.Attestation{
+				Data: &ethpb.AttestationData{Slot: att.slot}, AggregationBits: att.bits}))
+		}
+		return atts
+	}
+
+	t.Run("no atts", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		atts := getAtts([]testData{})
+		want := getAtts([]testData{})
+		atts, err := atts.sort()
+		if err != nil {
+			t.Error(err)
+		}
+		require.DeepEqual(t, want, atts)
+	})
+
+	t.Run("single att", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		atts := getAtts([]testData{
+			{4, bitfield.Bitlist{0b11100000, 0b1}},
+		})
+		want := getAtts([]testData{
+			{4, bitfield.Bitlist{0b11100000, 0b1}},
+		})
+		atts, err := atts.sort()
+		if err != nil {
+			t.Error(err)
+		}
+		require.DeepEqual(t, want, atts)
+	})
+
+	t.Run("single att per slot", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		atts := getAtts([]testData{
+			{1, bitfield.Bitlist{0b11000000, 0b1}},
+			{4, bitfield.Bitlist{0b11100000, 0b1}},
+		})
+		want := getAtts([]testData{
+			{4, bitfield.Bitlist{0b11100000, 0b1}},
+			{1, bitfield.Bitlist{0b11000000, 0b1}},
+		})
+		atts, err := atts.sort()
+		if err != nil {
+			t.Error(err)
+		}
+		require.DeepEqual(t, want, atts)
+	})
+
+	t.Run("two atts on one of the slots", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		atts := getAtts([]testData{
+			{1, bitfield.Bitlist{0b11000000, 0b1}},
+			{4, bitfield.Bitlist{0b11100000, 0b1}},
+			{4, bitfield.Bitlist{0b11110000, 0b1}},
+		})
+		want := getAtts([]testData{
+			{4, bitfield.Bitlist{0b11110000, 0b1}},
+			{1, bitfield.Bitlist{0b11000000, 0b1}},
+		})
+		atts, err := atts.sort()
+		if err != nil {
+			t.Error(err)
+		}
+		require.DeepEqual(t, want, atts)
+	})
+
+	t.Run("compare to native sort", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		// The max-cover based approach will select 0b00001100 instead, despite lower bit count
+		// (since it has two new/unknown bits).
+		t.Run("max-cover", func(t *testing.T) {
+			atts := getAtts([]testData{
+				{1, bitfield.Bitlist{0b11000011, 0b1}},
+				{1, bitfield.Bitlist{0b11001000, 0b1}},
+				{1, bitfield.Bitlist{0b00001100, 0b1}},
+			})
+			want := getAtts([]testData{
+				{1, bitfield.Bitlist{0b11000011, 0b1}},
+				{1, bitfield.Bitlist{0b00001100, 0b1}},
+			})
+			atts, err := atts.sort()
+			if err != nil {
+				t.Error(err)
+			}
+			require.DeepEqual(t, want, atts)
+		})
+	})
+
+	t.Run("multiple slots", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		atts := getAtts([]testData{
+			{2, bitfield.Bitlist{0b11100000, 0b1}},
+			{4, bitfield.Bitlist{0b11100000, 0b1}},
+			{1, bitfield.Bitlist{0b11000000, 0b1}},
+			{4, bitfield.Bitlist{0b11110000, 0b1}},
+			{1, bitfield.Bitlist{0b11100000, 0b1}},
+			{3, bitfield.Bitlist{0b11000000, 0b1}},
+		})
+		want := getAtts([]testData{
+			{4, bitfield.Bitlist{0b11110000, 0b1}},
+			{3, bitfield.Bitlist{0b11000000, 0b1}},
+			{2, bitfield.Bitlist{0b11100000, 0b1}},
+			{1, bitfield.Bitlist{0b11100000, 0b1}},
+		})
+		atts, err := atts.sort()
+		if err != nil {
+			t.Error(err)
+		}
+		require.DeepEqual(t, want, atts)
+	})
+
+	t.Run("follows max-cover", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		// Items at slot 4 must be first split into two lists by max-cover, with
+		// 0b10000011 being selected and 0b11100001 being leftover (despite naive bit count suggesting otherwise).
+		atts := getAtts([]testData{
+			{4, bitfield.Bitlist{0b00000001, 0b1}},
+			{4, bitfield.Bitlist{0b11100001, 0b1}},
+			{1, bitfield.Bitlist{0b11000000, 0b1}},
+			{2, bitfield.Bitlist{0b11100000, 0b1}},
+			{4, bitfield.Bitlist{0b10000011, 0b1}},
+			{4, bitfield.Bitlist{0b11111000, 0b1}},
+			{1, bitfield.Bitlist{0b11100000, 0b1}},
+			{3, bitfield.Bitlist{0b11000000, 0b1}},
+		})
+		want := getAtts([]testData{
+			{4, bitfield.Bitlist{0b11111000, 0b1}},
+			{4, bitfield.Bitlist{0b10000011, 0b1}},
+			{3, bitfield.Bitlist{0b11000000, 0b1}},
+			{2, bitfield.Bitlist{0b11100000, 0b1}},
+			{1, bitfield.Bitlist{0b11100000, 0b1}},
+		})
+		atts, err := atts.sort()
+		if err != nil {
+			t.Error(err)
+		}
+		require.DeepEqual(t, want, atts)
+	})
+}
+
+func TestProposer_sort_DifferentCommittees(t *testing.T) {
+	t.Run("one att per committee", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 1}})
+		c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11100000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 2}})
+		atts := proposerAtts{c1_a1, c2_a1}
+		atts, err := atts.sort()
+		require.NoError(t, err)
+		want := proposerAtts{c1_a1, c2_a1}
+		assert.DeepEqual(t, want, atts)
+	})
+	t.Run("multiple atts per committee", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111100, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 1}})
+		c1_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10000010, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 1}})
+		c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11110000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 2}})
+		c2_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11100000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 2}})
+		atts := proposerAtts{c1_a1, c1_a2, c2_a1, c2_a2}
+		atts, err := atts.sort()
+		require.NoError(t, err)
+
+		want := proposerAtts{c1_a1, c2_a1, c1_a2}
+		assert.DeepEqual(t, want, atts)
+	})
+	t.Run("multiple atts per committee, multiple slots", func(t *testing.T) {
+		feat := features.Get()
+		feat.EnableCommitteeAwarePacking = true
+		reset := features.InitWithReset(feat)
+		defer reset()
+
+		s2_c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111100, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1}})
+		s2_c1_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10000010, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1}})
+		s2_c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11110000, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 2}})
+		s2_c2_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11000000, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 2}})
+		s1_c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111100, 0b1}, Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1}})
+		s1_c1_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10000010, 0b1}, Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1}})
+		s1_c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11110000, 0b1}, Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 2}})
+		s1_c2_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11000000, 0b1}, Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 2}})
+
+		// Arrange in some random order
+		atts := proposerAtts{s1_c1_a1, s2_c1_a2, s1_c2_a2, s2_c2_a2, s1_c2_a1, s2_c2_a1, s1_c1_a2, s2_c1_a1}
+
+		atts, err := atts.sort()
+		require.NoError(t, err)
+
+		want := proposerAtts{s2_c1_a1, s2_c2_a1, s2_c1_a2, s1_c1_a1, s1_c2_a1, s1_c1_a2}
+		assert.DeepEqual(t, want, atts)
+	})
+}
+
 func TestProposer_ProposerAtts_dedup(t *testing.T) {
 	data1 := util.HydrateAttestationData(&ethpb.AttestationData{
 		Slot: 4,

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

@@ -96,6 +96,27 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 		// Compare payload values between local and builder. Default to the local value if it is higher.
 		localValueGwei := primitives.WeiToGwei(local.Bid)
 		builderValueGwei := primitives.WeiToGwei(bid.Value())
+		minBid := primitives.Gwei(params.BeaconConfig().MinBuilderBid)
+		// Use local block if min bid is not attained
+		if builderValueGwei < minBid {
+			log.WithFields(logrus.Fields{
+				"minBuilderBid":    minBid,
+				"builderGweiValue": builderValueGwei,
+			}).Warn("Proposer: using local execution payload because min bid not attained")
+			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+		}
+
+		// Use local block if min difference is not attained
+		minDiff := localValueGwei + primitives.Gwei(params.BeaconConfig().MinBuilderDiff)
+		if builderValueGwei < minDiff {
+			log.WithFields(logrus.Fields{
+				"localGweiValue":   localValueGwei,
+				"minBidDiff":       minDiff,
+				"builderGweiValue": builderValueGwei,
+			}).Warn("Proposer: using local execution payload because min difference with local value was not attained")
+			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+		}
+
 		// Use builder payload if the following in true:
 		// builder_bid_value * builderBoostFactor(default 100) > local_block_value * (local-block-value-boost + 100)
 		boost := primitives.Gwei(params.BeaconConfig().LocalBlockValueBoost)
@@ -221,6 +242,15 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot primitiv
 		return nil, fmt.Errorf("incorrect parent hash %#x != %#x", header.ParentHash(), h.BlockHash())
 	}
 
+	reg, err := vs.BlockBuilder.RegistrationByValidatorID(ctx, idx)
+	if err != nil {
+		log.WithError(err).Warn("Proposer: failed to get registration by validator ID, could not check gas limit")
+	} else {
+		if reg.GasLimit != header.GasLimit() {
+			return nil, fmt.Errorf("incorrect header gas limit %d != %d", reg.GasLimit, header.GasLimit())
+		}
+	}
+
 	t, err := slots.ToTime(uint64(vs.TimeFetcher.GenesisTime().Unix()), slot)
 	if err != nil {
 		return nil, err

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

@@ -420,7 +420,41 @@ func TestServer_setExecutionData(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, uint64(3), e.BlockNumber()) // Local block
 
-		require.LogsContain(t, hook, "builderGweiValue=1 localBoostPercentage=0 localGweiValue=2")
+		require.LogsContain(t, hook, "\"Proposer: using local execution payload because min difference with local value was not attained\" builderGweiValue=1 localGweiValue=2")
+	})
+	t.Run("Builder configured. Builder block does not achieve min bid", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.MinBuilderBid = 5
+		params.OverrideBeaconConfig(cfg)
+
+		blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockCapella())
+		require.NoError(t, err)
+		elBid := primitives.Uint64ToWei(2 * 1e9)
+		ed, err := blocks.NewWrappedExecutionData(&v1.ExecutionPayloadCapella{BlockNumber: 3})
+		require.NoError(t, err)
+		vs.ExecutionEngineCaller = &powtesting.EngineClient{PayloadIDBytes: id, GetPayloadResponse: &blocks.GetPayloadResponse{ExecutionData: ed, Bid: elBid}}
+		b := blk.Block()
+		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
+		require.NoError(t, err)
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		require.NoError(t, err)
+		_, err = builderBid.Header()
+		require.NoError(t, err)
+		builderKzgCommitments, err := builderBid.BlobKzgCommitments()
+		if builderBid.Version() >= version.Deneb {
+			require.NoError(t, err)
+		}
+		require.DeepEqual(t, [][]uint8{}, builderKzgCommitments)
+		_, bundle, err := setExecutionData(context.Background(), blk, res, builderBid, defaultBuilderBoostFactor)
+		require.NoError(t, err)
+		require.IsNil(t, bundle)
+		e, err := blk.Block().Body().Execution()
+		require.NoError(t, err)
+		require.Equal(t, uint64(3), e.BlockNumber()) // Local block
+
+		require.LogsContain(t, hook, "\"Proposer: using local execution payload because min bid not attained\" builderGweiValue=1 minBuilderBid=5")
+		cfg.MinBuilderBid = 0
+		params.OverrideBeaconConfig(cfg)
 	})
 	t.Run("Builder configured. Local block and local boost has higher value", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
@@ -686,6 +720,29 @@ func TestServer_getPayloadHeader(t *testing.T) {
 		Signature: sk.Sign(srCapella[:]).Marshal(),
 	}
 
+	incorrectGasLimitBid := &ethpb.BuilderBid{
+		Header: &v1.ExecutionPayloadHeader{
+			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:        make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+			LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:       make([]byte, fieldparams.RootLength),
+			BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+			BlockHash:        make([]byte, fieldparams.RootLength),
+			TransactionsRoot: bytesutil.PadTo([]byte{1}, fieldparams.RootLength),
+			ParentHash:       params.BeaconConfig().ZeroHash[:],
+			Timestamp:        uint64(tiCapella.Unix()),
+			GasLimit:         100,
+		},
+		Pubkey: sk.PublicKey().Marshal(),
+		Value:  bytesutil.PadTo([]byte{1, 2, 3}, 32),
+	}
+	signedIncorrectGasLimitBid :=
+		&ethpb.SignedBuilderBid{
+			Message:   incorrectGasLimitBid,
+			Signature: sk.Sign(srCapella[:]).Marshal(),
+		}
+
 	require.NoError(t, err)
 	tests := []struct {
 		name                  string
@@ -798,6 +855,21 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			},
 			err: "is different from head block version",
 		},
+		{
+			name: "incorrect gas limit",
+			mock: &builderTest.MockBuilderService{
+				Bid: signedIncorrectGasLimitBid,
+			},
+			fetcher: &blockchainTest.ChainService{
+				Block: func() interfaces.ReadOnlySignedBeaconBlock {
+					wb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockBellatrix())
+					require.NoError(t, err)
+					wb.SetSlot(primitives.Slot(params.BeaconConfig().BellatrixForkEpoch) * params.BeaconConfig().SlotsPerEpoch)
+					return wb
+				}(),
+			},
+			err: "incorrect header gas limit 0 != 100",
+		},
 		{
 			name: "different bid version during hard fork",
 			mock: &builderTest.MockBuilderService{
@@ -816,9 +888,18 @@ func TestServer_getPayloadHeader(t *testing.T) {
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			vs := &Server{BlockBuilder: tc.mock, HeadFetcher: tc.fetcher, TimeFetcher: &blockchainTest.ChainService{
+			vs := &Server{BeaconDB: dbTest.SetupDB(t), BlockBuilder: tc.mock, HeadFetcher: tc.fetcher, TimeFetcher: &blockchainTest.ChainService{
 				Genesis: genesis,
 			}}
+			regCache := cache.NewRegistrationCache()
+			regCache.UpdateIndexToRegisteredMap(context.Background(), map[primitives.ValidatorIndex]*ethpb.ValidatorRegistrationV1{
+				0: {
+					GasLimit:     0,
+					FeeRecipient: make([]byte, 20),
+					Pubkey:       make([]byte, 48),
+				},
+			})
+			tc.mock.RegistrationCache = regCache
 			hb, err := vs.HeadFetcher.HeadBlock(context.Background())
 			require.NoError(t, err)
 			bid, err := vs.getPayloadHeaderFromBuilder(context.Background(), hb.Block().Slot(), 0)

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

@@ -59,14 +59,26 @@ func (vs *Server) getLocalPayload(ctx context.Context, blk interfaces.ReadOnlyBe
 	slot := blk.Slot()
 	vIdx := blk.ProposerIndex()
 	headRoot := blk.ParentRoot()
-	logFields := logrus.Fields{
-		"validatorIndex": vIdx,
-		"slot":           slot,
-		"headRoot":       fmt.Sprintf("%#x", headRoot),
-	}
-	payloadId, ok := vs.PayloadIDCache.PayloadID(slot, headRoot)
 
-	val, tracked := vs.TrackedValidatorsCache.Validator(vIdx)
+	return vs.getLocalPayloadFromEngine(ctx, st, headRoot, slot, vIdx)
+}
+
+// This returns the local execution payload of a slot, proposer ID, and parent root assuming payload Is cached.
+// If the payload ID is not cached, the function will prepare a new payload through local EL engine and return it by using the head state.
+func (vs *Server) getLocalPayloadFromEngine(
+	ctx context.Context,
+	st state.BeaconState,
+	parentRoot [32]byte,
+	slot primitives.Slot,
+	proposerId primitives.ValidatorIndex) (*consensusblocks.GetPayloadResponse, error) {
+	logFields := logrus.Fields{
+		"validatorIndex": proposerId,
+		"slot":           slot,
+		"headRoot":       fmt.Sprintf("%#x", parentRoot),
+	}
+	payloadId, ok := vs.PayloadIDCache.PayloadID(slot, parentRoot)
+
+	val, tracked := vs.TrackedValidatorsCache.Validator(proposerId)
 	if !tracked {
 		logrus.WithFields(logFields).Warn("could not find tracked proposer index")
 	}
@@ -135,7 +147,7 @@ func (vs *Server) getLocalPayload(ctx context.Context, blk interfaces.ReadOnlyBe
 			PrevRandao:            random,
 			SuggestedFeeRecipient: val.FeeRecipient[:],
 			Withdrawals:           withdrawals,
-			ParentBeaconBlockRoot: headRoot[:],
+			ParentBeaconBlockRoot: parentRoot[:],
 		})
 		if err != nil {
 			return nil, err

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

@@ -879,33 +879,6 @@ func TestProposer_ProposeBlock_OK(t *testing.T) {
 			},
 			err: "blob KZG commitments don't match number of blobs or KZG proofs",
 		},
-		{
-			name: "electra block no blob",
-			block: func(parent [32]byte) *ethpb.GenericSignedBeaconBlock {
-				sb := &ethpb.SignedBeaconBlockContentsElectra{
-					Block: &ethpb.SignedBeaconBlockElectra{
-						Block: &ethpb.BeaconBlockElectra{Slot: 5, ParentRoot: parent[:], Body: util.HydrateBeaconBlockBodyElectra(&ethpb.BeaconBlockBodyElectra{})},
-					},
-				}
-				blk := &ethpb.GenericSignedBeaconBlock_Electra{Electra: sb}
-				return &ethpb.GenericSignedBeaconBlock{Block: blk, IsBlinded: false}
-			},
-		},
-		{
-			name: "electra block some blob",
-			block: func(parent [32]byte) *ethpb.GenericSignedBeaconBlock {
-
-				sb := &ethpb.SignedBeaconBlockContentsElectra{
-					Block: &ethpb.SignedBeaconBlockElectra{
-						Block: &ethpb.BeaconBlockElectra{Slot: 5, ParentRoot: parent[:], Body: util.HydrateBeaconBlockBodyElectra(&ethpb.BeaconBlockBodyElectra{})},
-					},
-					KzgProofs: [][]byte{{0x01}, {0x02}, {0x03}},
-					Blobs:     [][]byte{{0x01}, {0x02}, {0x03}},
-				}
-				blk := &ethpb.GenericSignedBeaconBlock_Electra{Electra: sb}
-				return &ethpb.GenericSignedBeaconBlock{Block: blk, IsBlinded: false}
-			},
-		},
 		{
 			name: "blind deneb block some blobs",
 			block: func(parent [32]byte) *ethpb.GenericSignedBeaconBlock {
@@ -943,6 +916,57 @@ func TestProposer_ProposeBlock_OK(t *testing.T) {
 			useBuilder: true,
 			err:        "unblind sidecars failed: commitment value doesn't match block",
 		},
+		{
+			name: "electra block no blob",
+			block: func(parent [32]byte) *ethpb.GenericSignedBeaconBlock {
+				sb := &ethpb.SignedBeaconBlockContentsElectra{
+					Block: &ethpb.SignedBeaconBlockElectra{
+						Block: &ethpb.BeaconBlockElectra{Slot: 5, ParentRoot: parent[:], Body: util.HydrateBeaconBlockBodyElectra(&ethpb.BeaconBlockBodyElectra{})},
+					},
+				}
+				blk := &ethpb.GenericSignedBeaconBlock_Electra{Electra: sb}
+				return &ethpb.GenericSignedBeaconBlock{Block: blk, IsBlinded: false}
+			},
+		},
+		{
+			name: "electra block some blob",
+			block: func(parent [32]byte) *ethpb.GenericSignedBeaconBlock {
+				sb := &ethpb.SignedBeaconBlockContentsElectra{
+					Block: &ethpb.SignedBeaconBlockElectra{
+						Block: &ethpb.BeaconBlockElectra{
+							Slot: 5, ParentRoot: parent[:],
+							Body: util.HydrateBeaconBlockBodyElectra(&ethpb.BeaconBlockBodyElectra{
+								BlobKzgCommitments: [][]byte{bytesutil.PadTo([]byte("kc"), 48), bytesutil.PadTo([]byte("kc1"), 48), bytesutil.PadTo([]byte("kc2"), 48)},
+							}),
+						},
+					},
+					KzgProofs: [][]byte{{0x01}, {0x02}, {0x03}},
+					Blobs:     [][]byte{{0x01}, {0x02}, {0x03}},
+				}
+				blk := &ethpb.GenericSignedBeaconBlock_Electra{Electra: sb}
+				return &ethpb.GenericSignedBeaconBlock{Block: blk, IsBlinded: false}
+			},
+		},
+		{
+			name: "electra block some blob (kzg and blob count mismatch)",
+			block: func(parent [32]byte) *ethpb.GenericSignedBeaconBlock {
+				sb := &ethpb.SignedBeaconBlockContentsElectra{
+					Block: &ethpb.SignedBeaconBlockElectra{
+						Block: &ethpb.BeaconBlockElectra{
+							Slot: 5, ParentRoot: parent[:],
+							Body: util.HydrateBeaconBlockBodyElectra(&ethpb.BeaconBlockBodyElectra{
+								BlobKzgCommitments: [][]byte{bytesutil.PadTo([]byte("kc"), 48), bytesutil.PadTo([]byte("kc1"), 48)},
+							}),
+						},
+					},
+					KzgProofs: [][]byte{{0x01}, {0x02}, {0x03}},
+					Blobs:     [][]byte{{0x01}, {0x02}, {0x03}},
+				}
+				blk := &ethpb.GenericSignedBeaconBlock_Electra{Electra: sb}
+				return &ethpb.GenericSignedBeaconBlock{Block: blk, IsBlinded: false}
+			},
+			err: "blob KZG commitments don't match number of blobs or KZG proofs",
+		},
 	}
 
 	for _, tt := range tests {
@@ -3092,3 +3116,15 @@ func TestProposer_GetParentHeadState(t *testing.T) {
 		require.LogsContain(t, hook, "late block attempted reorg failed")
 	})
 }
+
+func TestProposer_ElectraBlobsAndProofs(t *testing.T) {
+	electraContents := &ethpb.SignedBeaconBlockContentsElectra{Block: &ethpb.SignedBeaconBlockElectra{}}
+	electraContents.KzgProofs = make([][]byte, 10)
+	electraContents.Blobs = make([][]byte, 10)
+
+	genBlock := &ethpb.GenericSignedBeaconBlock{Block: &ethpb.GenericSignedBeaconBlock_Electra{Electra: electraContents}}
+	blobs, proofs, err := blobsAndProofs(genBlock)
+	require.NoError(t, err)
+	require.Equal(t, 10, len(blobs))
+	require.Equal(t, 10, len(proofs))
+}

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

@@ -49,7 +49,7 @@ func BenchmarkProposerAtts_sortByProfitability(b *testing.B) {
 		for i, att := range atts {
 			attsCopy[i] = att.(*ethpb.Attestation).Copy()
 		}
-		_, err := attsCopy.sortByProfitability()
+		_, err := attsCopy.sort()
 		require.NoError(b, err, "Could not sort attestations by profitability")
 	}
 

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

@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "handlers.go",
         "server.go",
         "validator_performance.go",
     ],
@@ -10,9 +11,17 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api/server/structs:go_default_library",
+        "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/eth/shared:go_default_library",
+        "//beacon-chain/rpc/lookup:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -20,23 +29,42 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["validator_performance_test.go"],
+    srcs = [
+        "handlers_test.go",
+        "validator_performance_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
+        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/db/testing:go_default_library",
+        "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen:go_default_library",
+        "//beacon-chain/state/stategen/mock:go_default_library",
         "//beacon-chain/sync/initial-sync/testing:go_default_library",
+        "//config/fieldparams: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/primitives: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",
+        "//time:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

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

@@ -0,0 +1,117 @@
+package validator
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/gorilla/mux"
+	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
+)
+
+// GetParticipation retrieves the validator participation information for a given epoch,
+// it returns the information about validator's participation rate in voting on the proof of stake
+// rules based on their balance compared to the total active validator balance.
+func (s *Server) GetParticipation(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "validator.GetParticipation")
+	defer span.End()
+
+	stateId := mux.Vars(r)["state_id"]
+	if stateId == "" {
+		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+
+	st, err := s.Stater.State(ctx, []byte(stateId))
+	if err != nil {
+		shared.WriteStateFetchError(w, err)
+		return
+	}
+	stEpoch := slots.ToEpoch(st.Slot())
+	vp, rpcError := s.CoreService.ValidatorParticipation(ctx, stEpoch)
+	if rpcError != nil {
+		httputil.HandleError(w, rpcError.Err.Error(), core.ErrorReasonToHTTP(rpcError.Reason))
+		return
+	}
+
+	response := &structs.GetValidatorParticipationResponse{
+		Epoch:     fmt.Sprintf("%d", vp.Epoch),
+		Finalized: vp.Finalized,
+		Participation: &structs.ValidatorParticipation{
+			GlobalParticipationRate:          fmt.Sprintf("%f", vp.Participation.GlobalParticipationRate),
+			VotedEther:                       fmt.Sprintf("%d", vp.Participation.VotedEther),
+			EligibleEther:                    fmt.Sprintf("%d", vp.Participation.EligibleEther),
+			CurrentEpochActiveGwei:           fmt.Sprintf("%d", vp.Participation.CurrentEpochActiveGwei),
+			CurrentEpochAttestingGwei:        fmt.Sprintf("%d", vp.Participation.CurrentEpochAttestingGwei),
+			CurrentEpochTargetAttestingGwei:  fmt.Sprintf("%d", vp.Participation.CurrentEpochTargetAttestingGwei),
+			PreviousEpochActiveGwei:          fmt.Sprintf("%d", vp.Participation.PreviousEpochActiveGwei),
+			PreviousEpochAttestingGwei:       fmt.Sprintf("%d", vp.Participation.PreviousEpochAttestingGwei),
+			PreviousEpochTargetAttestingGwei: fmt.Sprintf("%d", vp.Participation.PreviousEpochTargetAttestingGwei),
+			PreviousEpochHeadAttestingGwei:   fmt.Sprintf("%d", vp.Participation.PreviousEpochHeadAttestingGwei),
+		},
+	}
+	httputil.WriteJson(w, response)
+}
+
+// GetActiveSetChanges retrieves the active set changes for a given epoch.
+//
+// This data includes any activations, voluntary exits, and involuntary
+// ejections.
+func (s *Server) GetActiveSetChanges(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "validator.GetActiveSetChanges")
+	defer span.End()
+
+	stateId := mux.Vars(r)["state_id"]
+	if stateId == "" {
+		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+
+	st, err := s.Stater.State(ctx, []byte(stateId))
+	if err != nil {
+		shared.WriteStateFetchError(w, err)
+		return
+	}
+	stEpoch := slots.ToEpoch(st.Slot())
+
+	as, rpcError := s.CoreService.ValidatorActiveSetChanges(ctx, stEpoch)
+	if rpcError != nil {
+		httputil.HandleError(w, rpcError.Err.Error(), core.ErrorReasonToHTTP(rpcError.Reason))
+		return
+	}
+
+	response := &structs.ActiveSetChanges{
+		Epoch:               fmt.Sprintf("%d", as.Epoch),
+		ActivatedPublicKeys: byteSlice2dToStringSlice(as.ActivatedPublicKeys),
+		ActivatedIndices:    uint64SliceToStringSlice(as.ActivatedIndices),
+		ExitedPublicKeys:    byteSlice2dToStringSlice(as.ExitedPublicKeys),
+		ExitedIndices:       uint64SliceToStringSlice(as.ExitedIndices),
+		SlashedPublicKeys:   byteSlice2dToStringSlice(as.SlashedPublicKeys),
+		SlashedIndices:      uint64SliceToStringSlice(as.SlashedIndices),
+		EjectedPublicKeys:   byteSlice2dToStringSlice(as.EjectedPublicKeys),
+		EjectedIndices:      uint64SliceToStringSlice(as.EjectedIndices),
+	}
+	httputil.WriteJson(w, response)
+}
+
+func byteSlice2dToStringSlice(byteArrays [][]byte) []string {
+	s := make([]string, len(byteArrays))
+	for i, b := range byteArrays {
+		s[i] = hexutil.Encode(b)
+	}
+	return s
+}
+
+func uint64SliceToStringSlice(indices []primitives.ValidatorIndex) []string {
+	s := make([]string, len(indices))
+	for i, u := range indices {
+		s[i] = fmt.Sprintf("%d", u)
+	}
+	return s
+}