Add a simple cache for signed execution payload header

* process_withdrawal_fn and isParentfull test

* suggestions applied

* minor change

* removed

* lint

* lint fix

* removed Latestheader

* test added with nil error

* tests passing

* IsParentNode Test added

* lint

* fix test

* updated godoc

* fix in godoc

* comment removed

* fixed braces

* removed var

* removed var

* Update beacon-chain/core/blocks/withdrawals.go

* Update beacon-chain/core/blocks/withdrawals_test.go

* gazelle

* test added and removed previous changes in Testprocesswithdrawal

* added check for nil state

* decrease chromatic complexity

---------

Co-authored-by: Potuz <potuz@potuz.net>
Co-authored-by: Potuz <potuz@prysmaticlabs.com>

.github/PULL_REQUEST_TEMPLATE.md

@@ -10,7 +10,6 @@
    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?**
@@ -29,9 +28,3 @@
 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

@@ -1,33 +0,0 @@
-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

.github/workflows/go.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Go mod tidy checker
         id: gomodtidy
@@ -27,11 +27,11 @@ jobs:
       GO111MODULE: on
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
       - name: Set up Go 1.22
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v3
         with:
-          go-version: '1.22.6'
+          go-version: '1.22.3'
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
@@ -43,16 +43,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Set up Go 1.22
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v3
         with:
-          go-version: '1.22.6'
+          go-version: '1.22.3'
           id: go
 
       - name: Golangci-lint
-        uses: golangci/golangci-lint-action@v5
+        uses: golangci/golangci-lint-action@v3
         with:
           version: v1.55.2
           args: --config=.golangci.yml --out-${NO_FUTURE}format colored-line-number
@@ -62,13 +62,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up Go 1.x
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v2
         with:
-          go-version: '1.22.6'
+          go-version: '1.22.3'
         id: go
 
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Get dependencies
         run: |

.golangci.yml

@@ -6,7 +6,7 @@ run:
     - proto
     - tools/analyzers
   timeout: 10m
-  go: '1.22.6'
+  go: '1.22.3'
 
 linters:
   enable-all: true

CONTRIBUTING.md

@@ -6,9 +6,6 @@ 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!
 
-> [!IMPORTANT] 
-> 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.**
@@ -123,19 +120,15 @@ $ 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. Add an entry to CHANGELOG.md.**
+**16. Create a pull request.**
 
-If your change is user facing, you must include a CHANGELOG.md entry. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
+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.
 
-**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.**
+**17. 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.
 
-**19. If the number of commits becomes excessive, you may be asked to squash your commits.**
+**18. 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...
 
@@ -143,7 +136,7 @@ Core Contributors may ask questions and request that you make edits. If you set
 $ git merge-base feature-in-progress-branch prysm/master
 ```
 
-**20. The previous command will return a commit-hash that you should use in the following command.**
+**19. The previous command will return a commit-hash that you should use in the following command.**
 
 ```
 $ git rebase -i commit-hash
@@ -167,30 +160,13 @@ 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.
 
-**21. Update your pull request with the following command.**
+**20. Update your pull request with the following command.**
 
 ```
 $ git push myrepo feature-in-progress-branch -f
 ```
 
-**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.
+**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.**
 
 ## 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.5"
+consensus_spec_version = "v1.5.0-alpha.3"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-R9vG5HEL5eGMOAmbkKfJ2jfelNqL5V0xBUPiXOiGM6U=",
+    integrity = "sha256-+byv+GUOQytex5GgtjBGVoNDseJZbiBdAjEtlgCbjEo=",
     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-AEIiEOlf1XuxoRMCsN+kgJMo4LrS05+biTA1p/7Ro00=",
+    integrity = "sha256-JJUy/jT1h3kGQkinTuzL7gMOA1+qgmPgJXVrYuH63Cg=",
     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-LH/Xr20yrJRYnbpjRGupMWTIOWt3cpxZJWXgThwVDsk=",
+    integrity = "sha256-T2VM4Qd0SwgGnTjWxjOX297DqEsovO9Ueij1UEJy48Y=",
     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-mlytz4MPjKh0DwV7FMiAtnRbJw9B6o78/x66/vmnYc8=",
+    integrity = "sha256-OP9BCBcQ7i+93bwj7ktY8pZ5uWsGjgTe4XTp7BDhX+I=",
     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/client/builder/BUILD.bazel

@@ -21,7 +21,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
@@ -29,6 +28,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

api/client/builder/client.go

@@ -19,11 +19,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 const (

api/server/structs/block.go

@@ -317,94 +317,6 @@ 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"`
@@ -533,49 +445,3 @@ 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,42 +340,6 @@ 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 {
@@ -405,41 +369,6 @@ 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 {
@@ -694,18 +623,6 @@ 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
@@ -731,31 +648,6 @@ 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 {
@@ -773,126 +665,6 @@ 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
@@ -1158,138 +930,6 @@ 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
@@ -1317,33 +957,6 @@ 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
@@ -1474,37 +1087,3 @@ 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,185 +593,3 @@ 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_lightclient.go

@@ -1,24 +1,20 @@
 package structs
 
-type LightClientHeader struct {
-	Beacon *BeaconBlockHeader `json:"beacon"`
-}
-
 type LightClientBootstrapResponse struct {
 	Version string                `json:"version"`
 	Data    *LightClientBootstrap `json:"data"`
 }
 
 type LightClientBootstrap struct {
-	Header                     *LightClientHeader `json:"header"`
+	Header                     *BeaconBlockHeader `json:"header"`
 	CurrentSyncCommittee       *SyncCommittee     `json:"current_sync_committee"`
 	CurrentSyncCommitteeBranch []string           `json:"current_sync_committee_branch"`
 }
 
 type LightClientUpdate struct {
-	AttestedHeader          *LightClientHeader `json:"attested_header"`
+	AttestedHeader          *BeaconBlockHeader `json:"attested_header"`
 	NextSyncCommittee       *SyncCommittee     `json:"next_sync_committee,omitempty"`
-	FinalizedHeader         *LightClientHeader `json:"finalized_header,omitempty"`
+	FinalizedHeader         *BeaconBlockHeader `json:"finalized_header,omitempty"`
 	SyncAggregate           *SyncAggregate     `json:"sync_aggregate"`
 	NextSyncCommitteeBranch []string           `json:"next_sync_committee_branch,omitempty"`
 	FinalityBranch          []string           `json:"finality_branch,omitempty"`

api/server/structs/other.go

@@ -29,13 +29,6 @@ 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"`
@@ -85,17 +78,6 @@ 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"`
@@ -196,11 +178,6 @@ 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"`
@@ -219,12 +196,6 @@ 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"`
@@ -236,39 +207,3 @@ 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,43 +140,3 @@ 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

@@ -6,6 +6,7 @@ go_library(
         "chain_info.go",
         "chain_info_forkchoice.go",
         "currently_syncing_block.go",
+        "currently_syncing_execution_payload_envelope.go",
         "defragment.go",
         "error.go",
         "execution_engine.go",
@@ -13,6 +14,7 @@ go_library(
         "head.go",
         "head_sync_committee_info.go",
         "init_sync_process_block.go",
+        "lightclient.go",
         "log.go",
         "merge_ascii_art.go",
         "metrics.go",
@@ -25,6 +27,7 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
+        "receive_execution_payload_envelope.go",
         "service.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
@@ -43,11 +46,11 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
+        "//beacon-chain/core/epbs:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_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",
@@ -81,10 +84,10 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -117,6 +120,7 @@ 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",
@@ -125,6 +129,7 @@ go_test(
         "process_block_test.go",
         "receive_attestation_test.go",
         "receive_block_test.go",
+        "receive_execution_payload_envelope_test.go",
         "service_norace_test.go",
         "service_test.go",
         "setup_test.go",
@@ -173,11 +178,13 @@ 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",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -16,9 +16,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -118,6 +118,12 @@ type OptimisticModeFetcher interface {
 	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
 }
 
+// ExecutionPayloadFetcher defines a common interface that returns forkchoice
+// information about payload block hashes
+type ExecutionPayloadFetcher interface {
+	HashInForkchoice([32]byte) bool
+}
+
 // FinalizedCheckpt returns the latest finalized checkpoint from chain store.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 	s.cfg.ForkChoiceStore.RLock()
@@ -399,6 +405,14 @@ func (s *Service) InForkchoice(root [32]byte) bool {
 	return s.cfg.ForkChoiceStore.HasNode(root)
 }
 
+// HashInForkchoice returns true if the given payload block hash is found in
+// forkchoice
+func (s *Service) HashInForkchoice(hash [32]byte) bool {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.HasHash(hash)
+}
+
 // IsOptimisticForRoot takes the root as argument instead of the current head
 // and returns true if it is optimistic.
 func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
@@ -530,6 +544,11 @@ func (s *Service) recoverStateSummary(ctx context.Context, blockRoot [32]byte) (
 	return nil, errBlockDoesNotExist
 }
 
+// PayloadBeingSynced returns whether the payload for the block with the given root is currently being synced
+func (s *Service) PayloadBeingSynced(root [32]byte) bool {
+	return s.payloadBeingSynced.isSyncing(root)
+}
+
 // BlockBeingSynced returns whether the block with the given root is currently being synced
 func (s *Service) BlockBeingSynced(root [32]byte) bool {
 	return s.blockBeingSynced.isSyncing(root)

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -22,6 +22,13 @@ 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()

beacon-chain/blockchain/currently_syncing_execution_payload_envelope.go

@@ -0,0 +1,27 @@
+package blockchain
+
+import "sync"
+
+type currentlySyncingPayload struct {
+	sync.Mutex
+	roots map[[32]byte]struct{}
+}
+
+func (b *currentlySyncingPayload) set(root [32]byte) {
+	b.Lock()
+	defer b.Unlock()
+	b.roots[root] = struct{}{}
+}
+
+func (b *currentlySyncingPayload) unset(root [32]byte) {
+	b.Lock()
+	defer b.Unlock()
+	delete(b.roots, root)
+}
+
+func (b *currentlySyncingPayload) isSyncing(root [32]byte) bool {
+	b.Lock()
+	defer b.Unlock()
+	_, ok := b.roots[root]
+	return ok
+}

beacon-chain/blockchain/execution_engine.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"context"
-	"crypto/sha256"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -21,15 +20,13 @@ import (
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
-const blobCommitmentVersionKZG uint8 = 0x01
-
 var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
 
 // notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
@@ -402,13 +399,7 @@ func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([
 
 	versionedHashes := make([]common.Hash, len(commitments))
 	for i, commitment := range commitments {
-		versionedHashes[i] = ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
 	}
 	return versionedHashes, nil
 }
-
-func ConvertKzgCommitmentToVersionedHash(commitment []byte) common.Hash {
-	versionedHash := sha256.Sum256(commitment)
-	versionedHash[0] = blobCommitmentVersionKZG
-	return versionedHash
-}

beacon-chain/blockchain/execution_engine_test.go

@@ -1056,8 +1056,8 @@ func TestService_removeInvalidBlockAndState(t *testing.T) {
 
 	require.NoError(t, service.removeInvalidBlockAndState(ctx, [][32]byte{r1, r2}))
 
-	require.Equal(t, false, service.hasBlock(ctx, r1))
-	require.Equal(t, false, service.hasBlock(ctx, r2))
+	require.Equal(t, false, service.chainHasBlock(ctx, r1))
+	require.Equal(t, false, service.chainHasBlock(ctx, r2))
 	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r1))
 	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r2))
 	has, err := service.cfg.StateGen.HasState(ctx, r1)

beacon-chain/blockchain/head.go

@@ -18,11 +18,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // UpdateAndSaveHeadWithBalances updates the beacon state head after getting justified balanced from cache.

beacon-chain/blockchain/lightclient.go

@@ -1,20 +1,18 @@
-package light_client
+package blockchain
 
 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 (
@@ -131,16 +129,13 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	}
 
 	// Return result
-	attestedHeaderResult :=
-		&ethpbv2.LightClientHeader{
-			Beacon: &ethpbv1.BeaconBlockHeader{
-				Slot:          attestedHeader.Slot,
-				ProposerIndex: attestedHeader.ProposerIndex,
-				ParentRoot:    attestedHeader.ParentRoot,
-				StateRoot:     attestedHeader.StateRoot,
-				BodyRoot:      attestedHeader.BodyRoot,
-			},
-		}
+	attestedHeaderResult := &ethpbv1.BeaconBlockHeader{
+		Slot:          attestedHeader.Slot,
+		ProposerIndex: attestedHeader.ProposerIndex,
+		ParentRoot:    attestedHeader.ParentRoot,
+		StateRoot:     attestedHeader.StateRoot,
+		BodyRoot:      attestedHeader.BodyRoot,
+	}
 
 	syncAggregateResult := &ethpbv1.SyncAggregate{
 		SyncCommitteeBits:      syncAggregate.SyncCommitteeBits,
@@ -173,7 +168,7 @@ func NewLightClientFinalityUpdateFromBeaconState(
 	}
 
 	// Indicate finality whenever possible
-	var finalizedHeader *ethpbv2.LightClientHeader
+	var finalizedHeader *ethpbv1.BeaconBlockHeader
 	var finalityBranch [][]byte
 
 	if finalizedBlock != nil && !finalizedBlock.IsNil() {
@@ -182,9 +177,9 @@ func NewLightClientFinalityUpdateFromBeaconState(
 			if err != nil {
 				return nil, fmt.Errorf("could not get finalized header %w", err)
 			}
-			finalizedHeader = &ethpbv2.LightClientHeader{Beacon: migration.V1Alpha1SignedHeaderToV1(tempFinalizedHeader).GetMessage()}
+			finalizedHeader = migration.V1Alpha1SignedHeaderToV1(tempFinalizedHeader).GetMessage()
 
-			finalizedHeaderRoot, err := finalizedHeader.Beacon.HashTreeRoot()
+			finalizedHeaderRoot, err := finalizedHeader.HashTreeRoot()
 			if err != nil {
 				return nil, fmt.Errorf("could not get finalized header root %w", err)
 			}
@@ -197,13 +192,13 @@ func NewLightClientFinalityUpdateFromBeaconState(
 				return nil, fmt.Errorf("invalid finalized header root %v", attestedState.FinalizedCheckpoint().Root)
 			}
 
-			finalizedHeader = &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
+			finalizedHeader = &ethpbv1.BeaconBlockHeader{
 				Slot:          0,
 				ProposerIndex: 0,
 				ParentRoot:    make([]byte, 32),
 				StateRoot:     make([]byte, 32),
 				BodyRoot:      make([]byte, 32),
-			}}
+			}
 		}
 
 		var bErr error
@@ -212,13 +207,13 @@ func NewLightClientFinalityUpdateFromBeaconState(
 			return nil, fmt.Errorf("could not get finalized root proof %w", bErr)
 		}
 	} else {
-		finalizedHeader = &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
+		finalizedHeader = &ethpbv1.BeaconBlockHeader{
 			Slot:          0,
 			ProposerIndex: 0,
 			ParentRoot:    make([]byte, 32),
 			StateRoot:     make([]byte, 32),
 			BodyRoot:      make([]byte, 32),
-		}}
+		}
 
 		finalityBranch = make([][]byte, FinalityBranchNumOfLeaves)
 		for i := 0; i < FinalityBranchNumOfLeaves; i++ {

beacon-chain/blockchain/lightclient_test.go

@@ -0,0 +1,160 @@
+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/metrics.go

@@ -182,6 +182,10 @@ var (
 		Name: "chain_service_processing_milliseconds",
 		Help: "Total time to call a chain service in ReceiveBlock()",
 	})
+	executionEngineProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
+		Name: "execution_engine_processing_milliseconds",
+		Help: "Total time to process an execution payload envelope in ReceiveExecutionPayloadEnvelope()",
+	})
 	dataAvailWaitedTime = promauto.NewSummary(prometheus.SummaryOpts{
 		Name: "da_waited_time_milliseconds",
 		Help: "Total time spent waiting for a data availability check in ReceiveBlock()",

beacon-chain/blockchain/options.go

@@ -1,6 +1,8 @@
 package blockchain
 
 import (
+	"sync"
+
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
@@ -69,6 +71,22 @@ func WithDepositCache(c cache.DepositCache) Option {
 	}
 }
 
+// WithPayloadAttestationCache for payload attestation cache.
+func WithPayloadAttestationCache(c *cache.PayloadAttestationCache) Option {
+	return func(s *Service) error {
+		s.cfg.PayloadAttestationCache = c
+		return nil
+	}
+}
+
+// WithPayloadEnvelopeCache for payload envelope cache.
+func WithPayloadEnvelopeCache(c *sync.Map) Option {
+	return func(s *Service) error {
+		s.cfg.PayloadEnvelopeCache = c
+		return nil
+	}
+}
+
 // WithPayloadIDCache for payload ID cache.
 func WithPayloadIDCache(c *cache.PayloadIDCache) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation.go

@@ -97,7 +97,7 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	// We assume trusted attestation in this function has verified signature.
 
 	// Update forkchoice store with the new attestation for updating weight.
-	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
+	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Slot)
 
 	return nil
 }

beacon-chain/blockchain/process_block.go

@@ -25,12 +25,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	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"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // A custom slot deadline for processing state slots in our cache.
@@ -375,7 +375,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		}
 		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
-			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
+			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Slot)
 		} else if err := s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
 			return err
 		}

