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",
@@ -26,7 +25,6 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
-        "receive_sidecar.go",
         "service.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
@@ -49,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",
@@ -85,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",
@@ -118,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",
@@ -175,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

@@ -51,12 +51,6 @@ type BlobReceiver interface {
 	ReceiveBlob(context.Context, blocks.VerifiedROBlob) error
 }
 
-// DataColumnReceiver interface defines the methods of chain service for receiving new
-// data columns
-type DataColumnReceiver interface {
-	ReceiveDataColumn(context.Context, *ethpb.DataColumnSidecar) error
-}
-
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -83,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)
 
@@ -157,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)
@@ -199,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/blockchain/receive_sidecar.go

@@ -1,12 +0,0 @@
-package blockchain
-
-import (
-	"context"
-
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-)
-
-func (s *Service) ReceiveDataColumn(ctx context.Context, ds *ethpb.DataColumnSidecar) error {
-	// TODO
-	return nil
-}

beacon-chain/blockchain/testing/mock.go

@@ -628,11 +628,6 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 	return nil
 }
 
-// ReceiveDataColumn implements the same method in chain service
-func (c *ChainService) ReceiveDataColumn(_ context.Context, _ *ethpb.DataColumnSidecar) error {
-	return nil
-}
-
 // TargetRootForEpoch mocks the same method in the chain service
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/cache/BUILD.bazel