beacon-chain/blockchain/process_block_helpers.go

@@ -5,8 +5,6 @@ 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"
@@ -22,11 +20,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.
@@ -178,7 +176,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		}
 	}
 
-	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
+	update, err := NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -193,7 +191,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	// Return the result
 	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    lightclient.CreateLightClientFinalityUpdate(update),
+		Data:    CreateLightClientFinalityUpdate(update),
 	}
 
 	// Send event
@@ -213,7 +211,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 		return 0, errors.Wrap(err, "could not get attested state")
 	}
 
-	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
+	update, err := NewLightClientOptimisticUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -227,7 +225,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	// Return the result
 	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    lightclient.CreateLightClientOptimisticUpdate(update),
+		Data:    CreateLightClientOptimisticUpdate(update),
 	}
 
 	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{

beacon-chain/blockchain/receive_attestation.go

@@ -12,11 +12,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	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"
 )
 
 // reorgLateBlockCountAttestations is the time until the end of the slot in which we count
@@ -177,7 +176,7 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		}
 
 		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
-		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
+		hasBlock := s.chainHasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
 		if !(hasState && hasBlock) {
 			continue
 		}
@@ -191,26 +190,13 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		}
 
 		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
-			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")
+			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")
 		}
 	}
 }

beacon-chain/blockchain/receive_block.go

@@ -21,12 +21,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	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"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
 )
 
@@ -39,6 +39,7 @@ var epochsSinceFinalityExpandCache = primitives.Epoch(4)
 // BlockReceiver interface defines the methods of chain service for receiving and processing new blocks.
 type BlockReceiver interface {
 	ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityStore) error
+	ReceiveExecutionPayloadEnvelope(ctx context.Context, env interfaces.ROExecutionPayloadEnvelope, avs das.AvailabilityStore) error
 	ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityStore) error
 	HasBlock(ctx context.Context, root [32]byte) bool
 	RecentBlockSlot(root [32]byte) (primitives.Slot, error)

beacon-chain/blockchain/receive_execution_payload_envelope.go

@@ -0,0 +1,149 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+	"golang.org/x/sync/errgroup"
+)
+
+// ReceiveExecutionPayloadEnvelope is a function that defines the operations (minus pubsub)
+// that are performed on a received execution payload envelope. The operations consist of:
+//  1. Validate the payload, apply state transition.
+//  2. Apply fork choice to the processed payload
+//  3. Save latest head info
+func (s *Service) ReceiveExecutionPayloadEnvelope(ctx context.Context, envelope interfaces.ROExecutionPayloadEnvelope, _ das.AvailabilityStore) error {
+	receivedTime := time.Now()
+	root := envelope.BeaconBlockRoot()
+	s.payloadBeingSynced.set(root)
+	defer s.payloadBeingSynced.unset(root)
+
+	preState, err := s.getPayloadEnvelopePrestate(ctx, envelope)
+	if err != nil {
+		return errors.Wrap(err, "could not get prestate")
+	}
+
+	eg, _ := errgroup.WithContext(ctx)
+	var postState state.BeaconState
+	eg.Go(func() error {
+		if err := epbs.ValidatePayloadStateTransition(ctx, preState, envelope); 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.validateExecutionOnEnvelope(ctx, envelope)
+		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 err
+	}
+	_ = isValidPayload
+	_ = postState
+	daStartTime := time.Now()
+	// TODO: Add DA check
+	daWaitedTime := time.Since(daStartTime)
+	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
+	// TODO: Add Head update, cache handling, postProcessing
+	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
+	executionEngineProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
+	return nil
+}
+
+// notifyNewPayload signals execution engine on a new payload.
+// It returns true if the EL has returned VALID for the block
+func (s *Service) notifyNewEnvelope(ctx context.Context, envelope interfaces.ROExecutionPayloadEnvelope) (bool, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
+	defer span.End()
+
+	payload, err := envelope.Execution()
+	if err != nil {
+		return false, errors.Wrap(err, "could not get execution payload")
+	}
+
+	versionedHashes := envelope.VersionedHashes()
+	root := envelope.BeaconBlockRoot()
+	parentRoot, err := s.ParentRoot(root)
+	if err != nil {
+		return false, errors.Wrap(err, "could not get parent block root")
+	}
+	pr := common.Hash(parentRoot)
+	lastValidHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr)
+	switch {
+	case err == nil:
+		newPayloadValidNodeCount.Inc()
+		return true, nil
+	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
+		newPayloadOptimisticNodeCount.Inc()
+		log.WithFields(logrus.Fields{
+			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
+		}).Info("Called new payload with optimistic block")
+		return false, nil
+	case errors.Is(err, execution.ErrInvalidPayloadStatus):
+		lvh := bytesutil.ToBytes32(lastValidHash)
+		return false, invalidBlock{
+			error:         ErrInvalidPayload,
+			lastValidHash: lvh,
+		}
+	default:
+		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
+	}
+}
+
+// validateExecutionOnEnvelope notifies the engine of the incoming execution payload and returns true if the payload is valid
+func (s *Service) validateExecutionOnEnvelope(ctx context.Context, e interfaces.ROExecutionPayloadEnvelope) (bool, error) {
+	isValidPayload, err := s.notifyNewEnvelope(ctx, e)
+	if err == nil {
+		return isValidPayload, nil
+	}
+	blockRoot := e.BeaconBlockRoot()
+	parentRoot, rootErr := s.ParentRoot(blockRoot)
+	if rootErr != nil {
+		return false, errors.Wrap(rootErr, "could not get parent block root")
+	}
+	s.cfg.ForkChoiceStore.Lock()
+	err = s.handleInvalidExecutionError(ctx, err, blockRoot, parentRoot)
+	s.cfg.ForkChoiceStore.Unlock()
+	return false, err
+}
+
+func (s *Service) getPayloadEnvelopePrestate(ctx context.Context, e interfaces.ROExecutionPayloadEnvelope) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.getPayloadEnvelopePreState")
+	defer span.End()
+
+	// Verify incoming payload has a valid pre state.
+	root := e.BeaconBlockRoot()
+	// Verify the referred block is known to forkchoice
+	if !s.InForkchoice(root) {
+		return nil, errors.New("Cannot import execution payload envelope for unknown block")
+	}
+	if err := s.verifyBlkPreState(ctx, root); err != nil {
+		return nil, errors.Wrap(err, "could not verify payload prestate")
+	}
+
+	preState, err := s.cfg.StateGen.StateByRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get pre state")
+	}
+	if preState == nil || preState.IsNil() {
+		return nil, errors.Wrap(err, "nil pre state")
+	}
+	return preState, nil
+}

beacon-chain/blockchain/receive_execution_payload_envelope_test.go

@@ -0,0 +1,99 @@
+package blockchain
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func Test_getPayloadEnvelopePrestate(t *testing.T) {
+	service, tr := minimalTestService(t)
+	ctx, fcs := tr.ctx, tr.fcs
+
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+
+	p := random.ExecutionPayloadEnvelope(t)
+	p.BeaconBlockRoot = service.originBlockRoot[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+
+	_, err = service.getPayloadEnvelopePrestate(ctx, e)
+	require.NoError(t, err)
+}
+
+func Test_notifyNewEnvelope(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx, fcs := tr.ctx, tr.fcs
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+	p := random.ExecutionPayloadEnvelope(t)
+	p.BeaconBlockRoot = service.originBlockRoot[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	engine := &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = engine
+	isValidPayload, err := service.notifyNewEnvelope(ctx, e)
+	require.NoError(t, err)
+	require.Equal(t, true, isValidPayload)
+}
+
+func Test_validateExecutionOnEnvelope(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx, fcs := tr.ctx, tr.fcs
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+	p := random.ExecutionPayloadEnvelope(t)
+	p.BeaconBlockRoot = service.originBlockRoot[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	engine := &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = engine
+	isValidPayload, err := service.validateExecutionOnEnvelope(ctx, e)
+	require.NoError(t, err)
+	require.Equal(t, true, isValidPayload)
+}
+
+func Test_ReceiveExecutionPayloadEnvelope(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx, fcs := tr.ctx, tr.fcs
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+	post := gs.Copy()
+	p := &enginev1.ExecutionPayloadEnvelope{
+		Payload: &enginev1.ExecutionPayloadElectra{
+			ParentHash: make([]byte, 32),
+			BlockHash:  make([]byte, 32),
+		},
+		BeaconBlockRoot:    service.originBlockRoot[:],
+		BlobKzgCommitments: make([][]byte, 0),
+		StateRoot:          make([]byte, 32),
+	}
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	das := &das.MockAvailabilityStore{}
+
+	blockHeader := post.LatestBlockHeader()
+	prevStateRoot, err := post.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	blockHeader.StateRoot = prevStateRoot[:]
+	require.NoError(t, post.SetLatestBlockHeader(blockHeader))
+	stRoot, err := post.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	p.StateRoot = stRoot[:]
+	engine := &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = engine
+	require.NoError(t, service.ReceiveExecutionPayloadEnvelope(ctx, e, das))
+}

beacon-chain/blockchain/service.go

@@ -39,10 +39,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal
@@ -65,6 +65,7 @@ type Service struct {
 	syncComplete                  chan struct{}
 	blobNotifiers                 *blobNotifierMap
 	blockBeingSynced              *currentlySyncingBlock
+	payloadBeingSynced            *currentlySyncingPayload
 	blobStorage                   *filesystem.BlobStorage
 	lastPublishedLightClientEpoch primitives.Epoch
 }
@@ -75,6 +76,8 @@ type config struct {
 	ChainStartFetcher       execution.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
 	DepositCache            cache.DepositCache
+	PayloadAttestationCache *cache.PayloadAttestationCache
+	PayloadEnvelopeCache    *sync.Map
 	PayloadIDCache          *cache.PayloadIDCache
 	TrackedValidatorsCache  *cache.TrackedValidatorsCache
 	AttPool                 attestations.Pool
@@ -179,6 +182,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		blobNotifiers:        bn,
 		cfg:                  &config{},
 		blockBeingSynced:     &currentlySyncingBlock{roots: make(map[[32]byte]struct{})},
+		payloadBeingSynced:   &currentlySyncingPayload{roots: make(map[[32]byte]struct{})},
 	}
 	for _, opt := range opts {
 		if err := opt(srv); err != nil {
@@ -544,7 +548,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 // 2.) Check DB.
 // Checking 1.) is ten times faster than checking 2.)
 // this function requires a lock in forkchoice
-func (s *Service) hasBlock(ctx context.Context, root [32]byte) bool {
+func (s *Service) chainHasBlock(ctx context.Context, root [32]byte) bool {
 	if s.cfg.ForkChoiceStore.HasNode(root) {
 		return true
 	}

beacon-chain/blockchain/service_test.go

@@ -382,8 +382,8 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
 
-	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
-	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
+	assert.Equal(t, false, s.chainHasBlock(ctx, [32]byte{}), "Should not have block")
+	assert.Equal(t, true, s.chainHasBlock(ctx, r), "Should have block")
 }
 
 func TestServiceStop_SaveCachedBlocks(t *testing.T) {

beacon-chain/blockchain/testing/BUILD.bazel

@@ -3,7 +3,10 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     testonly = True,
-    srcs = ["mock.go"],
+    srcs = [
+        "mock.go",
+        "mock_epbs.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing",
     visibility = [
         "//beacon-chain:__subpackages__",

beacon-chain/blockchain/testing/mock.go

@@ -54,6 +54,7 @@ type ChainService struct {
 	DB                          db.Database
 	State                       state.BeaconState
 	Block                       interfaces.ReadOnlySignedBeaconBlock
+	ExecutionPayloadEnvelope    interfaces.ROExecutionPayloadEnvelope
 	VerifyBlkDescendantErr      error
 	stateNotifier               statefeed.Notifier
 	BlocksReceived              []interfaces.ReadOnlySignedBeaconBlock
@@ -68,6 +69,7 @@ type ChainService struct {
 	Genesis                     time.Time
 	ForkChoiceStore             forkchoice.ForkChoicer
 	ReceiveBlockMockErr         error
+	ReceiveEnvelopeMockErr      error
 	OptimisticCheckRootReceived [32]byte
 	FinalizedRoots              map[[32]byte]bool
 	OptimisticRoots             map[[32]byte]bool

beacon-chain/blockchain/testing/mock_epbs.go

@@ -0,0 +1,25 @@
+package testing
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+// ReceiveExecutionPayloadEnvelope mocks the  method in chain service.
+func (s *ChainService) ReceiveExecutionPayloadEnvelope(ctx context.Context, env interfaces.ROExecutionPayloadEnvelope, _ das.AvailabilityStore) error {
+	if s.ReceiveBlockMockErr != nil {
+		return s.ReceiveBlockMockErr
+	}
+	if s.State == nil {
+		return ErrNilState
+	}
+	if s.State.Slot() == env.Slot() {
+		if err := s.State.SetLatestFullSlot(s.State.Slot()); err != nil {
+			return err
+		}
+	}
+	s.ExecutionPayloadEnvelope = env
+	return nil
+}

beacon-chain/cache/BUILD.bazel

@@ -15,11 +15,13 @@ go_library(
         "doc.go",
         "error.go",
         "interfaces.go",
+        "payload_attestation.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep
         "proposer_indices_type.go",
         "registration.go",
+        "signed_execution_payload_header.go",
         "skip_slot_cache.go",
         "subnet_ids.go",
         "sync_committee.go",
@@ -42,10 +44,12 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
@@ -70,10 +74,12 @@ go_test(
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
         "committee_test.go",
+        "payload_attestation_test.go",
         "payload_id_test.go",
         "private_access_test.go",
         "proposer_indices_test.go",
         "registration_test.go",
+        "signed_execution_payload_header_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",
         "sync_committee_head_state_test.go",
@@ -88,11 +94,13 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",

beacon-chain/cache/payload_attestation.go

@@ -0,0 +1,132 @@
+package cache
+
+import (
+	"errors"
+	"sync"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+var errNilPayloadAttestationMessage = errors.New("nil Payload Attestation Message")
+
+// PayloadAttestationCache keeps a map of all the PTC votes that were seen,
+// already aggregated. The key is the beacon block root.
+type PayloadAttestationCache struct {
+	root         [32]byte
+	attestations [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation
+	sync.Mutex
+}
+
+// Seen returns true if a vote for the given Beacon Block Root has already been processed
+// for this Payload Timeliness Committee index. This will return true even if
+// the Payload status differs.
+func (p *PayloadAttestationCache) Seen(root [32]byte, idx uint64) bool {
+	p.Lock()
+	defer p.Unlock()
+	if p.root != root {
+		return false
+	}
+	for _, agg := range p.attestations {
+		if agg == nil {
+			continue
+		}
+		if agg.AggregationBits.BitAt(idx) {
+			return true
+		}
+	}
+	return false
+}
+
+// messageToPayloadAttestation creates a PayloadAttestation with a single
+// aggregated bit from the passed PayloadAttestationMessage
+func messageToPayloadAttestation(att *eth.PayloadAttestationMessage, idx uint64) *eth.PayloadAttestation {
+	bits := primitives.NewPayloadAttestationAggregationBits()
+	bits.SetBitAt(idx, true)
+	data := &eth.PayloadAttestationData{
+		BeaconBlockRoot: bytesutil.SafeCopyBytes(att.Data.BeaconBlockRoot),
+		Slot:            att.Data.Slot,
+		PayloadStatus:   att.Data.PayloadStatus,
+	}
+	return &eth.PayloadAttestation{
+		AggregationBits: bits,
+		Data:            data,
+		Signature:       bytesutil.SafeCopyBytes(att.Signature),
+	}
+}
+
+// aggregateSigFromMessage returns the aggregated signature from a Payload
+// Attestation by adding the passed signature in the PayloadAttestationMessage,
+// no signature validation is performed.
+func aggregateSigFromMessage(aggregated *eth.PayloadAttestation, message *eth.PayloadAttestationMessage) ([]byte, error) {
+	aggSig, err := bls.SignatureFromBytesNoValidation(aggregated.Signature)
+	if err != nil {
+		return nil, err
+	}
+	sig, err := bls.SignatureFromBytesNoValidation(message.Signature)
+	if err != nil {
+		return nil, err
+	}
+	return bls.AggregateSignatures([]bls.Signature{aggSig, sig}).Marshal(), nil
+}
+
+// Add adds a PayloadAttestationMessage to the internal cache of aggregated
+// PayloadAttestations.
+// If the index has already been seen for this attestation status the function does nothing.
+// If the root is not the cached root, the function will clear the previous cache
+// This function assumes that the message has already been validated. In
+// particular that the signature is valid and that the block root corresponds to
+// the given slot in the attestation data.
+func (p *PayloadAttestationCache) Add(att *eth.PayloadAttestationMessage, idx uint64) error {
+	if att == nil || att.Data == nil || att.Data.BeaconBlockRoot == nil {
+		return errNilPayloadAttestationMessage
+	}
+	p.Lock()
+	defer p.Unlock()
+	root := [32]byte(att.Data.BeaconBlockRoot)
+	if p.root != root {
+		p.root = root
+		p.attestations = [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{}
+	}
+	agg := p.attestations[att.Data.PayloadStatus]
+	if agg == nil {
+		p.attestations[att.Data.PayloadStatus] = messageToPayloadAttestation(att, idx)
+		return nil
+	}
+	if agg.AggregationBits.BitAt(idx) {
+		return nil
+	}
+	sig, err := aggregateSigFromMessage(agg, att)
+	if err != nil {
+		return err
+	}
+	agg.Signature = sig
+	agg.AggregationBits.SetBitAt(idx, true)
+	return nil
+}
+
+// Get returns the aggregated PayloadAttestation for the given root and status
+// if the root doesn't exist or status is invalid, the function returns nil.
+func (p *PayloadAttestationCache) Get(root [32]byte, status primitives.PTCStatus) *eth.PayloadAttestation {
+	p.Lock()
+	defer p.Unlock()
+
+	if p.root != root {
+		return nil
+	}
+	if status >= primitives.PAYLOAD_INVALID_STATUS {
+		return nil
+	}
+
+	return eth.CopyPayloadAttestation(p.attestations[status])
+}
+
+// Clear clears the internal map
+func (p *PayloadAttestationCache) Clear() {
+	p.Lock()
+	defer p.Unlock()
+	p.root = [32]byte{}
+	p.attestations = [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{}
+}

beacon-chain/cache/payload_attestation_test.go

@@ -0,0 +1,143 @@
+package cache
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestPayloadAttestationCache(t *testing.T) {
+	p := &PayloadAttestationCache{}
+
+	//Test Has seen
+	root := [32]byte{'r'}
+	idx := uint64(5)
+	require.Equal(t, false, p.Seen(root, idx))
+
+	// Test Add
+	msg := &eth.PayloadAttestationMessage{
+		Signature: bls.NewAggregateSignature().Marshal(),
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: root[:],
+			Slot:            1,
+			PayloadStatus:   primitives.PAYLOAD_PRESENT,
+		},
+	}
+
+	// Add new root
+	require.NoError(t, p.Add(msg, idx))
+	require.Equal(t, true, p.Seen(root, idx))
+	require.Equal(t, root, p.root)
+	att := p.attestations[primitives.PAYLOAD_PRESENT]
+	indices := att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx)}, indices)
+	singleSig := bytesutil.SafeCopyBytes(msg.Signature)
+	require.DeepEqual(t, singleSig, att.Signature)
+
+	// Test Seen
+	require.Equal(t, true, p.Seen(root, idx))
+	require.Equal(t, false, p.Seen(root, idx+1))
+
+	// Add another attestation on the same data
+	msg2 := &eth.PayloadAttestationMessage{
+		Signature: bls.NewAggregateSignature().Marshal(),
+		Data:      att.Data,
+	}
+	idx2 := uint64(7)
+	require.NoError(t, p.Add(msg2, idx2))
+	att = p.attestations[primitives.PAYLOAD_PRESENT]
+	indices = att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx), int(idx2)}, indices)
+	require.DeepNotEqual(t, att.Signature, msg.Signature)
+
+	// Try again the same index
+	require.NoError(t, p.Add(msg2, idx2))
+	att2 := p.attestations[primitives.PAYLOAD_PRESENT]
+	indices = att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx), int(idx2)}, indices)
+	require.DeepEqual(t, att, att2)
+
+	// Test Seen
+	require.Equal(t, true, p.Seen(root, idx2))
+	require.Equal(t, false, p.Seen(root, idx2+1))
+
+	// Add another payload status for a different payload status
+	msg3 := &eth.PayloadAttestationMessage{
+		Signature: bls.NewAggregateSignature().Marshal(),
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: root[:],
+			Slot:            1,
+			PayloadStatus:   primitives.PAYLOAD_WITHHELD,
+		},
+	}
+	idx3 := uint64(17)
+
+	require.NoError(t, p.Add(msg3, idx3))
+	att3 := p.attestations[primitives.PAYLOAD_WITHHELD]
+	indices3 := att3.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx3)}, indices3)
+	require.DeepEqual(t, singleSig, att3.Signature)
+
+	// Add a different root
+	root2 := [32]byte{'s'}
+	msg.Data.BeaconBlockRoot = root2[:]
+	require.NoError(t, p.Add(msg, idx))
+	require.Equal(t, root2, p.root)
+	require.Equal(t, true, p.Seen(root2, idx))
+	require.Equal(t, false, p.Seen(root, idx))
+	att = p.attestations[primitives.PAYLOAD_PRESENT]
+	indices = att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx)}, indices)
+}
+
+func TestPayloadAttestationCache_Get(t *testing.T) {
+	root := [32]byte{1, 2, 3}
+	wrongRoot := [32]byte{4, 5, 6}
+	status := primitives.PAYLOAD_PRESENT
+	invalidStatus := primitives.PAYLOAD_INVALID_STATUS
+
+	cache := &PayloadAttestationCache{
+		root: root,
+		attestations: [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{
+			{
+				Signature: []byte{1},
+			},
+			{
+				Signature: []byte{2},
+			},
+			{
+				Signature: []byte{3},
+			},
+		},
+	}
+
+	t.Run("valid root and status", func(t *testing.T) {
+		result := cache.Get(root, status)
+		require.NotNil(t, result, "Expected a non-nil result")
+		require.DeepEqual(t, cache.attestations[status], result)
+	})
+
+	t.Run("invalid root", func(t *testing.T) {
+		result := cache.Get(wrongRoot, status)
+		require.IsNil(t, result)
+	})
+
+	t.Run("status out of bound", func(t *testing.T) {
+		result := cache.Get(root, invalidStatus)
+		require.IsNil(t, result)
+	})
+
+	t.Run("no attestation", func(t *testing.T) {
+		emptyCache := &PayloadAttestationCache{
+			root:         root,
+			attestations: [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{},
+		}
+
+		result := emptyCache.Get(root, status)
+		require.IsNil(t, result)
+	})
+}

beacon-chain/cache/signed_execution_payload_header.go

@@ -0,0 +1,25 @@
+package cache
+
+import (
+	"sync"
+
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+var (
+	mu                                 sync.RWMutex
+	cachedSignedExecutionPayloadHeader *enginev1.SignedExecutionPayloadHeader
+)
+
+func SaveSignedExecutionPayloadHeader(header *enginev1.SignedExecutionPayloadHeader) {
+	mu.Lock()
+	defer mu.Unlock()
+	cachedSignedExecutionPayloadHeader = header
+}
+
+func SignedExecutionPayloadHeader() *enginev1.SignedExecutionPayloadHeader {
+	mu.RLock()
+	defer mu.RUnlock()
+	return eth.CopySignedExecutionPayloadHeader(cachedSignedExecutionPayloadHeader)
+}

beacon-chain/cache/signed_execution_payload_header_test.go

@@ -0,0 +1,16 @@
+package cache
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func TestSignedExecutionPayloadHeader(t *testing.T) {
+	require.IsNil(t, SignedExecutionPayloadHeader())
+
+	h := random.SignedExecutionPayloadHeader(t)
+	SaveSignedExecutionPayloadHeader(h)
+	require.DeepEqual(t, h, SignedExecutionPayloadHeader())
+}

beacon-chain/core/altair/BUILD.bazel

@@ -34,13 +34,13 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/core/altair/attestation.go

@@ -14,9 +14,9 @@ import (
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
+	"go.opencensus.io/trace"
 )
 
 // ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation

beacon-chain/core/altair/epoch_precompute.go

@@ -10,7 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	"go.opencensus.io/trace"
 )
 
 // AttDelta contains rewards and penalties for a single attestation.

beacon-chain/core/altair/transition.go

@@ -7,7 +7,7 @@ import (
 	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	"go.opencensus.io/trace"
 )
 
 // ProcessEpoch describes the per epoch operations that are performed on the beacon state.

beacon-chain/core/blocks/BUILD.bazel

@@ -40,7 +40,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -50,6 +49,7 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
@@ -107,6 +107,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/core/blocks/attestation.go

@@ -14,10 +14,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	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"
+	"go.opencensus.io/trace"
 )
 
 // ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation
@@ -110,7 +110,25 @@ func VerifyAttestationNoVerifySignature(
 
 	var indexedAtt ethpb.IndexedAtt
 
-	if att.Version() >= version.Electra {
+	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.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
@@ -136,29 +154,6 @@ 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/genesis.go

@@ -12,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"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"
 )
@@ -217,6 +218,42 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
+	case *ethpb.BeaconStateEPBS:
+		kzgs := make([][]byte, 0)
+		kzgRoot, err := ssz.KzgCommitmentsRoot(kzgs)
+		if err != nil {
+			return nil, err
+		}
+		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockEpbs{
+			Block: &ethpb.BeaconBlockEpbs{
+				ParentRoot: params.BeaconConfig().ZeroHash[:],
+				StateRoot:  root[:],
+				Body: &ethpb.BeaconBlockBodyEpbs{
+					RandaoReveal: make([]byte, 96),
+					Eth1Data: &ethpb.Eth1Data{
+						DepositRoot: make([]byte, 32),
+						BlockHash:   make([]byte, 32),
+					},
+					Graffiti: make([]byte, 32),
+					SyncAggregate: &ethpb.SyncAggregate{
+						SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
+						SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+					},
+					SignedExecutionPayloadHeader: &enginev1.SignedExecutionPayloadHeader{
+						Message: &enginev1.ExecutionPayloadHeaderEPBS{
+							ParentBlockHash:        make([]byte, 32),
+							ParentBlockRoot:        make([]byte, 32),
+							BlockHash:              make([]byte, 32),
+							BlobKzgCommitmentsRoot: kzgRoot[:],
+						},
+						Signature: make([]byte, 96),
+					},
+					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
+					PayloadAttestations:   make([]*ethpb.PayloadAttestation, 0),
+				},
+			},
+			Signature: params.BeaconConfig().EmptySignature[:],
+		})
 	default:
 		return nil, ErrUnrecognizedState
 	}