@@ -8,7 +8,6 @@ go_library(
         "attestation_data.go",
         "balance_cache_key.go",
         "checkpoint_state.go",
-        "column_subnet_ids.go",
         "committee.go",
         "committee_disabled.go",  # keep
         "committees.go",

beacon-chain/cache/column_subnet_ids.go

@@ -1,65 +0,0 @@
-package cache
-
-import (
-	"sync"
-	"time"
-
-	"github.com/patrickmn/go-cache"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-)
-
-type columnSubnetIDs struct {
-	colSubCache *cache.Cache
-	colSubLock  sync.RWMutex
-}
-
-// ColumnSubnetIDs for column subnet participants
-var ColumnSubnetIDs = newColumnSubnetIDs()
-
-const columnKey = "columns"
-
-func newColumnSubnetIDs() *columnSubnetIDs {
-	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
-	// Set the default duration of a column subnet subscription as the column expiry period.
-	subLength := epochDuration * time.Duration(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
-	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
-	return &columnSubnetIDs{colSubCache: persistentCache}
-}
-
-// GetColumnSubnets retrieves the data column subnets.
-func (s *columnSubnetIDs) GetColumnSubnets() ([]uint64, bool, time.Time) {
-	s.colSubLock.RLock()
-	defer s.colSubLock.RUnlock()
-
-	id, duration, ok := s.colSubCache.GetWithExpiration(columnKey)
-	if !ok {
-		return nil, false, time.Time{}
-	}
-	// Retrieve indices from the cache.
-	idxs, ok := id.([]uint64)
-	if !ok {
-		return nil, false, time.Time{}
-	}
-
-	return idxs, ok, duration
-}
-
-// AddColumnSubnets adds the relevant data column subnets.
-func (s *columnSubnetIDs) AddColumnSubnets(colIdx []uint64) {
-	s.colSubLock.Lock()
-	defer s.colSubLock.Unlock()
-
-	s.colSubCache.Set(columnKey, colIdx, 0)
-}
-
-// EmptyAllCaches empties out all the related caches and flushes any stored
-// entries on them. This should only ever be used for testing, in normal
-// production, handling of the relevant subnets for each role is done
-// separately.
-func (s *columnSubnetIDs) EmptyAllCaches() {
-	// Clear the cache.
-	s.colSubLock.Lock()
-	defer s.colSubLock.Unlock()
-
-	s.colSubCache.Flush()
-}

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/blocks/signature.go

@@ -96,24 +96,6 @@ func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.Sig
 	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
 }
 
-func VerifyBlockHeaderSignatureUsingCurrentFork(beaconState state.BeaconState, header *ethpb.SignedBeaconBlockHeader) error {
-	currentEpoch := slots.ToEpoch(header.Header.Slot)
-	fork, err := forks.Fork(currentEpoch)
-	if err != nil {
-		return err
-	}
-	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
-	if err != nil {
-		return err
-	}
-	proposer, err := beaconState.ValidatorAtIndex(header.Header.ProposerIndex)
-	if err != nil {
-		return err
-	}
-	proposerPubKey := proposer.PublicKey
-	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
-}
-
 // VerifyBlockSignatureUsingCurrentFork verifies the proposer signature of a beacon block. This differs
 // from the above method by not using fork data from the state and instead retrieving it
 // via the respective epoch.

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/feed/operation/events.go

@@ -32,9 +32,6 @@ const (
 
 	// AttesterSlashingReceived is sent after an attester slashing is received from gossip or rpc
 	AttesterSlashingReceived = 8
-
-	// DataColumnSidecarReceived is sent after a data column sidecar is received from gossip or rpc.
-	DataColumnSidecarReceived = 9
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -80,7 +77,3 @@ type ProposerSlashingReceivedData struct {
 type AttesterSlashingReceivedData struct {
 	AttesterSlashing ethpb.AttSlashing
 }
-
-type DataColumnSidecarReceivedData struct {
-	DataColumn *ethpb.DataColumnSidecar
-}

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/peerdas/BUILD.bazel

@@ -1,21 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["helpers.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
-        "@com_github_holiman_uint256//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)

beacon-chain/core/peerdas/helpers.go

@@ -1,245 +0,0 @@
-package peerdas
-
-import (
-	"encoding/binary"
-
-	cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go"
-	"github.com/holiman/uint256"
-
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	errors "github.com/pkg/errors"
-	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/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-)
-
-const (
-	// Number of field elements per extended blob
-	fieldElementsPerExtBlob = 2 * cKzg4844.FieldElementsPerBlob
-
-	// Bytes per cell
-	bytesPerCell = cKzg4844.FieldElementsPerCell * cKzg4844.BytesPerFieldElement
-
-	// Number of cells in the extended matrix
-	extendedMatrixSize = fieldparams.MaxBlobsPerBlock * cKzg4844.CellsPerExtBlob
-)
-
-type (
-	extendedMatrix []cKzg4844.Cell
-
-	cellCoordinate struct {
-		blobIndex uint64
-		cellID    uint64
-	}
-)
-
-var (
-	errCustodySubnetCountTooLarge          = errors.New("custody subnet count larger than data column sidecar subnet count")
-	errCellNotFound                        = errors.New("cell not found (should never happen)")
-	errCurveOrder                          = errors.New("could not set bls curve order as big int")
-	errBlsFieldElementNil                  = errors.New("bls field element is nil")
-	errBlsFieldElementBiggerThanCurveOrder = errors.New("bls field element higher than curve order")
-	errBlsFieldElementDoesNotFit           = errors.New("bls field element does not fit in BytesPerFieldElement")
-)
-
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#helper-functions
-func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) {
-	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
-
-	// Compute the custodied subnets.
-	subnetIds, err := CustodyColumnSubnets(nodeId, custodySubnetCount)
-	if err != nil {
-		return nil, errors.Wrap(err, "custody subnets")
-	}
-
-	columnsPerSubnet := cKzg4844.CellsPerExtBlob / dataColumnSidecarSubnetCount
-
-	// Knowing the subnet ID and the number of columns per subnet, select all the columns the node should custody.
-	// Columns belonging to the same subnet are contiguous.
-	columnIndices := make(map[uint64]bool, custodySubnetCount*columnsPerSubnet)
-	for i := uint64(0); i < columnsPerSubnet; i++ {
-		for subnetId := range subnetIds {
-			columnIndex := dataColumnSidecarSubnetCount*i + subnetId
-			columnIndices[columnIndex] = true
-		}
-	}
-
-	return columnIndices, nil
-}
-
-func CustodyColumnSubnets(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) {
-	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
-
-	// Check if the custody subnet count is larger than the data column sidecar subnet count.
-	if custodySubnetCount > dataColumnSidecarSubnetCount {
-		return nil, errCustodySubnetCountTooLarge
-	}
-
-	// First, compute the subnet IDs that the node should participate in.
-	subnetIds := make(map[uint64]bool, custodySubnetCount)
-
-	for i := uint64(0); uint64(len(subnetIds)) < custodySubnetCount; i++ {
-		nodeIdUInt256, nextNodeIdUInt256 := new(uint256.Int), new(uint256.Int)
-		nodeIdUInt256.SetBytes(nodeId.Bytes())
-		nextNodeIdUInt256.Add(nodeIdUInt256, uint256.NewInt(i))
-		nextNodeIdUInt64 := nextNodeIdUInt256.Uint64()
-		nextNodeId := bytesutil.Uint64ToBytesLittleEndian(nextNodeIdUInt64)
-
-		hashedNextNodeId := hash.Hash(nextNodeId)
-		subnetId := binary.LittleEndian.Uint64(hashedNextNodeId[:8]) % dataColumnSidecarSubnetCount
-
-		if _, exists := subnetIds[subnetId]; !exists {
-			subnetIds[subnetId] = true
-		}
-	}
-
-	return subnetIds, nil
-}
-
-// computeExtendedMatrix computes the extended matrix from the blobs.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#compute_extended_matrix
-func computeExtendedMatrix(blobs []cKzg4844.Blob) (extendedMatrix, error) {
-	matrix := make(extendedMatrix, 0, extendedMatrixSize)
-
-	for i := range blobs {
-		// Chunk a non-extended blob into cells representing the corresponding extended blob.
-		blob := &blobs[i]
-		cells, err := cKzg4844.ComputeCells(blob)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute cells for blob")
-		}
-
-		matrix = append(matrix, cells[:]...)
-	}
-
-	return matrix, nil
-}
-
-// recoverMatrix recovers the extended matrix from some cells.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix
-func recoverMatrix(cellFromCoordinate map[cellCoordinate]cKzg4844.Cell, blobCount uint64) (extendedMatrix, error) {
-	matrix := make(extendedMatrix, 0, extendedMatrixSize)
-
-	for blobIndex := uint64(0); blobIndex < blobCount; blobIndex++ {
-		// Filter all cells that belong to the current blob.
-		cellIds := make([]uint64, 0, cKzg4844.CellsPerExtBlob)
-		for coordinate := range cellFromCoordinate {
-			if coordinate.blobIndex == blobIndex {
-				cellIds = append(cellIds, coordinate.cellID)
-			}
-		}
-
-		// Retrieve cells corresponding to all `cellIds`.
-		cellIdsCount := len(cellIds)
-
-		cells := make([]cKzg4844.Cell, 0, cellIdsCount)
-		for _, cellId := range cellIds {
-			coordinate := cellCoordinate{blobIndex: blobIndex, cellID: cellId}
-			cell, ok := cellFromCoordinate[coordinate]
-			if !ok {
-				return matrix, errCellNotFound
-			}
-
-			cells = append(cells, cell)
-		}
-
-		// Recover all cells.
-		allCellsForRow, err := cKzg4844.RecoverAllCells(cellIds, cells)
-		if err != nil {
-			return matrix, errors.Wrap(err, "recover all cells")
-		}
-
-		matrix = append(matrix, allCellsForRow[:]...)
-	}
-
-	return matrix, nil
-}
-
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix
-func dataColumnSidecars(signedBlock interfaces.SignedBeaconBlock, blobs []cKzg4844.Blob) ([]ethpb.DataColumnSidecar, error) {
-	blobsCount := len(blobs)
-
-	// Get the signed block header.
-	signedBlockHeader, err := signedBlock.Header()
-	if err != nil {
-		return nil, errors.Wrap(err, "signed block header")
-	}
-
-	// Get the block body.
-	block := signedBlock.Block()
-	blockBody := block.Body()
-
-	// Get the blob KZG commitments.
-	blobKzgCommitments, err := blockBody.BlobKzgCommitments()
-	if err != nil {
-		return nil, errors.Wrap(err, "blob KZG commitments")
-	}
-
-	// Compute the KZG commitments inclusion proof.
-	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
-	if err != nil {
-		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
-	}
-
-	// Compute cells and proofs.
-	cells := make([][cKzg4844.CellsPerExtBlob]cKzg4844.Cell, 0, blobsCount)
-	proofs := make([][cKzg4844.CellsPerExtBlob]cKzg4844.KZGProof, 0, blobsCount)
-
-	for i := range blobs {
-		blob := &blobs[i]
-		blobCells, blobProofs, err := cKzg4844.ComputeCellsAndProofs(blob)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute cells and proofs")
-		}
-
-		cells = append(cells, blobCells)
-		proofs = append(proofs, blobProofs)
-	}
-
-	// Get the column sidecars.
-	sidecars := make([]ethpb.DataColumnSidecar, cKzg4844.CellsPerExtBlob)
-	for columnIndex := uint64(0); columnIndex < cKzg4844.CellsPerExtBlob; columnIndex++ {
-		column := make([]cKzg4844.Cell, 0, blobsCount)
-		kzgProofOfColumn := make([]cKzg4844.KZGProof, 0, blobsCount)
-
-		for rowIndex := 0; rowIndex < blobsCount; rowIndex++ {
-			cell := cells[rowIndex][columnIndex]
-			column = append(column, cell)
-
-			kzgProof := proofs[rowIndex][columnIndex]
-			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
-		}
-
-		columnBytes := make([][]byte, 0, blobsCount)
-		for i := range column {
-			cell := column[i]
-
-			cellBytes := make([]byte, 0, bytesPerCell)
-			for _, fieldElement := range cell {
-				cellBytes = append(cellBytes, fieldElement[:]...)
-			}
-
-			columnBytes = append(columnBytes, cellBytes)
-		}
-
-		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
-		for _, kzgProof := range kzgProofOfColumn {
-			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, kzgProof[:])
-		}
-
-		sidecars = append(sidecars, ethpb.DataColumnSidecar{
-			ColumnIndex:                  columnIndex,
-			DataColumn:                   columnBytes,
-			KzgCommitments:               blobKzgCommitments,
-			KzgProof:                     kzgProofOfColumnBytes,
-			SignedBlockHeader:            signedBlockHeader,
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		})
-	}
-
-	return sidecars, nil
-}

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/filesystem/blob.go