beacon-chain/core/blocks/payload.go

@@ -239,12 +239,47 @@ func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
 // GetBlockPayloadHash returns the hash of the execution payload of the block
 func GetBlockPayloadHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
 	var payloadHash [32]byte
-	if IsPreBellatrixVersion(blk.Version()) {
-		return payloadHash, nil
+	if blk.Version() >= version.EPBS {
+		header, err := blk.Body().SignedExecutionPayloadHeader()
+		if err != nil {
+			return payloadHash, err
+		}
+		payload, err := header.Header()
+		if err != nil {
+			return payloadHash, err
+		}
+		return payload.BlockHash(), nil
 	}
-	payload, err := blk.Body().Execution()
-	if err != nil {
-		return payloadHash, err
+	if blk.Version() >= version.Bellatrix {
+		payload, err := blk.Body().Execution()
+		if err != nil {
+			return payloadHash, err
+		}
+		return bytesutil.ToBytes32(payload.BlockHash()), nil
 	}
-	return bytesutil.ToBytes32(payload.BlockHash()), nil
+	return payloadHash, nil
+}
+
+// GetBlockParentHash returns the hash of the parent execution payload
+func GetBlockParentHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
+	var parentHash [32]byte
+	if blk.Version() >= version.EPBS {
+		header, err := blk.Body().SignedExecutionPayloadHeader()
+		if err != nil {
+			return parentHash, err
+		}
+		payload, err := header.Header()
+		if err != nil {
+			return parentHash, err
+		}
+		return payload.ParentBlockHash(), nil
+	}
+	if blk.Version() >= version.Bellatrix {
+		payload, err := blk.Body().Execution()
+		if err != nil {
+			return parentHash, err
+		}
+		return bytesutil.ToBytes32(payload.ParentHash()), nil
+	}
+	return parentHash, nil
 }

beacon-chain/core/blocks/withdrawals.go

@@ -14,8 +14,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
-	"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/runtime/version"
 )
@@ -115,15 +115,97 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 	return val, nil
 }
 
+func checkWithdrawalsAgainstPayload(
+	executionData interfaces.ExecutionData,
+	numExpected int,
+	expectedRoot [32]byte,
+) error {
+	var wdRoot [32]byte
+	if executionData.IsBlinded() {
+		r, err := executionData.WithdrawalsRoot()
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals root")
+		}
+		copy(wdRoot[:], r)
+	} else {
+		wds, err := executionData.Withdrawals()
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals")
+		}
+
+		if len(wds) != numExpected {
+			return fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), numExpected)
+		}
+
+		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals root")
+		}
+	}
+	if expectedRoot != wdRoot {
+		return fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
+	}
+	return nil
+}
+
+func processWithdrawalStateTransition(
+	st state.BeaconState,
+	expectedWithdrawals []*enginev1.Withdrawal,
+	partialWithdrawalsCount uint64,
+) (err error) {
+	for _, withdrawal := range expectedWithdrawals {
+		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
+		if err != nil {
+			return errors.Wrap(err, "could not decrease balance")
+		}
+	}
+	if st.Version() >= version.Electra {
+		if err := st.DequeuePartialWithdrawals(partialWithdrawalsCount); err != nil {
+			return fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
+		}
+	}
+
+	if len(expectedWithdrawals) > 0 {
+		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
+			return errors.Wrap(err, "could not set next withdrawal index")
+		}
+	}
+	var nextValidatorIndex primitives.ValidatorIndex
+	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
+		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
+		if err != nil {
+			return errors.Wrap(err, "could not get next withdrawal validator index")
+		}
+		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
+		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
+	} else {
+		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
+		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
+			nextValidatorIndex = 0
+		}
+	}
+	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
+		return errors.Wrap(err, "could not set next withdrawal validator index")
+	}
+	return nil
+}
+
 // ProcessWithdrawals processes the validator withdrawals from the provided execution payload
 // into the beacon state.
 //
 // Spec pseudocode definition:
 //
 //	def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//		if state.fork.current_version >= EIP7732_FORK_VERSION :
+//			if not is_parent_block_full(state): # [New in EIP-7732]
+//		 		return
+//
 //	    expected_withdrawals, partial_withdrawals_count = get_expected_withdrawals(state)  # [Modified in Electra:EIP7251]
 //
-//	    assert len(payload.withdrawals) == len(expected_withdrawals)
+//		if state.fork.current_version >= EIP7732_FORK_VERSION :
+//			state.latest_withdrawals_root = hash_tree_root(expected_withdrawals) # [New in EIP-7732]
+//		else :
+//	    	assert len(payload.withdrawals) == len(expected_withdrawals)
 //
 //	    for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
 //	        assert withdrawal == expected_withdrawal
@@ -148,76 +230,39 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 //	        next_validator_index = ValidatorIndex(next_index % len(state.validators))
 //	        state.next_withdrawal_validator_index = next_validator_index
 func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
+	if st.Version() >= version.EPBS {
+		IsParentBlockFull, err := st.IsParentBlockFull()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not check if parent block is full")
+		}
+
+		if !IsParentBlockFull {
+			return nil, nil
+		}
+	}
+
 	expectedWithdrawals, partialWithdrawalsCount, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
 
-	var wdRoot [32]byte
-	if executionData.IsBlinded() {
-		r, err := executionData.WithdrawalsRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
-		wdRoot = bytesutil.ToBytes32(r)
-	} else {
-		wds, err := executionData.Withdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals")
-		}
-
-		if len(wds) != len(expectedWithdrawals) {
-			return nil, fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), len(expectedWithdrawals))
-		}
-
-		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
-	}
-
 	expectedRoot, err := ssz.WithdrawalSliceRoot(expectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals root")
 	}
-	if expectedRoot != wdRoot {
-		return nil, fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
-	}
 
-	for _, withdrawal := range expectedWithdrawals {
-		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
+	if st.Version() >= version.EPBS {
+		err = st.SetLastWithdrawalsRoot(expectedRoot[:])
 		if err != nil {
-			return nil, errors.Wrap(err, "could not decrease balance")
+			return nil, errors.Wrap(err, "could not set withdrawals root")
 		}
-	}
-
-	if st.Version() >= version.Electra {
-		if err := st.DequeuePartialWithdrawals(partialWithdrawalsCount); err != nil {
-			return nil, fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
-		}
-	}
-
-	if len(expectedWithdrawals) > 0 {
-		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
-			return nil, errors.Wrap(err, "could not set next withdrawal index")
-		}
-	}
-	var nextValidatorIndex primitives.ValidatorIndex
-	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
-		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
-		}
-		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
 	} else {
-		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
-		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
-			nextValidatorIndex = 0
+		if err := checkWithdrawalsAgainstPayload(executionData, len(expectedWithdrawals), expectedRoot); err != nil {
+			return nil, err
 		}
 	}
-	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
-		return nil, errors.Wrap(err, "could not set next withdrawal validator index")
+	if err := processWithdrawalStateTransition(st, expectedWithdrawals, partialWithdrawalsCount); err != nil {
+		return nil, err
 	}
 	return st, nil
 }

beacon-chain/core/blocks/withdrawals_test.go

@@ -22,6 +22,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -1132,13 +1133,407 @@ func TestProcessWithdrawals(t *testing.T) {
 						checkPostState(t, test.Control, post)
 					}
 					params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
-
 				})
 			}
 		})
 	}
 }
 
+func TestProcessWithdrawalsEPBS(t *testing.T) {
+	const (
+		currentEpoch             = primitives.Epoch(10)
+		epochInFuture            = primitives.Epoch(12)
+		epochInPast              = primitives.Epoch(8)
+		numValidators            = 128
+		notWithdrawableIndex     = 127
+		notPartiallyWithdrawable = 126
+		maxSweep                 = uint64(80)
+	)
+	maxEffectiveBalance := params.BeaconConfig().MaxEffectiveBalance
+
+	type args struct {
+		Name                            string
+		NextWithdrawalValidatorIndex    primitives.ValidatorIndex
+		NextWithdrawalIndex             uint64
+		FullWithdrawalIndices           []primitives.ValidatorIndex
+		PendingPartialWithdrawalIndices []primitives.ValidatorIndex
+		Withdrawals                     []*enginev1.Withdrawal
+		PendingPartialWithdrawals       []*ethpb.PendingPartialWithdrawal // Electra
+		LatestBlockHash                 []byte                            // EIP-7732
+	}
+	type control struct {
+		NextWithdrawalValidatorIndex primitives.ValidatorIndex
+		NextWithdrawalIndex          uint64
+		Balances                     map[uint64]uint64
+	}
+	type Test struct {
+		Args    args
+		Control control
+	}
+	executionAddress := func(i primitives.ValidatorIndex) []byte {
+		wc := make([]byte, 20)
+		wc[19] = byte(i)
+		return wc
+	}
+	withdrawalAmount := func(i primitives.ValidatorIndex) uint64 {
+		return maxEffectiveBalance + uint64(i)*100000
+	}
+	fullWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
+		return &enginev1.Withdrawal{
+			Index:          idx,
+			ValidatorIndex: i,
+			Address:        executionAddress(i),
+			Amount:         withdrawalAmount(i),
+		}
+	}
+	PendingPartialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
+		return &enginev1.Withdrawal{
+			Index:          idx,
+			ValidatorIndex: i,
+			Address:        executionAddress(i),
+			Amount:         withdrawalAmount(i) - maxEffectiveBalance,
+		}
+	}
+	tests := []Test{
+		{
+			Args: args{
+				Name:                         "success no withdrawals",
+				NextWithdrawalValidatorIndex: 10,
+				NextWithdrawalIndex:          3,
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 90,
+				NextWithdrawalIndex:          3,
+			},
+		},
+		{
+			Args: args{
+				Name:                         "success one full withdrawal",
+				NextWithdrawalIndex:          3,
+				NextWithdrawalValidatorIndex: 5,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{70},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(70, 3),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 85,
+				NextWithdrawalIndex:          4,
+				Balances:                     map[uint64]uint64{70: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success one partial withdrawal",
+				NextWithdrawalIndex:             21,
+				NextWithdrawalValidatorIndex:    120,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(7, 21),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 72,
+				NextWithdrawalIndex:          22,
+				Balances:                     map[uint64]uint64{7: maxEffectiveBalance},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "success many full withdrawals",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          25,
+				Balances:                     map[uint64]uint64{7: 0, 19: 0, 28: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "less than max sweep at end",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{80, 81, 82, 83},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(80, 22), fullWithdrawal(81, 23), fullWithdrawal(82, 24),
+					fullWithdrawal(83, 25),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          26,
+				Balances:                     map[uint64]uint64{80: 0, 81: 0, 82: 0, 83: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "less than max sweep and beginning",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{4, 5, 6},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(4, 22), fullWithdrawal(5, 23), fullWithdrawal(6, 24),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          25,
+				Balances:                     map[uint64]uint64{4: 0, 5: 0, 6: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success many partial withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    4,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7, 19, 28},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(7, 22), PendingPartialWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          25,
+				Balances: map[uint64]uint64{
+					7:  maxEffectiveBalance,
+					19: maxEffectiveBalance,
+					28: maxEffectiveBalance,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success many withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					fullWithdrawal(28, 28),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 40,
+				NextWithdrawalIndex:          29,
+				Balances: map[uint64]uint64{
+					7: 0, 19: 0, 28: 0,
+					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
+					15: maxEffectiveBalance,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success many withdrawals with pending partial withdrawals in state",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					fullWithdrawal(28, 28),
+				},
+				PendingPartialWithdrawals: []*ethpb.PendingPartialWithdrawal{
+					{
+						Index:  11,
+						Amount: withdrawalAmount(11) - maxEffectiveBalance,
+					},
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 40,
+				NextWithdrawalIndex:          29,
+				Balances: map[uint64]uint64{
+					7: 0, 19: 0, 28: 0,
+					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
+					15: maxEffectiveBalance,
+				},
+			},
+		},
+
+		{
+			Args: args{
+				Name:                         "success more than max fully withdrawals",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 0,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(1, 22), fullWithdrawal(2, 23), fullWithdrawal(3, 24),
+					fullWithdrawal(4, 25), fullWithdrawal(5, 26), fullWithdrawal(6, 27),
+					fullWithdrawal(7, 28), fullWithdrawal(8, 29), fullWithdrawal(9, 30),
+					fullWithdrawal(21, 31), fullWithdrawal(22, 32), fullWithdrawal(23, 33),
+					fullWithdrawal(24, 34), fullWithdrawal(25, 35), fullWithdrawal(26, 36),
+					fullWithdrawal(27, 37),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 28,
+				NextWithdrawalIndex:          38,
+				Balances: map[uint64]uint64{
+					1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,
+					21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success more than max partially withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    0,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(1, 22), PendingPartialWithdrawal(2, 23), PendingPartialWithdrawal(3, 24),
+					PendingPartialWithdrawal(4, 25), PendingPartialWithdrawal(5, 26), PendingPartialWithdrawal(6, 27),
+					PendingPartialWithdrawal(7, 28), PendingPartialWithdrawal(8, 29), PendingPartialWithdrawal(9, 30),
+					PendingPartialWithdrawal(21, 31), PendingPartialWithdrawal(22, 32), PendingPartialWithdrawal(23, 33),
+					PendingPartialWithdrawal(24, 34), PendingPartialWithdrawal(25, 35), PendingPartialWithdrawal(26, 36),
+					PendingPartialWithdrawal(27, 37),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 28,
+				NextWithdrawalIndex:          38,
+				Balances: map[uint64]uint64{
+					1:  maxEffectiveBalance,
+					2:  maxEffectiveBalance,
+					3:  maxEffectiveBalance,
+					4:  maxEffectiveBalance,
+					5:  maxEffectiveBalance,
+					6:  maxEffectiveBalance,
+					7:  maxEffectiveBalance,
+					8:  maxEffectiveBalance,
+					9:  maxEffectiveBalance,
+					21: maxEffectiveBalance,
+					22: maxEffectiveBalance,
+					23: maxEffectiveBalance,
+					24: maxEffectiveBalance,
+					25: maxEffectiveBalance,
+					26: maxEffectiveBalance,
+					27: maxEffectiveBalance,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "Parent Node is not full",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
+				},
+				LatestBlockHash: []byte{1, 2, 3},
+			},
+		},
+	}
+
+	checkPostState := func(t *testing.T, expected control, st state.BeaconState) {
+		l, err := st.NextWithdrawalValidatorIndex()
+		require.NoError(t, err)
+		require.Equal(t, expected.NextWithdrawalValidatorIndex, l)
+
+		n, err := st.NextWithdrawalIndex()
+		require.NoError(t, err)
+		require.Equal(t, expected.NextWithdrawalIndex, n)
+		balances := st.Balances()
+		for idx, bal := range expected.Balances {
+			require.Equal(t, bal, balances[idx])
+		}
+	}
+
+	prepareValidators := func(st state.BeaconState, arguments args) error {
+		validators := make([]*ethpb.Validator, numValidators)
+		if err := st.SetBalances(make([]uint64, numValidators)); err != nil {
+			return err
+		}
+		for i := range validators {
+			v := &ethpb.Validator{}
+			v.EffectiveBalance = maxEffectiveBalance
+			v.WithdrawableEpoch = epochInFuture
+			v.WithdrawalCredentials = make([]byte, 32)
+			v.WithdrawalCredentials[31] = byte(i)
+			if err := st.UpdateBalancesAtIndex(primitives.ValidatorIndex(i), v.EffectiveBalance-uint64(rand.Intn(1000))); err != nil {
+				return err
+			}
+			validators[i] = v
+		}
+		for _, idx := range arguments.FullWithdrawalIndices {
+			if idx != notWithdrawableIndex {
+				validators[idx].WithdrawableEpoch = epochInPast
+			}
+			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
+				return err
+			}
+			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		}
+		for _, idx := range arguments.PendingPartialWithdrawalIndices {
+			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
+				return err
+			}
+		}
+		return st.SetValidators(validators)
+	}
+
+	for _, test := range tests {
+		t.Run(test.Args.Name, func(t *testing.T) {
+			saved := params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep
+			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = maxSweep
+			if test.Args.Withdrawals == nil {
+				test.Args.Withdrawals = make([]*enginev1.Withdrawal, 0)
+			}
+			if test.Args.FullWithdrawalIndices == nil {
+				test.Args.FullWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
+			}
+			if test.Args.PendingPartialWithdrawalIndices == nil {
+				test.Args.PendingPartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
+			}
+			slot, err := slots.EpochStart(currentEpoch)
+			require.NoError(t, err)
+			var st state.BeaconState
+			var p interfaces.ExecutionData
+			spb := &ethpb.BeaconStateEPBS{
+				Slot:                         slot,
+				NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
+				NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
+				PendingPartialWithdrawals:    test.Args.PendingPartialWithdrawals,
+				LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderEPBS{
+					BlockHash: []byte{},
+				},
+				LatestBlockHash: test.Args.LatestBlockHash,
+			}
+			st, err = state_native.InitializeFromProtoUnsafeEpbs(spb)
+			require.NoError(t, err)
+			env := random.ExecutionPayloadEnvelope(t)
+			env.Payload.Withdrawals = test.Args.Withdrawals
+			wp, err := consensusblocks.WrappedROExecutionPayloadEnvelope(env)
+			require.NoError(t, err)
+			p, err = wp.Execution()
+			require.NoError(t, err)
+			err = prepareValidators(st, test.Args)
+			require.NoError(t, err)
+			post, err := blocks.ProcessWithdrawals(st, p)
+			if test.Args.Name == "Parent Node is not full" {
+				require.IsNil(t, post)
+				require.IsNil(t, err)
+			} else {
+				require.NoError(t, err)
+				checkPostState(t, test.Control, post)
+			}
+			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
+		})
+	}
+}
+
 func TestProcessBLSToExecutionChanges(t *testing.T) {
 	spb := &ethpb.BeaconStateCapella{
 		Fork: &ethpb.Fork{

beacon-chain/core/electra/consolidations.go

@@ -49,7 +49,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 		return errors.New("nil state")
 	}
 
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
+	currentEpoch := slots.ToEpoch(st.Slot())
 
 	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 > nextEpoch {
+		if sourceValidator.WithdrawableEpoch > currentEpoch {
 			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
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
+	curEpoch := slots.ToEpoch(st.Slot())
 
 	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 nextEpoch <= v.WithdrawableEpoch() {
+			if curEpoch <= 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/effective_balance_updates.go

@@ -55,9 +55,8 @@ func ProcessEffectiveBalanceUpdates(state state.BeaconState) error {
 
 		if balance+downwardThreshold < val.EffectiveBalance || val.EffectiveBalance+upwardThreshold < balance {
 			effectiveBal := min(balance-balance%effBalanceInc, effectiveBalanceLimit)
-			newVal := ethpb.CopyValidator(val)
-			newVal.EffectiveBalance = effectiveBal
-			return true, newVal, nil
+			val.EffectiveBalance = effectiveBal
+			return true, val, nil
 		}
 		return false, val, nil
 	}

beacon-chain/core/electra/effective_balance_updates_test.go

@@ -11,29 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
-func TestProcessEffectiveBalanceUpdates_SafeCopy(t *testing.T) {
-	pb := &eth.BeaconStateElectra{
-		Validators: []*eth.Validator{
-			{
-				EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
-				WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0x11},
-			},
-		},
-		Balances: []uint64{
-			params.BeaconConfig().MaxEffectiveBalanceElectra * 2,
-		},
-	}
-	st, err := state_native.InitializeFromProtoElectra(pb)
-	require.NoError(t, err)
-	copiedState := st.Copy()
-
-	err = electra.ProcessEffectiveBalanceUpdates(copiedState)
-	require.NoError(t, err)
-
-	require.Equal(t, st.Validators()[0].EffectiveBalance, params.BeaconConfig().MinActivationBalance)
-	require.Equal(t, copiedState.Validators()[0].EffectiveBalance, params.BeaconConfig().MaxEffectiveBalanceElectra)
-}
-
 func TestProcessEffectiveBalnceUpdates(t *testing.T) {
 	effBalanceInc := params.BeaconConfig().EffectiveBalanceIncrement
 	hysteresisInc := effBalanceInc / params.BeaconConfig().HysteresisQuotient

beacon-chain/core/electra/upgrade.go

@@ -40,7 +40,6 @@ 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/epbs/BUILD.bazel

@@ -0,0 +1,38 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "attestation.go",
+        "execution_payload_envelope.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "attestation_test.go",
+        "execution_payload_envelope_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
+    ],
+)

beacon-chain/core/epbs/attestation.go

@@ -0,0 +1,13 @@
+package epbs
+
+import (
+	"fmt"
+)
+
+// RemoveValidatorFlag removes validator flag from existing one.
+func RemoveValidatorFlag(flag, flagPosition uint8) (uint8, error) {
+	if flagPosition > 7 {
+		return flag, fmt.Errorf("flag position %d exceeds length", flagPosition)
+	}
+	return flag & ^(1 << flagPosition), nil
+}

beacon-chain/core/epbs/attestation_test.go

@@ -0,0 +1,93 @@
+package epbs_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestValidatorFlag_Remove(t *testing.T) {
+	tests := []struct {
+		name          string
+		add           []uint8
+		remove        []uint8
+		expectedTrue  []uint8
+		expectedFalse []uint8
+	}{
+		{
+			name:          "none",
+			add:           []uint8{},
+			remove:        []uint8{},
+			expectedTrue:  []uint8{},
+			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+		{
+			name:          "source",
+			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			remove:        []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			expectedTrue:  []uint8{},
+			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+		{
+			name:          "source, target",
+			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
+			remove:        []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			expectedTrue:  []uint8{params.BeaconConfig().TimelyTargetFlagIndex},
+			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+		{
+			name:          "source, target, head",
+			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+			remove:        []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+			expectedTrue:  []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			expectedFalse: []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+	}
+	var err error
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			flag := uint8(0)
+
+			// Add flags.
+			for _, flagPosition := range test.add {
+				flag, err = altair.AddValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+
+				has, err := altair.HasValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+				require.Equal(t, true, has)
+			}
+
+			// Remove flags.
+			for _, flagPosition := range test.remove {
+				flag, err = epbs.RemoveValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+			}
+
+			// Check if flags are set correctly.
+			for _, flagPosition := range test.expectedTrue {
+				has, err := altair.HasValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+				require.Equal(t, true, has)
+			}
+			for _, flagPosition := range test.expectedFalse {
+				has, err := altair.HasValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+				require.Equal(t, false, has)
+			}
+		})
+	}
+}
+
+func TestValidatorFlag_Remove_ExceedsLength(t *testing.T) {
+	_, err := epbs.RemoveValidatorFlag(0, 8)
+	require.ErrorContains(t, "flag position 8 exceeds length", err)
+}
+
+func TestValidatorFlag_Remove_NotSet(t *testing.T) {
+	_, err := epbs.RemoveValidatorFlag(0, 1)
+	require.NoError(t, err)
+}

beacon-chain/core/epbs/execution_payload_envelope.go

@@ -0,0 +1,129 @@
+package epbs
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+)
+
+// ValidatePayloadStateTransition performs the process_execution_payload
+// function.
+func ValidatePayloadStateTransition(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	if err := validateAgainstHeader(ctx, preState, envelope); err != nil {
+		return err
+	}
+	committedHeader, err := preState.LatestExecutionPayloadHeaderEPBS()
+	if err != nil {
+		return err
+	}
+	if err := validateAgainstCommittedBid(committedHeader, envelope); err != nil {
+		return err
+	}
+	if err := processPayloadStateTransition(ctx, preState, envelope); err != nil {
+		return err
+	}
+	return checkPostStateRoot(ctx, preState, envelope)
+}
+
+func processPayloadStateTransition(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	payload, err := envelope.Execution()
+	if err != nil {
+		return err
+	}
+	exe, ok := payload.(interfaces.ExecutionDataElectra)
+	if !ok {
+		return errors.New("could not cast execution data to electra execution data")
+	}
+	preState, err = electra.ProcessDepositRequests(ctx, preState, exe.DepositRequests())
+	if err != nil {
+		return errors.Wrap(err, "could not process deposit receipts")
+	}
+	preState, err = electra.ProcessWithdrawalRequests(ctx, preState, exe.WithdrawalRequests())
+	if err != nil {
+		return errors.Wrap(err, "could not process execution layer withdrawal requests")
+	}
+	if err := electra.ProcessConsolidationRequests(ctx, preState, exe.ConsolidationRequests()); err != nil {
+		return errors.Wrap(err, "could not process consolidation requests")
+	}
+	if err := preState.SetLatestBlockHash(payload.BlockHash()); err != nil {
+		return err
+	}
+	return preState.SetLatestFullSlot(preState.Slot())
+}
+
+func validateAgainstHeader(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	blockHeader := preState.LatestBlockHeader()
+	if blockHeader == nil {
+		return errors.New("invalid nil latest block header")
+	}
+	if len(blockHeader.StateRoot) == 0 || [32]byte(blockHeader.StateRoot) == [32]byte{} {
+		prevStateRoot, err := preState.HashTreeRoot(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not compute previous state root")
+		}
+		blockHeader.StateRoot = prevStateRoot[:]
+		if err := preState.SetLatestBlockHeader(blockHeader); err != nil {
+			return errors.Wrap(err, "could not set latest block header")
+		}
+	}
+	blockHeaderRoot, err := blockHeader.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	beaconBlockRoot := envelope.BeaconBlockRoot()
+	if blockHeaderRoot != beaconBlockRoot {
+		return fmt.Errorf("beacon block root does not match previous header, got: %#x wanted: %#x", beaconBlockRoot, blockHeaderRoot)
+	}
+	return nil
+}
+
+func validateAgainstCommittedBid(
+	committedHeader *enginev1.ExecutionPayloadHeaderEPBS,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	builderIndex := envelope.BuilderIndex()
+	if committedHeader.BuilderIndex != builderIndex {
+		return errors.New("builder index does not match committed header")
+	}
+	kzgRoot, err := envelope.BlobKzgCommitmentsRoot()
+	if err != nil {
+		return err
+	}
+	if [32]byte(committedHeader.BlobKzgCommitmentsRoot) != kzgRoot {
+		return errors.New("blob KZG commitments root does not match committed header")
+	}
+	return nil
+}
+
+func checkPostStateRoot(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	stateRoot, err := preState.HashTreeRoot(ctx)
+	if err != nil {
+		return err
+	}
+	envelopeStateRoot := envelope.StateRoot()
+	if stateRoot != envelopeStateRoot {
+		return errors.New("state root mismatch")
+	}
+	return nil
+}

beacon-chain/core/epbs/execution_payload_envelope_test.go

@@ -0,0 +1,108 @@
+package epbs
+
+import (
+	"context"
+	"testing"
+
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	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/testing/util/random"
+)
+
+func TestProcessPayloadStateTransition(t *testing.T) {
+	bh := [32]byte{'h'}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload.BlockHash = bh[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	validators := make([]*ethpb.Validator, 0)
+	stpb := &ethpb.BeaconStateEPBS{Slot: 3, Validators: validators}
+	st, err := state_native.InitializeFromProtoUnsafeEpbs(stpb)
+	require.NoError(t, err)
+	ctx := context.Background()
+
+	lbh, err := st.LatestBlockHash()
+	require.NoError(t, err)
+	require.Equal(t, [32]byte{}, [32]byte(lbh))
+
+	require.NoError(t, processPayloadStateTransition(ctx, st, e))
+
+	lbh, err = st.LatestBlockHash()
+	require.NoError(t, err)
+	require.Equal(t, bh, [32]byte(lbh))
+
+	lfs, err := st.LatestFullSlot()
+	require.NoError(t, err)
+	require.Equal(t, lfs, st.Slot())
+}
+
+func Test_validateAgainstHeader(t *testing.T) {
+	bh := [32]byte{'h'}
+	payload := &enginev1.ExecutionPayloadElectra{BlockHash: bh[:]}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload = payload
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	stpb := &ethpb.BeaconStateEPBS{Slot: 3}
+	st, err := state_native.InitializeFromProtoUnsafeEpbs(stpb)
+	require.NoError(t, err)
+	ctx := context.Background()
+	require.ErrorContains(t, "invalid nil latest block header", validateAgainstHeader(ctx, st, e))
+
+	prest, _ := util.DeterministicGenesisStateEpbs(t, 64)
+	br := [32]byte{'r'}
+	p.BeaconBlockRoot = br[:]
+	require.ErrorContains(t, "beacon block root does not match previous header", validateAgainstHeader(ctx, prest, e))
+
+	header := prest.LatestBlockHeader()
+	require.NoError(t, err)
+	headerRoot, err := header.HashTreeRoot()
+	require.NoError(t, err)
+	p.BeaconBlockRoot = headerRoot[:]
+	require.NoError(t, validateAgainstHeader(ctx, prest, e))
+}
+
+func Test_validateAgainstCommittedBid(t *testing.T) {
+	payload := &enginev1.ExecutionPayloadElectra{}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload = payload
+	p.BuilderIndex = 1
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	h := &enginev1.ExecutionPayloadHeaderEPBS{}
+	require.ErrorContains(t, "builder index does not match committed header", validateAgainstCommittedBid(h, e))
+
+	h.BuilderIndex = 1
+	p.BlobKzgCommitments = make([][]byte, 6)
+	for i := range p.BlobKzgCommitments {
+		p.BlobKzgCommitments[i] = make([]byte, 48)
+	}
+	h.BlobKzgCommitmentsRoot = make([]byte, 32)
+	require.ErrorContains(t, "blob KZG commitments root does not match committed header", validateAgainstCommittedBid(h, e))
+
+	root, err := e.BlobKzgCommitmentsRoot()
+	require.NoError(t, err)
+	h.BlobKzgCommitmentsRoot = root[:]
+	require.NoError(t, validateAgainstCommittedBid(h, e))
+}
+
+func TestCheckPostStateRoot(t *testing.T) {
+	payload := &enginev1.ExecutionPayloadElectra{}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload = payload
+	p.BuilderIndex = 1
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	ctx := context.Background()
+	st, _ := util.DeterministicGenesisStateEpbs(t, 64)
+	p.StateRoot = make([]byte, 32)
+	require.ErrorContains(t, "state root mismatch", checkPostStateRoot(ctx, st, e))
+	root, err := st.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	p.StateRoot = root[:]
+	require.NoError(t, checkPostStateRoot(ctx, st, e))
+}

beacon-chain/core/epoch/BUILD.bazel

@@ -22,6 +22,7 @@ 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",
     ],
@@ -52,6 +53,7 @@ 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,9 +20,32 @@ 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.
 //
@@ -432,3 +455,51 @@ 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,6 +6,7 @@ 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"
@@ -23,6 +24,131 @@ 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

@@ -24,7 +24,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -48,6 +47,7 @@ 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/attestation.go

@@ -11,10 +11,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	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"
+	"go.opencensus.io/trace"
 )
 
 // ProcessAttestations process the attestations in state and update individual validator's pre computes,

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

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

beacon-chain/core/helpers/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "block.go",
         "genesis.go",
         "metrics.go",
+        "payload_attestation.go",
         "randao.go",
         "rewards_penalties.go",
         "shuffle.go",
@@ -20,11 +21,13 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/epbs:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
@@ -33,7 +36,6 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
@@ -43,6 +45,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 
@@ -53,6 +56,8 @@ go_test(
         "attestation_test.go",
         "beacon_committee_test.go",
         "block_test.go",
+        "exports_test.go",
+        "payload_attestation_test.go",
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
         "randao_test.go",
@@ -63,26 +68,33 @@ go_test(
         "validators_test.go",
         "weak_subjectivity_test.go",
     ],
+    data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     shard_count = 2,
     tags = ["CI_race_detection"],
     deps = [
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/epbs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
+        "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/core/helpers/beacon_committee.go

@@ -213,6 +213,7 @@ type CommitteeAssignment struct {
 	Committee      []primitives.ValidatorIndex
 	AttesterSlot   primitives.Slot
 	CommitteeIndex primitives.CommitteeIndex
+	PtcSlot        primitives.Slot
 }
 
 // verifyAssignmentEpoch verifies if the given epoch is valid for assignment based on the provided state.
@@ -294,7 +295,7 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	if err := verifyAssignmentEpoch(epoch, state); err != nil {
 		return nil, err
 	}
-	startSlot, err := slots.EpochStart(epoch)
+	slot, err := slots.EpochStart(epoch)
 	if err != nil {
 		return nil, err
 	}
@@ -303,14 +304,17 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 		vals[v] = struct{}{}
 	}
 	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
+
+	committees, err := BeaconCommittees(ctx, state, slot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute beacon committees")
+	}
+	ptcPerSlot, ptcMembersPerCommittee := PtcAllocation(len(committees))
 	// Compute committee assignments for each slot in the epoch.
-	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
-		committees, err := BeaconCommittees(ctx, state, slot)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute beacon committees")
-		}
+	endSlot := slot + params.BeaconConfig().SlotsPerEpoch
+	for {
 		for j, committee := range committees {
-			for _, vIndex := range committee {
+			for i, vIndex := range committee {
 				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
 					continue
 				}
@@ -320,8 +324,19 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 				assignments[vIndex].Committee = committee
 				assignments[vIndex].AttesterSlot = slot
 				assignments[vIndex].CommitteeIndex = primitives.CommitteeIndex(j)
+				if uint64(j) < ptcPerSlot && uint64(i) < ptcMembersPerCommittee {
+					assignments[vIndex].PtcSlot = slot
+				}
 			}
 		}
+		slot++
+		if slot == endSlot {
+			break
+		}
+		committees, err = BeaconCommittees(ctx, state, slot)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not compute beacon committees")
+		}
 	}
 	return assignments, nil
 }
@@ -337,6 +352,24 @@ 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

@@ -3,6 +3,7 @@ package helpers_test
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"testing"
 
@@ -10,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
@@ -403,12 +405,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 		helpers.ClearCache()
 
 		require.NoError(t, state.SetSlot(tt.stateSlot))
-		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)))
+		err := helpers.VerifyAttestationBitfieldLengths(context.Background(), state, tt.attestation)
 		if tt.verificationFailure {
 			assert.NotNil(t, err, "Verification succeeded when it was supposed to fail")
 		} else {
@@ -722,15 +719,26 @@ func TestCommitteeIndices(t *testing.T) {
 	assert.DeepEqual(t, []primitives.CommitteeIndex{0, 1, 3}, indices)
 }
 
-func TestAttestationCommittees(t *testing.T) {
-	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
+func TestCommitteeAssignments_PTC(t *testing.T) {
+	helpers.ClearCache()
+	// Create 10 committees. Total 40960 validators.
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+	validatorIndices := make([]primitives.ValidatorIndex, validatorCount)
+
 	for i := 0; i < len(validators); i++ {
+		k := make([]byte, 48)
+		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             k,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
 		}
+		validatorIndices[i] = primitives.ValidatorIndex(i)
 	}
 
-	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
 		Validators:  validators,
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
@@ -754,6 +762,31 @@ func TestAttestationCommittees(t *testing.T) {
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[1])))
 	})