@@ -246,20 +246,6 @@ func (bs *BlobStorage) Get(root [32]byte, idx uint64) (blocks.VerifiedROBlob, er
 	return verification.BlobSidecarNoop(ro)
 }
 
-// GetColumn retrieves a single DataColumnSidecar by its root and index.
-func (bs *BlobStorage) GetColumn(root [32]byte, idx uint64) (*ethpb.DataColumnSidecar, error) {
-	expected := blobNamer{root: root, index: idx}
-	encoded, err := afero.ReadFile(bs.fs, expected.path())
-	if err != nil {
-		return nil, err
-	}
-	s := &ethpb.DataColumnSidecar{}
-	if err := s.UnmarshalSSZ(encoded); err != nil {
-		return nil, err
-	}
-	return s, nil
-}
-
 // Remove removes all blobs for a given root.
 func (bs *BlobStorage) Remove(root [32]byte) error {
 	rootDir := blobNamer{root: root}.dir()

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/BUILD.bazel

@@ -46,7 +46,6 @@ go_library(
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",

beacon-chain/p2p/discovery.go

@@ -47,11 +47,11 @@ type quicProtocol uint16
 // quicProtocol is the "quic" key, which holds the QUIC port of the node.
 func (quicProtocol) ENRKey() string { return "quic" }
 
-// RefreshPersistentSubnets checks that we are tracking our local persistent subnets for a variety of gossip topics.
-// This routine checks for our attestation, sync committee and data column subnets and updates them if they have
-// been rotated.
-func (s *Service) RefreshPersistentSubnets() {
-	// return early if discv5 isnt running
+// RefreshENR uses an epoch to refresh the enr entry for our node
+// with the tracked committee ids for the epoch, allowing our node
+// to be dynamically discoverable by others given our tracked committee ids.
+func (s *Service) RefreshENR() {
+	// return early if discv5 isn't running
 	if s.dv5Listener == nil || !s.isInitialized() {
 		return
 	}
@@ -60,10 +60,6 @@ func (s *Service) RefreshPersistentSubnets() {
 		log.WithError(err).Error("Could not initialize persistent subnets")
 		return
 	}
-	if err := initializePersistentColumnSubnets(s.dv5Listener.LocalNode().ID()); err != nil {
-		log.WithError(err).Error("Could not initialize persistent column subnets")
-		return
-	}
 
 	bitV := bitfield.NewBitvector64()
 	committees := cache.SubnetIDs.GetAllSubnets()

beacon-chain/p2p/discovery_test.go

@@ -435,7 +435,7 @@ func addPeer(t *testing.T, p *peers.Status, state peerdata.PeerConnectionState)
 	return id
 }
 
-func TestRefreshPersistentSubnets_ForkBoundaries(t *testing.T) {
+func TestRefreshENR_ForkBoundaries(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	// Clean up caches after usage.
 	defer cache.SubnetIDs.EmptyAllCaches()
@@ -601,7 +601,7 @@ func TestRefreshPersistentSubnets_ForkBoundaries(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			s := tt.svcBuilder(t)
-			s.RefreshPersistentSubnets()
+			s.RefreshENR()
 			tt.postValidation(t, s)
 			s.dv5Listener.Close()
 			cache.SubnetIDs.EmptyAllCaches()

beacon-chain/p2p/gossip_topic_mappings.go

@@ -22,7 +22,6 @@ var gossipTopicMappings = map[string]func() proto.Message{
 	SyncCommitteeSubnetTopicFormat:            func() proto.Message { return &ethpb.SyncCommitteeMessage{} },
 	BlsToExecutionChangeSubnetTopicFormat:     func() proto.Message { return &ethpb.SignedBLSToExecutionChange{} },
 	BlobSubnetTopicFormat:                     func() proto.Message { return &ethpb.BlobSidecar{} },
-	DataColumnSubnetTopicFormat:               func() proto.Message { return &ethpb.DataColumnSidecar{} },
 }
 
 // GossipTopicMappings is a function to return the assigned data type

beacon-chain/p2p/interfaces.go

@@ -3,7 +3,6 @@ package p2p
 import (
 	"context"
 
-	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/connmgr"
@@ -82,9 +81,8 @@ type PeerManager interface {
 	PeerID() peer.ID
 	Host() host.Host
 	ENR() *enr.Record
-	NodeID() enode.ID
 	DiscoveryAddresses() ([]multiaddr.Multiaddr, error)
-	RefreshPersistentSubnets()
+	RefreshENR()
 	FindPeersWithSubnet(ctx context.Context, topic string, subIndex uint64, threshold int) (bool, error)
 	AddPingMethod(reqFunc func(ctx context.Context, id peer.ID) error)
 }

beacon-chain/p2p/pubsub_filter_test.go

@@ -90,7 +90,7 @@ func TestService_CanSubscribe(t *testing.T) {
 		formatting := []interface{}{digest}
 
 		// Special case for attestation subnets which have a second formatting placeholder.
-		if topic == AttestationSubnetTopicFormat || topic == SyncCommitteeSubnetTopicFormat || topic == BlobSubnetTopicFormat || topic == DataColumnSubnetTopicFormat {
+		if topic == AttestationSubnetTopicFormat || topic == SyncCommitteeSubnetTopicFormat || topic == BlobSubnetTopicFormat {
 			formatting = append(formatting, 0 /* some subnet ID */)
 		}
 

beacon-chain/p2p/rpc_topic_mappings.go

@@ -43,9 +43,6 @@ const BlobSidecarsByRangeName = "/blob_sidecars_by_range"
 // BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
 const BlobSidecarsByRootName = "/blob_sidecars_by_root"
 
-// DataColumnSidecarsByRootName is the name for the DataColumnSidecarsByRoot v1 message topic.
-const DataColumnSidecarsByRootName = "/data_column_sidecars_by_root"
-
 const (
 	// V1 RPC Topics
 	// RPCStatusTopicV1 defines the v1 topic for the status rpc method.
@@ -68,9 +65,6 @@ const (
 	// RPCBlobSidecarsByRootTopicV1 is a topic for requesting blob sidecars by their block root. New in deneb.
 	// /eth2/beacon_chain/req/blob_sidecars_by_root/1/
 	RPCBlobSidecarsByRootTopicV1 = protocolPrefix + BlobSidecarsByRootName + SchemaVersionV1
-	// RPCDataColumnSidecarsByRootTopicV1 is a topic for requesting data column sidecars by their block root. New in PeerDAS.
-	// /eth2/beacon_chain/req/data_column_sidecars_by_root/1
-	RPCDataColumnSidecarsByRootTopicV1 = protocolPrefix + DataColumnSidecarsByRootName + SchemaVersionV1
 
 	// V2 RPC Topics
 	// RPCBlocksByRangeTopicV2 defines v2 the topic for the blocks by range rpc method.

beacon-chain/p2p/service.go

@@ -226,7 +226,7 @@ func (s *Service) Start() {
 	}
 	// Initialize metadata according to the
 	// current epoch.
-	s.RefreshPersistentSubnets()
+	s.RefreshENR()
 
 	// Periodic functions.
 	async.RunEvery(s.ctx, params.BeaconConfig().TtfbTimeoutDuration(), func() {
@@ -234,7 +234,7 @@ func (s *Service) Start() {
 	})
 	async.RunEvery(s.ctx, 30*time.Minute, s.Peers().Prune)
 	async.RunEvery(s.ctx, time.Duration(params.BeaconConfig().RespTimeout)*time.Second, s.updateMetrics)
-	async.RunEvery(s.ctx, refreshRate, s.RefreshPersistentSubnets)
+	async.RunEvery(s.ctx, refreshRate, s.RefreshENR)
 	async.RunEvery(s.ctx, 1*time.Minute, func() {
 		inboundQUICCount := len(s.peers.InboundConnectedWithProtocol(peers.QUIC))
 		inboundTCPCount := len(s.peers.InboundConnectedWithProtocol(peers.TCP))
@@ -358,15 +358,6 @@ func (s *Service) ENR() *enr.Record {
 	return s.dv5Listener.Self().Record()
 }
 
-// NodeID returns the local node's node ID
-// for discovery.
-func (s *Service) NodeID() enode.ID {
-	if s.dv5Listener == nil {
-		return [32]byte{}
-	}
-	return s.dv5Listener.Self().ID()
-}
-
 // DiscoveryAddresses represents our enr addresses as multiaddresses.
 func (s *Service) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	if s.dv5Listener == nil {

beacon-chain/p2p/subnets.go

@@ -13,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -207,25 +206,6 @@ func initializePersistentSubnets(id enode.ID, epoch primitives.Epoch) error {
 	return nil
 }
 
-func initializePersistentColumnSubnets(id enode.ID) error {
-	_, ok, expTime := cache.ColumnSubnetIDs.GetColumnSubnets()
-	if ok && expTime.After(time.Now()) {
-		return nil
-	}
-	subsMap, err := peerdas.CustodyColumnSubnets(id, params.BeaconConfig().CustodyRequirement)
-	if err != nil {
-		return err
-	}
-
-	subs := make([]uint64, 0, len(subsMap))
-	for sub := range subsMap {
-		subs = append(subs, sub)
-	}
-
-	cache.ColumnSubnetIDs.AddColumnSubnets(subs)
-	return nil
-}
-
 // Spec pseudocode definition:
 //
 // def compute_subscribed_subnets(node_id: NodeID, epoch: Epoch) -> Sequence[SubnetID]:

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -3,7 +3,6 @@ package testing
 import (
 	"context"
 
-	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/control"
@@ -56,11 +55,6 @@ func (_ *FakeP2P) ENR() *enr.Record {
 	return new(enr.Record)
 }
 
-// NodeID returns the node id of the local peer.
-func (_ *FakeP2P) NodeID() enode.ID {
-	return [32]byte{}
-}
-
 // DiscoveryAddresses -- fake
 func (_ *FakeP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return nil, nil
@@ -71,8 +65,8 @@ func (_ *FakeP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ i
 	return false, nil
 }
 
-// RefreshPersistentSubnets mocks the p2p func.
-func (_ *FakeP2P) RefreshPersistentSubnets() {}
+// RefreshENR mocks the p2p func.
+func (_ *FakeP2P) RefreshENR() {}
 
 // LeaveTopic -- fake.
 func (_ *FakeP2P) LeaveTopic(_ string) error {

beacon-chain/p2p/testing/mock_peermanager.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 
-	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -40,11 +39,6 @@ func (m MockPeerManager) ENR() *enr.Record {
 	return m.Enr
 }
 
-// NodeID .
-func (m MockPeerManager) NodeID() enode.ID {
-	return [32]byte{}
-}
-
 // DiscoveryAddresses .
 func (m MockPeerManager) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	if m.FailDiscoveryAddr {
@@ -53,8 +47,8 @@ func (m MockPeerManager) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return m.DiscoveryAddr, nil
 }
 
-// RefreshPersistentSubnets .
-func (_ MockPeerManager) RefreshPersistentSubnets() {}
+// RefreshENR .
+func (_ MockPeerManager) RefreshENR() {}
 
 // FindPeersWithSubnet .
 func (_ MockPeerManager) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {

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/p2p/testing/p2p.go

@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	core "github.com/libp2p/go-libp2p/core"
@@ -264,11 +263,6 @@ func (_ *TestP2P) ENR() *enr.Record {
 	return new(enr.Record)
 }
 
-// NodeID returns the node id of the local peer.
-func (_ *TestP2P) NodeID() enode.ID {
-	return [32]byte{}
-}
-
 // DiscoveryAddresses --
 func (_ *TestP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return nil, nil
@@ -366,8 +360,8 @@ func (_ *TestP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ i
 	return false, nil
 }
 
-// RefreshPersistentSubnets mocks the p2p func.
-func (_ *TestP2P) RefreshPersistentSubnets() {}
+// RefreshENR mocks the p2p func.
+func (_ *TestP2P) RefreshENR() {}
 
 // ForkDigest mocks the p2p func.
 func (p *TestP2P) ForkDigest() ([4]byte, error) {

beacon-chain/p2p/topics.go

@@ -30,9 +30,6 @@ const (
 	GossipBlsToExecutionChangeMessage = "bls_to_execution_change"
 	// GossipBlobSidecarMessage is the name for the blob sidecar message type.
 	GossipBlobSidecarMessage = "blob_sidecar"
-	// GossipDataColumnSidecarMessage is the name for the data column sidecar message type.
-	GossipDataColumnSidecarMessage = "data_column_sidecar"
-
 	// Topic Formats
 	//
 	// AttestationSubnetTopicFormat is the topic format for the attestation subnet.
@@ -55,6 +52,4 @@ const (
 	BlsToExecutionChangeSubnetTopicFormat = GossipProtocolAndDigest + GossipBlsToExecutionChangeMessage
 	// BlobSubnetTopicFormat is the topic format for the blob subnet.
 	BlobSubnetTopicFormat = GossipProtocolAndDigest + GossipBlobSidecarMessage + "_%d"
-	// DataColumnSubnetTopicFormat is the topic format for the data column subnet.
-	DataColumnSubnetTopicFormat = GossipProtocolAndDigest + GossipDataColumnSidecarMessage + "_%d"
 )

beacon-chain/p2p/types/rpc_errors.go

@@ -9,15 +9,10 @@ var (
 	ErrInvalidSequenceNum     = errors.New("invalid sequence number provided")
 	ErrGeneric                = errors.New("internal service error")
 
-	ErrRateLimited      = errors.New("rate limited")
-	ErrIODeadline       = errors.New("i/o deadline exceeded")
-	ErrInvalidRequest   = errors.New("invalid range, step or count")
-	ErrBlobLTMinRequest = errors.New("blob epoch < minimum_request_epoch")
-
-	ErrDataColumnLTMinRequest   = errors.New("data column epoch < minimum_request_epoch")
-	ErrMaxBlobReqExceeded       = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
-	ErrMaxDataColumnReqExceeded = errors.New("requested more than MAX_REQUEST_DATA_COLUMN_SIDECARS")
-
+	ErrRateLimited         = errors.New("rate limited")
+	ErrIODeadline          = errors.New("i/o deadline exceeded")
+	ErrInvalidRequest      = errors.New("invalid range, step or count")
+	ErrBlobLTMinRequest    = errors.New("blob slot < minimum_request_epoch")
+	ErrMaxBlobReqExceeded  = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
 	ErrResourceUnavailable = errors.New("resource requested unavailable")
-	ErrInvalidColumnIndex  = errors.New("invalid column index requested")
 )

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"