+	as, err := helpers.CommitteeAssignments(context.Background(), state, 1, validatorIndices)
+	require.NoError(t, err)
+
+	// Capture all the slots and all the validator index that belonged in a PTC using a map for verification later.
+	slotValidatorMap := make(map[primitives.Slot][]primitives.ValidatorIndex)
+	for i, a := range as {
+		slotValidatorMap[a.PtcSlot] = append(slotValidatorMap[a.PtcSlot], i)
+	}
+
+	// Verify that all the slots have the correct number of PTC.
+	for s, v := range slotValidatorMap {
+		if s == 0 {
+			continue
+		}
+		// Make sure all the PTC are the correct size from the map.
+		require.Equal(t, len(v), field_params.PTCSize)
+
+		// Get the actual PTC from the beacon state using the helper function
+		ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, s)
+		require.NoError(t, err)
+		for _, index := range ptc {
+			i := slices.Index(v, index)
+			require.NotEqual(t, -1, i) // PTC not found from the assignment map
+		}
+	}
 }
 
 func TestBeaconCommittees(t *testing.T) {

beacon-chain/core/helpers/exports_test.go

@@ -0,0 +1,12 @@
+package helpers
+
+var (
+	ErrNilMessage            = errNilMessage
+	ErrNilData               = errNilData
+	ErrNilBeaconBlockRoot    = errNilBeaconBlockRoot
+	ErrNilPayloadAttestation = errNilPayloadAttestation
+	ErrNilSignature          = errNilSignature
+	ErrNilAggregationBits    = errNilAggregationBits
+	ErrPreEPBSState          = errPreEPBSState
+	ErrCommitteeOverflow     = errCommitteeOverflow
+)

beacon-chain/core/helpers/payload_attestation.go

@@ -0,0 +1,296 @@
+package helpers
+
+import (
+	"context"
+	"slices"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/epbs"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+var (
+	errNilMessage            = errors.New("nil PayloadAttestationMessage")
+	errNilData               = errors.New("nil PayloadAttestationData")
+	errNilBeaconBlockRoot    = errors.New("nil BeaconBlockRoot")
+	errNilPayloadAttestation = errors.New("nil PayloadAttestation")
+	errNilSignature          = errors.New("nil Signature")
+	errNilAggregationBits    = errors.New("nil AggregationBits")
+	errPreEPBSState          = errors.New("beacon state pre ePBS fork")
+	errCommitteeOverflow     = errors.New("beacon committee of insufficient size")
+)
+
+// ValidateNilPayloadAttestationData checks if any composite field of the
+// payload attestation data is nil
+func ValidateNilPayloadAttestationData(data *eth.PayloadAttestationData) error {
+	if data == nil {
+		return errNilData
+	}
+	if data.BeaconBlockRoot == nil {
+		return errNilBeaconBlockRoot
+	}
+	return nil
+}
+
+// ValidateNilPayloadAttestationMessage checks if any composite field of the
+// payload attestation message is nil
+func ValidateNilPayloadAttestationMessage(att *eth.PayloadAttestationMessage) error {
+	if att == nil {
+		return errNilMessage
+	}
+	if att.Signature == nil {
+		return errNilSignature
+	}
+	return ValidateNilPayloadAttestationData(att.Data)
+}
+
+// ValidateNilPayloadAttestation checks if any composite field of the
+// payload attestation is nil
+func ValidateNilPayloadAttestation(att *eth.PayloadAttestation) error {
+	if att == nil {
+		return errNilPayloadAttestation
+	}
+	if att.AggregationBits == nil {
+		return errNilAggregationBits
+	}
+	if att.Signature == nil {
+		return errNilSignature
+	}
+	return ValidateNilPayloadAttestationData(att.Data)
+}
+
+// InPayloadTimelinessCommittee returns whether the given index belongs to the
+// PTC computed from the passed state.
+func InPayloadTimelinessCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, idx primitives.ValidatorIndex) (bool, error) {
+	ptc, err := GetPayloadTimelinessCommittee(ctx, state, slot)
+	if err != nil {
+		return false, err
+	}
+	for _, i := range ptc {
+		if i == idx {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// GetPayloadTimelinessCommittee returns the PTC for the given slot, computed from the passed state as in the
+// spec function `get_ptc`.
+func GetPayloadTimelinessCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) (indices []primitives.ValidatorIndex, err error) {
+	if state.Version() < version.EPBS {
+		return nil, errPreEPBSState
+	}
+	committees, err := BeaconCommittees(ctx, state, slot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get beacon committees")
+	}
+	committeesPerSlot, membersPerCommittee := PtcAllocation(len(committees))
+	for i, committee := range committees {
+		if uint64(i) >= committeesPerSlot {
+			return
+		}
+		if uint64(len(committee)) < membersPerCommittee {
+			return nil, errCommitteeOverflow
+		}
+		indices = append(indices, committee[:membersPerCommittee]...)
+	}
+	return
+}
+
+// PtcAllocation returns:
+// 1. The number of beacon committees that PTC will borrow from in a slot.
+// 2. The number of validators that PTC will borrow from in a beacon committee.
+func PtcAllocation(slotCommittees int) (committeesPerSlot, membersPerCommittee uint64) {
+	committeesPerSlot = math.LargestPowerOfTwo(math.Min(uint64(slotCommittees), fieldparams.PTCSize))
+	membersPerCommittee = fieldparams.PTCSize / committeesPerSlot
+	return
+}
+
+// GetPayloadAttestingIndices returns the set of attester indices corresponding to the given PayloadAttestation.
+//
+// Spec pseudocode definition:
+//
+//	def get_payload_attesting_indices(state: BeaconState, slot: Slot,
+//		payload_attestation: PayloadAttestation) -> Set[ValidatorIndex]:
+//	"""
+//	Return the set of attesting indices corresponding to ``payload_attestation``.
+//	"""
+//	ptc = get_ptc(state, slot)
+//	return set(index for i, index in enumerate(ptc) if payload_attestation.aggregation_bits[i])
+func GetPayloadAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, att *eth.PayloadAttestation) (indices []primitives.ValidatorIndex, err error) {
+	if state.Version() < version.EPBS {
+		return nil, errPreEPBSState
+	}
+
+	ptc, err := GetPayloadTimelinessCommittee(ctx, state, slot)
+	if err != nil {
+		return nil, err
+	}
+
+	for i, validatorIndex := range ptc {
+		if att.AggregationBits.BitAt(uint64(i)) {
+			indices = append(indices, validatorIndex)
+		}
+	}
+
+	return
+}
+
+// GetIndexedPayloadAttestation replaces a PayloadAttestation's AggregationBits with sorted AttestingIndices and returns an IndexedPayloadAttestation.
+//
+// Spec pseudocode definition:
+//
+//	def get_indexed_payload_attestation(state: BeaconState, slot: Slot,
+//		payload_attestation: PayloadAttestation) -> IndexedPayloadAttestation:
+//	"""
+//	Return the indexed payload attestation corresponding to ``payload_attestation``.
+//	"""
+//	attesting_indices = get_payload_attesting_indices(state, slot, payload_attestation)
+//
+//	return IndexedPayloadAttestation(
+//	attesting_indices=sorted(attesting_indices),
+//	data=payload_attestation.data,
+//	signature=payload_attestation.signature,
+//	)
+func GetIndexedPayloadAttestation(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, att *eth.PayloadAttestation) (*epbs.IndexedPayloadAttestation, error) {
+	if state.Version() < version.EPBS {
+		return nil, errPreEPBSState
+	}
+
+	attestingIndices, err := GetPayloadAttestingIndices(ctx, state, slot, att)
+	if err != nil {
+		return nil, err
+	}
+
+	slices.Sort(attestingIndices)
+
+	return &epbs.IndexedPayloadAttestation{
+		AttestingIndices: attestingIndices,
+		Data:             att.Data,
+		Signature:        att.Signature,
+	}, nil
+}
+
+// IsValidIndexedPayloadAttestation validates the given IndexedPayloadAttestation.
+//
+// Spec pseudocode definition:
+//
+//	def is_valid_indexed_payload_attestation(
+//		state: BeaconState,
+//		indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
+//	"""
+//	Check if ``indexed_payload_attestation`` is not empty, has sorted and unique indices and has
+//	a valid aggregate signature.
+//	"""
+//	# Verify the data is valid
+//	if indexed_payload_attestation.data.payload_status >= PAYLOAD_INVALID_STATUS:
+//		return False
+//
+//	# Verify indices are sorted and unique
+//	indices = indexed_payload_attestation.attesting_indices
+//	if len(indices) == 0 or not indices == sorted(set(indices)):
+//		return False
+//
+//	# Verify aggregate signature
+//	pubkeys = [state.validators[i].pubkey for i in indices]
+//	domain = get_domain(state, DOMAIN_PTC_ATTESTER, None)
+//	signing_root = compute_signing_root(indexed_payload_attestation.data, domain)
+//	return bls.FastAggregateVerify(pubkeys, signing_root, indexed_payload_attestation.signature)
+func IsValidIndexedPayloadAttestation(state state.ReadOnlyBeaconState, att *epbs.IndexedPayloadAttestation) (bool, error) {
+	if state.Version() < version.EPBS {
+		return false, errPreEPBSState
+	}
+
+	// Verify the data is valid.
+	if att.Data.PayloadStatus >= primitives.PAYLOAD_INVALID_STATUS {
+		return false, nil
+	}
+
+	// Verify indices are sorted and unique.
+	indices := att.AttestingIndices
+	slices.Sort(indices)
+	if len(indices) == 0 || !slices.Equal(att.AttestingIndices, indices) {
+		return false, nil
+	}
+
+	// Verify aggregate signature.
+	publicKeys := make([]bls.PublicKey, len(indices))
+	for i, index := range indices {
+		validator, err := state.ValidatorAtIndexReadOnly(index)
+		if err != nil {
+			return false, err
+		}
+
+		publicKeyBytes := validator.PublicKey()
+		publicKey, err := bls.PublicKeyFromBytes(publicKeyBytes[:])
+		if err != nil {
+			return false, err
+		}
+
+		publicKeys[i] = publicKey
+	}
+
+	domain, err := signing.Domain(
+		state.Fork(),
+		slots.ToEpoch(state.Slot()),
+		params.BeaconConfig().DomainPTCAttester,
+		state.GenesisValidatorsRoot(),
+	)
+	if err != nil {
+		return false, err
+	}
+
+	signingRoot, err := signing.ComputeSigningRoot(att.Data, domain)
+	if err != nil {
+		return false, err
+	}
+
+	signature, err := bls.SignatureFromBytes(att.Signature)
+	if err != nil {
+		return false, err
+	}
+
+	return signature.FastAggregateVerify(publicKeys, signingRoot), nil
+}
+
+// ValidatePayloadAttestationMessageSignature verifies the signature of a
+// payload attestation message.
+func ValidatePayloadAttestationMessageSignature(ctx context.Context, st state.ReadOnlyBeaconState, msg *eth.PayloadAttestationMessage) error {
+	if err := ValidateNilPayloadAttestationMessage(msg); err != nil {
+		return err
+	}
+	val, err := st.ValidatorAtIndex(msg.ValidatorIndex)
+	if err != nil {
+		return err
+	}
+	pub, err := bls.PublicKeyFromBytes(val.PublicKey)
+	if err != nil {
+		return err
+	}
+	sig, err := bls.SignatureFromBytes(msg.Signature)
+	if err != nil {
+		return err
+	}
+	currentEpoch := slots.ToEpoch(st.Slot())
+	domain, err := signing.Domain(st.Fork(), currentEpoch, params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+	root, err := signing.ComputeSigningRoot(msg.Data, domain)
+	if err != nil {
+		return err
+	}
+	if !sig.Verify(pub, root[:]) {
+		return signing.ErrSigFailedToVerify
+	}
+	return nil
+}

beacon-chain/core/helpers/payload_attestation_test.go

@@ -0,0 +1,363 @@
+package helpers_test
+
+import (
+	"context"
+	"slices"
+	"strconv"
+	"testing"
+
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/epbs"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	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/testing/util/random"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+func TestValidateNilPayloadAttestation(t *testing.T) {
+	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestationData(nil))
+	data := &eth.PayloadAttestationData{}
+	require.ErrorIs(t, helpers.ErrNilBeaconBlockRoot, helpers.ValidateNilPayloadAttestationData(data))
+	data.BeaconBlockRoot = make([]byte, 32)
+	require.NoError(t, helpers.ValidateNilPayloadAttestationData(data))
+
+	require.ErrorIs(t, helpers.ErrNilMessage, helpers.ValidateNilPayloadAttestationMessage(nil))
+	message := &eth.PayloadAttestationMessage{}
+	require.ErrorIs(t, helpers.ErrNilSignature, helpers.ValidateNilPayloadAttestationMessage(message))
+	message.Signature = make([]byte, 96)
+	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestationMessage(message))
+	message.Data = data
+	require.NoError(t, helpers.ValidateNilPayloadAttestationMessage(message))
+
+	require.ErrorIs(t, helpers.ErrNilPayloadAttestation, helpers.ValidateNilPayloadAttestation(nil))
+	att := &eth.PayloadAttestation{}
+	require.ErrorIs(t, helpers.ErrNilAggregationBits, helpers.ValidateNilPayloadAttestation(att))
+	att.AggregationBits = bitfield.NewBitvector512()
+	require.ErrorIs(t, helpers.ErrNilSignature, helpers.ValidateNilPayloadAttestation(att))
+	att.Signature = message.Signature
+	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestation(att))
+	att.Data = data
+	require.NoError(t, helpers.ValidateNilPayloadAttestation(att))
+}
+
+func TestGetPayloadTimelinessCommittee(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create 10 committees
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+
+	for i := 0; i < len(validators); i++ {
+		k := make([]byte, 48)
+		copy(k, strconv.Itoa(i))
+		validators[i] = &ethpb.Validator{
+			PublicKey:             k,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	state, err := state_native.InitializeFromProtoEpbs(random.BeaconState(t))
+	require.NoError(t, err)
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(200))
+
+	ctx := context.Background()
+	indices, err := helpers.BeaconCommitteeFromState(ctx, state, state.Slot(), 1)
+	require.NoError(t, err)
+	require.Equal(t, 128, len(indices))
+
+	epoch := slots.ToEpoch(state.Slot())
+	activeCount, err := helpers.ActiveValidatorCount(ctx, state, epoch)
+	require.NoError(t, err)
+	require.Equal(t, uint64(40960), activeCount)
+
+	computedCommitteeCount := helpers.SlotCommitteeCount(activeCount)
+	require.Equal(t, committeeCount, computedCommitteeCount)
+	committeesPerSlot := math.LargestPowerOfTwo(math.Min(committeeCount, fieldparams.PTCSize))
+	require.Equal(t, uint64(8), committeesPerSlot)
+
+	ptc, err := helpers.GetPayloadTimelinessCommittee(ctx, state, state.Slot())
+	require.NoError(t, err)
+	require.Equal(t, fieldparams.PTCSize, len(ptc))
+
+	committee1, err := helpers.BeaconCommitteeFromState(ctx, state, state.Slot(), 0)
+	require.NoError(t, err)
+
+	require.DeepEqual(t, committee1[:64], ptc[:64])
+}
+
+func Test_PtcAllocation(t *testing.T) {
+	tests := []struct {
+		committeeCount     int
+		memberPerCommittee uint64
+		committeesPerSlot  uint64
+	}{
+		{1, 512, 1},
+		{4, 128, 4},
+		{128, 4, 128},
+		{512, 1, 512},
+		{1024, 1, 512},
+	}
+
+	for _, test := range tests {
+		committeesPerSlot, memberPerCommittee := helpers.PtcAllocation(test.committeeCount)
+		if memberPerCommittee != test.memberPerCommittee {
+			t.Errorf("memberPerCommittee(%d) = %d; expected %d", test.committeeCount, memberPerCommittee, test.memberPerCommittee)
+		}
+		if committeesPerSlot != test.committeesPerSlot {
+			t.Errorf("committeesPerSlot(%d) = %d; expected %d", test.committeeCount, committeesPerSlot, test.committeesPerSlot)
+		}
+	}
+}
+
+func TestGetPayloadAttestingIndices(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create 10 committees. Total 40960 validators.
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+
+	for i := 0; i < len(validators); i++ {
+		pubkey := make([]byte, 48)
+		copy(pubkey, strconv.Itoa(i))
+		validators[i] = &ethpb.Validator{
+			PublicKey:             pubkey,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	// Create a beacon state.
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	// Get PTC.
+	ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, state.Slot())
+	require.NoError(t, err)
+	require.Equal(t, fieldparams.PTCSize, len(ptc))
+
+	// Generate random indices. PTC members at the corresponding indices are considered attested.
+	randGen := rand.NewDeterministicGenerator()
+	attesterCount := randGen.Intn(fieldparams.PTCSize) + 1
+	indices := randGen.Perm(fieldparams.PTCSize)[:attesterCount]
+	slices.Sort(indices)
+	require.Equal(t, attesterCount, len(indices))
+
+	// Create a PayloadAttestation with AggregationBits set true at the indices.
+	aggregationBits := bitfield.NewBitvector512()
+	for _, index := range indices {
+		aggregationBits.SetBitAt(uint64(index), true)
+	}
+
+	payloadAttestation := &eth.PayloadAttestation{
+		AggregationBits: aggregationBits,
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: make([]byte, 32),
+		},
+		Signature: make([]byte, 96),
+	}
+
+	// Get attesting indices.
+	attesters, err := helpers.GetPayloadAttestingIndices(context.Background(), state, state.Slot(), payloadAttestation)
+	require.NoError(t, err)
+	require.Equal(t, len(indices), len(attesters))
+
+	// Check if each attester equals to the PTC member at the corresponding index.
+	for i, index := range indices {
+		require.Equal(t, attesters[i], ptc[index])
+	}
+}
+
+func TestGetIndexedPayloadAttestation(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create 10 committees. Total 40960 validators.
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+
+	for i := 0; i < len(validators); i++ {
+		publicKey := make([]byte, 48)
+		copy(publicKey, strconv.Itoa(i))
+		validators[i] = &ethpb.Validator{
+			PublicKey:             publicKey,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	// Create a beacon state.
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	// Get PTC.
+	ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, state.Slot())
+	require.NoError(t, err)
+	require.Equal(t, fieldparams.PTCSize, len(ptc))
+
+	// Generate random indices. PTC members at the corresponding indices are considered attested.
+	randGen := rand.NewDeterministicGenerator()
+	attesterCount := randGen.Intn(fieldparams.PTCSize) + 1
+	indices := randGen.Perm(fieldparams.PTCSize)[:attesterCount]
+	slices.Sort(indices)
+	require.Equal(t, attesterCount, len(indices))
+
+	// Create a PayloadAttestation with AggregationBits set true at the indices.
+	aggregationBits := bitfield.NewBitvector512()
+	for _, index := range indices {
+		aggregationBits.SetBitAt(uint64(index), true)
+	}
+
+	payloadAttestation := &eth.PayloadAttestation{
+		AggregationBits: aggregationBits,
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: make([]byte, 32),
+		},
+		Signature: make([]byte, 96),
+	}
+
+	// Get attesting indices.
+	ctx := context.Background()
+	attesters, err := helpers.GetPayloadAttestingIndices(ctx, state, state.Slot(), payloadAttestation)
+	require.NoError(t, err)
+	require.Equal(t, len(indices), len(attesters))
+
+	// Get an IndexedPayloadAttestation.
+	indexedPayloadAttestation, err := helpers.GetIndexedPayloadAttestation(ctx, state, state.Slot(), payloadAttestation)
+	require.NoError(t, err)
+	require.Equal(t, len(indices), len(indexedPayloadAttestation.AttestingIndices))
+	require.DeepEqual(t, payloadAttestation.Data, indexedPayloadAttestation.Data)
+	require.DeepEqual(t, payloadAttestation.Signature, indexedPayloadAttestation.Signature)
+
+	// Check if the attesting indices are the same.
+	slices.Sort(attesters) // GetIndexedPayloadAttestation sorts attesting indices.
+	require.DeepEqual(t, attesters, indexedPayloadAttestation.AttestingIndices)
+}
+
+func TestIsValidIndexedPayloadAttestation(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create validators.
+	validatorCount := uint64(350)
+	validators := make([]*ethpb.Validator, validatorCount)
+	_, secretKeys, err := util.DeterministicDepositsAndKeys(validatorCount)
+	require.NoError(t, err)
+
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             secretKeys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	// Create a beacon state.
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+		Validators: validators,
+		Fork: &ethpb.Fork{
+			Epoch:           0,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+		},
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	// Define test cases.
+	tests := []struct {
+		attestation *epbs.IndexedPayloadAttestation
+	}{
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{1},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{13, 19},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{123, 234, 345},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{38, 46, 54, 62, 70, 78, 86, 194},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{5},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+	}
+
+	// Run test cases.
+	for _, test := range tests {
+		signatures := make([]bls.Signature, len(test.attestation.AttestingIndices))
+		for i, index := range test.attestation.AttestingIndices {
+			signedBytes, err := signing.ComputeDomainAndSign(
+				state,
+				slots.ToEpoch(test.attestation.Data.Slot),
+				test.attestation.Data,
+				params.BeaconConfig().DomainPTCAttester,
+				secretKeys[index],
+			)
+			require.NoError(t, err)
+
+			signature, err := bls.SignatureFromBytes(signedBytes)
+			require.NoError(t, err)
+
+			signatures[i] = signature
+		}
+
+		aggregatedSignature := bls.AggregateSignatures(signatures)
+		test.attestation.Signature = aggregatedSignature.Marshal()
+
+		isValid, err := helpers.IsValidIndexedPayloadAttestation(state, test.attestation)
+		require.NoError(t, err)
+		require.Equal(t, true, isValid)
+	}
+}

beacon-chain/core/helpers/validators.go

@@ -16,11 +16,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 var (

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

@@ -1,31 +0,0 @@
-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/v2:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-    ],
-)

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

@@ -1,53 +0,0 @@
-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"
-	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-)
-
-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, (*v2.LightClientHeader)(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.Beacon.Slot, "Finalized header slot is not zero")
-	require.Equal(t, primitives.ValidatorIndex(0), update.FinalizedHeader.Beacon.ProposerIndex, "Finalized header proposer index is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.Beacon.ParentRoot, "Finalized header parent root is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.Beacon.StateRoot, "Finalized header state root is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.Beacon.BodyRoot, "Finalized header body root is not zero")
-	require.Equal(t, lightClient.FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
-	for _, leaf := range update.FinalityBranch {
-		require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
-	}
-}

beacon-chain/core/transition/BUILD.bazel

@@ -41,7 +41,6 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",

beacon-chain/core/transition/transition.go

@@ -25,9 +25,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	goTrace "go.opencensus.io/trace"
+	"go.opencensus.io/trace"
 )
 
 type customProcessingFn func(context.Context, state.BeaconState) error
@@ -259,7 +258,7 @@ func cacheBestBeaconStateOnErrFn(highestSlot primitives.Slot, key [32]byte) cust
 //	      if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
 //	          process_epoch(state)
 //	      state.slot = Slot(state.slot + 1)
-func ProcessSlotsCore(ctx context.Context, span *goTrace.Span, state state.BeaconState, slot primitives.Slot, fn customProcessingFn) (state.BeaconState, error) {
+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 {

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -16,8 +16,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"go.opencensus.io/trace"
 )
 
 // ExecuteStateTransitionNoVerifyAnySig defines the procedure for a state transition function.

beacon-chain/core/validators/slashing.go

@@ -22,7 +22,7 @@ func SlashingParamsPerVersion(v int) (slashingQuotient, proposerRewardQuotient,
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
 		proposerRewardQuotient = cfg.ProposerRewardQuotient
 		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
-	case version.Electra:
+	case version.Electra, version.EPBS:
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientElectra
 		proposerRewardQuotient = cfg.ProposerRewardQuotient
 		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotientElectra

beacon-chain/db/iface/BUILD.bazel

@@ -18,7 +18,6 @@ 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,8 +7,6 @@ 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"
@@ -25,6 +23,7 @@ import (
 type ReadOnlyDatabase interface {
 	// Block related methods.
 	Block(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error)
+	SignedExecutionPayloadHeader(ctx context.Context, blockRoot [32]byte) (interfaces.ROSignedExecutionPayloadHeader, error)
 	Blocks(ctx context.Context, f *filters.QueryFilter) ([]interfaces.ReadOnlySignedBeaconBlock, [][32]byte, error)
 	BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]byte, error)
 	BlocksBySlot(ctx context.Context, slot primitives.Slot) ([]interfaces.ReadOnlySignedBeaconBlock, error)
@@ -55,12 +54,10 @@ type ReadOnlyDatabase interface {
 	DepositContractAddress(ctx context.Context) ([]byte, error)
 	// ExecutionChainData operations.
 	ExecutionChainData(ctx context.Context) (*ethpb.ETH1ChainData, error)
+	SignedBlindPayloadEnvelope(ctx context.Context, blockRoot []byte) (*ethpb.SignedBlindPayloadEnvelope, error)
 	// 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,13 +89,12 @@ type NoHeadAccessDatabase interface {
 	SaveDepositContractAddress(ctx context.Context, addr common.Address) error
 	// SaveExecutionChainData operations.
 	SaveExecutionChainData(ctx context.Context, data *ethpb.ETH1ChainData) error
+	SaveBlindPayloadEnvelope(ctx context.Context, envelope *ethpb.SignedBlindPayloadEnvelope) error
 	// Run any required database migrations.
 	RunMigrations(ctx context.Context) error
 	// 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

@@ -6,17 +6,18 @@ go_library(
         "archived_point.go",
         "backfill.go",
         "backup.go",
+        "blind_payload_envelope.go",
         "blocks.go",
         "checkpoint.go",
         "deposit_contract.go",
         "encoding.go",
+        "epbs.go",
         "error.go",
         "execution_chain.go",
         "finalized_block_roots.go",
         "genesis.go",
         "key.go",
         "kv.go",
-        "lightclient.go",
         "log.go",
         "migration.go",
         "migration_archived_index.go",
@@ -51,9 +52,7 @@ go_library(
         "//io/file:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace: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",
@@ -81,16 +80,17 @@ go_test(
         "archived_point_test.go",
         "backfill_test.go",
         "backup_test.go",
+        "blind_payload_envelope_test.go",
         "blocks_test.go",
         "checkpoint_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
+        "epbs_test.go",
         "execution_chain_test.go",
         "finalized_block_roots_test.go",
         "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",
@@ -117,13 +117,13 @@ 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",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_golang_snappy//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/db/kv/backup.go

@@ -8,8 +8,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 const backupsDirectoryName = "backups"

beacon-chain/db/kv/blind_payload_envelope.go

@@ -0,0 +1,45 @@
+package kv
+
+import (
+	"context"
+
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+// SaveBlindPayloadEnvelope saves a signed execution payload envelope blind in the database.
+func (s *Store) SaveBlindPayloadEnvelope(ctx context.Context, env *ethpb.SignedBlindPayloadEnvelope) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBlindPayloadEnvelope")
+	defer span.End()
+
+	enc, err := encode(ctx, env)
+	if err != nil {
+		return err
+	}
+
+	r := env.Message.BeaconBlockRoot
+	err = s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(executionPayloadEnvelopeBucket)
+		return bucket.Put(r, enc)
+	})
+
+	return err
+}
+
+// SignedBlindPayloadEnvelope retrieves a signed execution payload envelope blind from the database.
+func (s *Store) SignedBlindPayloadEnvelope(ctx context.Context, blockRoot []byte) (*ethpb.SignedBlindPayloadEnvelope, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SignedBlindPayloadEnvelope")
+	defer span.End()
+
+	env := &ethpb.SignedBlindPayloadEnvelope{}
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(executionPayloadEnvelopeBucket)
+		enc := bkt.Get(blockRoot)
+		if enc == nil {
+			return ErrNotFound
+		}
+		return decode(ctx, enc, env)
+	})
+	return env, err
+}

beacon-chain/db/kv/blind_payload_envelope_test.go

@@ -0,0 +1,23 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func TestStore_SignedBlindPayloadEnvelope(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	_, err := db.SignedBlindPayloadEnvelope(ctx, []byte("test"))
+	require.ErrorIs(t, err, ErrNotFound)
+
+	env := random.SignedBlindPayloadEnvelope(t)
+	err = db.SaveBlindPayloadEnvelope(ctx, env)
+	require.NoError(t, err)
+	got, err := db.SignedBlindPayloadEnvelope(ctx, env.Message.BeaconBlockRoot)
+	require.NoError(t, err)
+	require.DeepEqual(t, got, env)
+}

beacon-chain/db/kv/blocks.go

@@ -16,11 +16,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 // used to represent errors for inconsistent slot ranges.
@@ -823,6 +823,11 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 		if err := rawBlock.UnmarshalSSZ(enc[len(electraBlindKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal blinded Electra block")
 		}
+	case hasEpbsKey(enc):
+		rawBlock = &ethpb.SignedBeaconBlockEpbs{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(epbsKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal EPBS block")
+		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
@@ -852,6 +857,8 @@ func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 
 func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 	switch blk.Version() {
+	case version.EPBS:
+		return epbsKey, nil
 	case version.Electra:
 		if blk.IsBlinded() {
 			return electraBlindKey, nil

beacon-chain/db/kv/blocks_test.go

@@ -18,6 +18,7 @@ import (
 	"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/testing/util/random"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -146,6 +147,17 @@ var blockTests = []struct {
 			}
 			return blocks.NewSignedBeaconBlock(b)
 		}},
+	{
+		name: "epbs",
+		newBlock: func(slot primitives.Slot, root []byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
+			b := random.SignedBeaconBlock(&testing.T{})
+			b.Block.Slot = slot
+			if root != nil {
+				b.Block.ParentRoot = root
+			}
+			return blocks.NewSignedBeaconBlock(b)
+		},
+	},
 }
 
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
@@ -202,7 +214,7 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			wanted := retrievedBlock
-			if retrievedBlock.Version() >= version.Bellatrix {
+			if retrievedBlock.Version() >= version.Bellatrix && retrievedBlock.Version() < version.EPBS {
 				wanted, err = retrievedBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -390,7 +402,7 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := blk
-			if blk.Version() >= version.Bellatrix {
+			if blk.Version() >= version.Bellatrix && blk.Version() < version.EPBS {
 				wanted, err = blk.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -609,7 +621,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if block1.Version() >= version.Bellatrix {
+			if block1.Version() >= version.Bellatrix && block1.Version() < version.EPBS {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -627,7 +639,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted2 := block2
-			if block2.Version() >= version.Bellatrix {
+			if block2.Version() >= version.Bellatrix && block2.Version() < version.EPBS {
 				wanted2, err = block2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -645,7 +657,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = block3
-			if block3.Version() >= version.Bellatrix {
+			if block3.Version() >= version.Bellatrix && block3.Version() < version.EPBS {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -681,7 +693,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if block1.Version() >= version.Bellatrix {
+			if block1.Version() >= version.Bellatrix && block1.Version() < version.EPBS {
 				wanted, err = block1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -698,7 +710,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if genesisBlock.Version() >= version.Bellatrix {
+			if genesisBlock.Version() >= version.Bellatrix && genesisBlock.Version() < version.EPBS {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -715,7 +727,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if genesisBlock.Version() >= version.Bellatrix {
+			if genesisBlock.Version() >= version.Bellatrix && genesisBlock.Version() < version.EPBS {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -811,7 +823,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := b1
-			if b1.Version() >= version.Bellatrix {
+			if b1.Version() >= version.Bellatrix && b1.Version() < version.EPBS {
 				wanted, err = b1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -827,7 +839,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
 			wanted = b2
-			if b2.Version() >= version.Bellatrix {
+			if b2.Version() >= version.Bellatrix && b2.Version() < version.EPBS {
 				wanted, err = b2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -837,7 +849,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(wantedPb, retrieved0Pb), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
 			wanted = b3
-			if b3.Version() >= version.Bellatrix {
+			if b3.Version() >= version.Bellatrix && b3.Version() < version.EPBS {
 				wanted, err = b3.ToBlinded()
 				require.NoError(t, err)
 			}

beacon-chain/db/kv/checkpoint.go

@@ -8,9 +8,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 var errMissingStateForCheckpoint = errors.New("missing state summary for checkpoint root")

beacon-chain/db/kv/encoding.go

@@ -78,6 +78,8 @@ func isSSZStorageFormat(obj interface{}) bool {
 		return true
 	case *ethpb.VoluntaryExit:
 		return true
+	case *ethpb.SignedBlindPayloadEnvelope:
+		return true
 	case *ethpb.ValidatorRegistrationV1:
 		return true
 	default:

beacon-chain/db/kv/epbs.go

@@ -0,0 +1,18 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+func (s *Store) SignedExecutionPayloadHeader(ctx context.Context, blockRoot [32]byte) (interfaces.ROSignedExecutionPayloadHeader, error) {
+	b, err := s.Block(ctx, blockRoot)
+	if err != nil {
+		return nil, err
+	}
+	if b.IsNil() {
+		return nil, ErrNotFound
+	}
+	return b.Block().Body().SignedExecutionPayloadHeader()
+}

beacon-chain/db/kv/epbs_test.go

@@ -0,0 +1,28 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func Test_SignedExecutionPayloadHeader(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	b := random.SignedBeaconBlock(t)
+	blk, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	blockRoot, err := blk.Block().HashTreeRoot()
+	require.NoError(t, err)
+
+	require.NoError(t, db.SaveBlock(ctx, blk))
+	retrievedHeader, err := db.SignedExecutionPayloadHeader(ctx, blockRoot)
+	require.NoError(t, err)
+	wantedHeader, err := blk.Block().Body().SignedExecutionPayloadHeader()
+	require.NoError(t, err)
+	require.DeepEqual(t, wantedHeader, retrievedHeader)
+}

beacon-chain/db/kv/execution_chain.go

@@ -5,9 +5,9 @@ import (
 	"errors"
 
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v2 "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 	"google.golang.org/protobuf/proto"
 )
 

beacon-chain/db/kv/finalized_block_roots.go

@@ -10,9 +10,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 var previousFinalizedCheckpointKey = []byte("previous-finalized-checkpoint")

beacon-chain/db/kv/key.go

@@ -65,3 +65,10 @@ func hasElectraBlindKey(enc []byte) bool {
 	}
 	return bytes.Equal(enc[:len(electraBlindKey)], electraBlindKey)
 }
+
+func hasEpbsKey(enc []byte) bool {
+	if len(epbsKey) >= len(enc) {
+		return false
+	}
+	return bytes.Equal(enc[:len(epbsKey)], epbsKey)
+}

beacon-chain/db/kv/kv.go

@@ -107,7 +107,6 @@ var Buckets = [][]byte{
 	powchainBucket,
 	stateSummaryBucket,
 	stateValidatorsBucket,
-	lightClientUpdatesBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,
@@ -119,6 +118,9 @@ var Buckets = [][]byte{
 
 	feeRecipientBucket,
 	registrationBucket,
+
+	// ePBS
+	executionPayloadEnvelopeBucket,
 }
 
 // KVStoreOption is a functional option that modifies a kv.Store.

beacon-chain/db/kv/lightclient.go

@@ -1,79 +0,0 @@
-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
-}