Initialize payload att message verfier in sync

Adds the processing of execution payload envelope
Corrects the protos for attestations and slashings in Electra versions
Adds generators of full blocks for Electra

.buildkite-bazelrc

@@ -12,8 +12,7 @@
 build:remote-cache --remote_download_minimal
 build:remote-cache --remote_build_event_upload=minimal
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
-# Does not work with rules_oci. See https://github.com/bazel-contrib/rules_oci/issues/292
-#build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
+build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
 build:remote-cache --remote_local_fallback
 build:remote-cache --experimental_remote_cache_async
 build:remote-cache --experimental_remote_merkle_tree_cache

.github/actions/gomodtidy/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.21-alpine
+FROM golang:1.22-alpine
 
 COPY entrypoint.sh /entrypoint.sh
 

.github/workflows/fuzz.yml

@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
       - id: list
         uses: shogo82148/actions-go-fuzz/list@v0
         with:
@@ -36,7 +36,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
       - uses: shogo82148/actions-go-fuzz/run@v0
         with:
           packages: ${{ matrix.package }}

.github/workflows/go.yml

@@ -28,14 +28,14 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Set up Go 1.21
+      - name: Set up Go 1.22
         uses: actions/setup-go@v3
         with:
-          go-version: '1.21.5'
+          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
-          go install github.com/securego/gosec/v2/cmd/gosec@v2.15.0
+          go install github.com/securego/gosec/v2/cmd/gosec@v2.19.0
           gosec -exclude-generated -exclude=G307 -exclude-dir=crypto/bls/herumi ./...
 
   lint:
@@ -45,10 +45,10 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
-      - name: Set up Go 1.21
+      - name: Set up Go 1.22
         uses: actions/setup-go@v3
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
           id: go
 
       - name: Golangci-lint
@@ -64,7 +64,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
         id: go
 
       - name: Check out code into the Go module directory

.golangci.yml

@@ -6,7 +6,7 @@ run:
     - proto
     - tools/analyzers
   timeout: 10m
-  go: '1.21.5'
+  go: '1.22.3'
 
 linters:
   enable-all: true
@@ -34,7 +34,6 @@ linters:
     - dogsled
     - dupl
     - durationcheck
-    - errorlint
     - exhaustive
     - exhaustruct
     - forbidigo
@@ -52,6 +51,7 @@ linters:
     - gofumpt
     - gomnd
     - gomoddirectives
+    - gosec
     - inamedparam
     - interfacebloat
     - ireturn

BUILD.bazel

@@ -224,6 +224,7 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/defers:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/directive:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/errorsas:go_default_library",
         # fieldalignment disabled
         #"@org_golang_x_tools//go/analysis/passes/fieldalignment:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",

MODULE.bazel.lock

@@ -1123,6 +1123,27 @@
         "recordedRepoMappingEntries": []
       }
     },
+    "@@bazel_tools//tools/test:extensions.bzl%remote_coverage_tools_extension": {
+      "general": {
+        "bzlTransitiveDigest": "l5mcjH2gWmbmIycx97bzI2stD0Q0M5gpDc0aLOHKIm8=",
+        "recordedFileInputs": {},
+        "recordedDirentsInputs": {},
+        "envVariables": {},
+        "generatedRepoSpecs": {
+          "remote_coverage_tools": {
+            "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl",
+            "ruleClassName": "http_archive",
+            "attributes": {
+              "sha256": "7006375f6756819b7013ca875eab70a541cf7d89142d9c511ed78ea4fefa38af",
+              "urls": [
+                "https://mirror.bazel.build/bazel_coverage_output_generator/releases/coverage_output_generator-v2.6.zip"
+              ]
+            }
+          }
+        },
+        "recordedRepoMappingEntries": []
+      }
+    },
     "@@rules_java~//java:extensions.bzl%toolchains": {
       "general": {
         "bzlTransitiveDigest": "tJHbmWnq7m+9eUBnUdv7jZziQ26FmcGL9C5/hU3Q9UQ=",

WORKSPACE

@@ -29,23 +29,7 @@ http_archive(
 
 load("@hermetic_cc_toolchain//toolchain:defs.bzl", zig_toolchains = "toolchains")
 
-# Temporarily use a nightly build until 0.12.0 is released.
-# See: https://github.com/prysmaticlabs/prysm/issues/13130
-zig_toolchains(
-    host_platform_sha256 = {
-        "linux-aarch64": "45afb8e32adde825165f4f293fcea9ecea503f7f9ec0e9bf4435afe70e67fb70",
-        "linux-x86_64": "f136c6a8a0f6adcb057d73615fbcd6f88281b3593f7008d5f7ed514ff925c02e",
-        "macos-aarch64": "05d995853c05243151deff47b60bdc2674f1e794a939eaeca0f42312da031cee",
-        "macos-x86_64": "721754ba5a50f31e8a1f0e1a74cace26f8246576878ac4a8591b0ee7b6db1fc1",
-        "windows-x86_64": "93f5248b2ea8c5ee8175e15b1384e133edc1cd49870b3ea259062a2e04164343",
-    },
-    url_formats = [
-        "https://ziglang.org/builds/zig-{host_platform}-{version}.{_ext}",
-        "https://mirror.bazel.build/ziglang.org/builds/zig-{host_platform}-{version}.{_ext}",
-        "https://prysmaticlabs.com/mirror/ziglang.org/builds/zig-{host_platform}-{version}.{_ext}",
-    ],
-    version = "0.12.0-dev.1349+fa022d1ec",
-)
+zig_toolchains()
 
 # Register zig sdk toolchains with support for Ubuntu 20.04 (Focal Fossa) which has an EOL date of April, 2025.
 # For ubuntu glibc support, see https://launchpad.net/ubuntu/+source/glibc
@@ -198,7 +182,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.21.8",
+    go_version = "1.22.4",
     nogo = "@//:nogo",
 )
 
@@ -243,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.4.0"
+consensus_spec_version = "v1.5.0-alpha.3"
 
 bls_test_version = "v0.1.1"
 
@@ -259,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "c282c0f86f23f3d2e0f71f5975769a4077e62a7e3c7382a16bd26a7e589811a0",
+    integrity = "sha256-+byv+GUOQytex5GgtjBGVoNDseJZbiBdAjEtlgCbjEo=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "4649c35aa3b8eb0cfdc81bee7c05649f90ef36bede5b0513e1f2e8baf37d6033",
+    integrity = "sha256-JJUy/jT1h3kGQkinTuzL7gMOA1+qgmPgJXVrYuH63Cg=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -291,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "c5a03f724f757456ffaabd2a899992a71d2baf45ee4db65ca3518f2b7ee928c8",
+    integrity = "sha256-T2VM4Qd0SwgGnTjWxjOX297DqEsovO9Ueij1UEJy48Y=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -306,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "cd1c9d97baccbdde1d2454a7dceb8c6c61192a3b581eee12ffc94969f2db8453",
+    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,
 )
@@ -342,36 +326,20 @@ filegroup(
     url = "https://github.com/eth-clients/eth2-networks/archive/934c948e69205dcf2deb87e4ae6cc140c335f94d.tar.gz",
 )
 
-http_archive(
-    name = "goerli_testnet",
-    build_file_content = """
-filegroup(
-    name = "configs",
-    srcs = [
-        "prater/config.yaml",
-    ],
-    visibility = ["//visibility:public"],
-)
-    """,
-    sha256 = "43fc0f55ddff7b511713e2de07aa22846a67432df997296fb4fc09cd8ed1dcdb",
-    strip_prefix = "goerli-6522ac6684693740cd4ddcc2a0662e03702aa4a1",
-    url = "https://github.com/eth-clients/goerli/archive/6522ac6684693740cd4ddcc2a0662e03702aa4a1.tar.gz",
-)
-
 http_archive(
     name = "holesky_testnet",
     build_file_content = """
 filegroup(
     name = "configs",
     srcs = [
-        "custom_config_data/config.yaml",
+        "metadata/config.yaml",
     ],
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "5f4be6fd088683ea9db45c863b9c5a1884422449e5b59fd2d561d3ba0f73ffd9",
-    strip_prefix = "holesky-9d9aabf2d4de51334ee5fed6c79a4d55097d1a43",
-    url = "https://github.com/eth-clients/holesky/archive/9d9aabf2d4de51334ee5fed6c79a4d55097d1a43.tar.gz",  # 2024-01-22
+    integrity = "sha256-b7ZTT+olF+VXEJYNTV5jggNtCkt9dOejm1i2VE+zy+0=",
+    strip_prefix = "holesky-874c199423ccd180607320c38cbaca05d9a1573a",
+    url = "https://github.com/eth-clients/holesky/archive/874c199423ccd180607320c38cbaca05d9a1573a.tar.gz",  # 2024-06-18
 )
 
 http_archive(

api/BUILD.bazel

@@ -1,11 +1,24 @@
-load("@prysm//tools/go:def.bzl", "go_library")
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = [
         "constants.go",
         "headers.go",
+        "jwt.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/api",
     visibility = ["//visibility:public"],
+    deps = [
+        "//crypto/rand:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["jwt_test.go"],
+    embed = [":go_default_library"],
+    deps = ["//testing/require:go_default_library"],
 )

api/client/beacon/checkpoint_test.go

@@ -9,22 +9,20 @@ import (
 	"net/http"
 	"testing"
 
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	blocktest "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks/testing"
-	"github.com/prysmaticlabs/prysm/v5/network/forks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz/detect"
+	"github.com/prysmaticlabs/prysm/v5/network/forks"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
 type testRT struct {

api/client/beacon/health.go

@@ -36,20 +36,25 @@ func (n *NodeHealthTracker) IsHealthy() bool {
 }
 
 func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
-	n.RLock()
+	n.Lock()
+	defer n.Unlock()
+
 	newStatus := n.node.IsHealthy(ctx)
 	if n.isHealthy == nil {
 		n.isHealthy = &newStatus
 	}
-	isStatusChanged := newStatus != *n.isHealthy
-	n.RUnlock()
 
+	isStatusChanged := newStatus != *n.isHealthy
 	if isStatusChanged {
-		n.Lock()
-		// Double-check the condition to ensure it hasn't changed since the first check.
+		// Update the health status
 		n.isHealthy = &newStatus
-		n.Unlock() // It's better to unlock as soon as the protected section is over.
-		n.healthChan <- newStatus
+		// Send the new status to the health channel, potentially overwriting the existing value
+		select {
+		case <-n.healthChan:
+			n.healthChan <- newStatus
+		default:
+			n.healthChan <- newStatus
+		}
 	}
 	return newStatus
 }

api/client/beacon/health_test.go

@@ -87,21 +87,15 @@ func TestNodeHealth_Concurrency(t *testing.T) {
 	// Number of goroutines to spawn for both reading and writing
 	numGoroutines := 6
 
-	go func() {
-		for range n.HealthUpdates() {
-			// Consume values to avoid blocking on channel send.
-		}
-	}()
-
 	wg.Add(numGoroutines * 2) // for readers and writers
 
 	// Concurrently update health status
 	for i := 0; i < numGoroutines; i++ {
 		go func() {
 			defer wg.Done()
-			client.EXPECT().IsHealthy(gomock.Any()).Return(false)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(false).Times(1)
 			n.CheckHealth(context.Background())
-			client.EXPECT().IsHealthy(gomock.Any()).Return(true)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(true).Times(1)
 			n.CheckHealth(context.Background())
 		}()
 	}

api/client/beacon/testing/mock.go

@@ -3,6 +3,7 @@ package testing
 import (
 	"context"
 	"reflect"
+	"sync"
 
 	"github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface"
 	"go.uber.org/mock/gomock"
@@ -16,6 +17,7 @@ var (
 type MockHealthClient struct {
 	ctrl     *gomock.Controller
 	recorder *MockHealthClientMockRecorder
+	sync.Mutex
 }
 
 // MockHealthClientMockRecorder is the mock recorder for MockHealthClient.
@@ -25,6 +27,8 @@ type MockHealthClientMockRecorder struct {
 
 // IsHealthy mocks base method.
 func (m *MockHealthClient) IsHealthy(arg0 context.Context) bool {
+	m.Lock()
+	defer m.Unlock()
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsHealthy", arg0)
 	ret0, ok := ret[0].(bool)
@@ -41,6 +45,8 @@ func (m *MockHealthClient) EXPECT() *MockHealthClientMockRecorder {
 
 // IsHealthy indicates an expected call of IsHealthy.
 func (mr *MockHealthClientMockRecorder) IsHealthy(arg0 any) *gomock.Call {
+	mr.mock.Lock()
+	defer mr.mock.Unlock()
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHealthy", reflect.TypeOf((*MockHealthClient)(nil).IsHealthy), arg0)
 }

api/client/builder/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/api/client/builder",
     visibility = ["//visibility:public"],
     deps = [
+        "//api:go_default_library",
         "//api/server/structs:go_default_library",
         "//config/fieldparams:go_default_library",
         "//consensus-types:go_default_library",
@@ -28,6 +29,7 @@ go_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",
     ],
 )
 
@@ -49,9 +51,11 @@ go_test(
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

api/client/builder/bid.go

@@ -6,6 +6,7 @@ import (
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
@@ -22,7 +23,7 @@ type SignedBid interface {
 type Bid interface {
 	Header() (interfaces.ExecutionData, error)
 	BlobKzgCommitments() ([][]byte, error)
-	Value() []byte
+	Value() primitives.Wei
 	Pubkey() []byte
 	Version() int
 	IsNil() bool
@@ -125,8 +126,8 @@ func (b builderBid) Version() int {
 }
 
 // Value --
-func (b builderBid) Value() []byte {
-	return b.p.Value
+func (b builderBid) Value() primitives.Wei {
+	return primitives.LittleEndianBytesToWei(b.p.Value)
 }
 
 // Pubkey --
@@ -165,7 +166,7 @@ func WrappedBuilderBidCapella(p *ethpb.BuilderBidCapella) (Bid, error) {
 // Header returns the execution data interface.
 func (b builderBidCapella) Header() (interfaces.ExecutionData, error) {
 	// We have to convert big endian to little endian because the value is coming from the execution layer.
-	return blocks.WrappedExecutionPayloadHeaderCapella(b.p.Header, blocks.PayloadValueToWei(b.p.Value))
+	return blocks.WrappedExecutionPayloadHeaderCapella(b.p.Header)
 }
 
 // BlobKzgCommitments --
@@ -179,8 +180,8 @@ func (b builderBidCapella) Version() int {
 }
 
 // Value --
-func (b builderBidCapella) Value() []byte {
-	return b.p.Value
+func (b builderBidCapella) Value() primitives.Wei {
+	return primitives.LittleEndianBytesToWei(b.p.Value)
 }
 
 // Pubkey --
@@ -222,8 +223,8 @@ func (b builderBidDeneb) Version() int {
 }
 
 // Value --
-func (b builderBidDeneb) Value() []byte {
-	return b.p.Value
+func (b builderBidDeneb) Value() primitives.Wei {
+	return primitives.LittleEndianBytesToWei(b.p.Value)
 }
 
 // Pubkey --
@@ -249,7 +250,7 @@ func (b builderBidDeneb) HashTreeRootWith(hh *ssz.Hasher) error {
 // Header --
 func (b builderBidDeneb) Header() (interfaces.ExecutionData, error) {
 	// We have to convert big endian to little endian because the value is coming from the execution layer.
-	return blocks.WrappedExecutionPayloadHeaderDeneb(b.p.Header, blocks.PayloadValueToWei(b.p.Value))
+	return blocks.WrappedExecutionPayloadHeaderDeneb(b.p.Header)
 }
 
 // BlobKzgCommitments --

api/client/builder/client.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/big"
 	"net"
 	"net/http"
 	"net/url"
@@ -14,11 +13,11 @@ import (
 	"text/template"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"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/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -282,133 +281,68 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 	return err
 }
 
+var errResponseVersionMismatch = errors.New("builder API response uses a different version than requested in " + api.VersionHeader + " header")
+
 // SubmitBlindedBlock calls the builder API endpoint that binds the validator to the builder and submits the block.
 // The response is the full execution payload used to create the blinded block.
 func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
 	if !sb.IsBlinded() {
 		return nil, nil, errNotBlinded
 	}
-	switch sb.Version() {
-	case version.Bellatrix:
-		psb, err := sb.PbBlindedBellatrixBlock()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
-		}
-		b, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(&ethpb.SignedBlindedBeaconBlockBellatrix{Block: psb.Block, Signature: bytesutil.SafeCopyBytes(psb.Signature)})
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not convert SignedBlindedBeaconBlockBellatrix to json marshalable type")
-		}
-		body, err := json.Marshal(b)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockBellatrix value body in SubmitBlindedBlock")
-		}
-		versionOpt := func(r *http.Request) {
-			r.Header.Add("Eth-Consensus-Version", version.String(version.Bellatrix))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
-		}
-		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockBellatrix to the builder api")
-		}
-		ep := &ExecPayloadResponse{}
-		if err := json.Unmarshal(rb, ep); err != nil {
-			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlock response")
-		}
-		if strings.ToLower(ep.Version) != version.String(version.Bellatrix) {
-			return nil, nil, errors.New("not a bellatrix payload")
-		}
-		p, err := ep.ToProto()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
-		}
-		payload, err := blocks.WrappedExecutionPayload(p)
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
-		}
-		return payload, nil, nil
-	case version.Capella:
-		psb, err := sb.PbBlindedCapellaBlock()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
-		}
-		b, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(&ethpb.SignedBlindedBeaconBlockCapella{Block: psb.Block, Signature: bytesutil.SafeCopyBytes(psb.Signature)})
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not convert SignedBlindedBeaconBlockCapella to json marshalable type")
-		}
-		body, err := json.Marshal(b)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockCapella value body in SubmitBlindedBlockCapella")
-		}
-		versionOpt := func(r *http.Request) {
-			r.Header.Add("Eth-Consensus-Version", version.String(version.Capella))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
-		}
-		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
-
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockCapella to the builder api")
-		}
-		ep := &ExecPayloadResponseCapella{}
-		if err := json.Unmarshal(rb, ep); err != nil {
-			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockCapella response")
-		}
-		if strings.ToLower(ep.Version) != version.String(version.Capella) {
-			return nil, nil, errors.New("not a capella payload")
-		}
-		p, err := ep.ToProto()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
-		}
-		payload, err := blocks.WrappedExecutionPayloadCapella(p, big.NewInt(0))
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
-		}
-		return payload, nil, nil
-	case version.Deneb:
-		psb, err := sb.PbBlindedDenebBlock()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
-		}
-		b, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(&ethpb.SignedBlindedBeaconBlockDeneb{Message: psb.Message, Signature: bytesutil.SafeCopyBytes(psb.Signature)})
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not convert SignedBlindedBeaconBlockDeneb to json marshalable type")
-		}
-		body, err := json.Marshal(b)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockDeneb value body in SubmitBlindedBlockDeneb")
-		}
-
-		versionOpt := func(r *http.Request) {
-			r.Header.Add("Eth-Consensus-Version", version.String(version.Deneb))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
-		}
-		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockDeneb to the builder api")
-		}
-		ep := &ExecPayloadResponseDeneb{}
-		if err := json.Unmarshal(rb, ep); err != nil {
-			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockDeneb response")
-		}
-		if strings.ToLower(ep.Version) != version.String(version.Deneb) {
-			return nil, nil, errors.New("not a deneb payload")
-		}
-		p, blobBundle, err := ep.ToProto()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
-		}
-		payload, err := blocks.WrappedExecutionPayloadDeneb(p, big.NewInt(0))
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
-		}
-		return payload, blobBundle, nil
-	default:
-		return nil, nil, fmt.Errorf("unsupported block version %s", version.String(sb.Version()))
+	// massage the proto struct type data into the api response type.
+	mj, err := structs.SignedBeaconBlockMessageJsoner(sb)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error generating blinded beacon block post request")
 	}
+
+	body, err := json.Marshal(mj)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error marshaling blinded block post request to json")
+	}
+	postOpts := func(r *http.Request) {
+		r.Header.Add("Eth-Consensus-Version", version.String(sb.Version()))
+		r.Header.Set("Content-Type", api.JsonMediaType)
+		r.Header.Set("Accept", api.JsonMediaType)
+	}
+	// post the blinded block - the execution payload response should contain the unblinded payload, along with the
+	// blobs bundle if it is post deneb.
+	rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), postOpts)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
+	}
+	// ExecutionPayloadResponse parses just the outer container and the Value key, enabling it to use the .Value
+	// key to determine which underlying data type to use to finish the unmarshaling.
+	ep := &ExecutionPayloadResponse{}
+	if err := json.Unmarshal(rb, ep); err != nil {
+		return nil, nil, errors.Wrap(err, "error unmarshaling the builder ExecutionPayloadResponse")
+	}
+	if strings.ToLower(ep.Version) != version.String(sb.Version()) {
+		return nil, nil, errors.Wrapf(errResponseVersionMismatch, "req=%s, recv=%s", strings.ToLower(ep.Version), version.String(sb.Version()))
+	}
+	// This parses the rest of the response and returns the inner data field.
+	pp, err := ep.ParsePayload()
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "failed to parse execution payload from builder with version=%s", ep.Version)
+	}
+	// Get the payload as a proto.Message so it can be wrapped as an execution payload interface.
+	pb, err := pp.PayloadProto()
+	if err != nil {
+		return nil, nil, err
+	}
+	ed, err := blocks.NewWrappedExecutionData(pb)
+	if err != nil {
+		return nil, nil, err
+	}
+	bb, ok := pp.(BlobBundler)
+	if ok {
+		bbpb, err := bb.BundleProto()
+		if err != nil {
+			return nil, nil, errors.Wrapf(err, "failed to extract blobs bundle from builder response with version=%s", ep.Version)
+		}
+		return ed, bbpb, nil
+	}
+	return ed, nil, nil
 }
 
 // Status asks the remote builder server for a health check. A response of 200 with an empty body is the success/healthy

api/client/builder/client_test.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/big"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -16,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
@@ -198,12 +198,12 @@ func TestClient_GetHeader(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(expectedTxRoot, withdrawalsRoot))
 		require.Equal(t, uint64(1), bidHeader.GasUsed())
-		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+		// this matches the value in the testExampleHeaderResponse
+		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
+		value, err := stringToUint256(bidStr)
 		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", bid.Value()))
-		bidValue := bytesutil.ReverseByteOrder(bid.Value())
-		require.DeepEqual(t, bidValue, value.Bytes())
-		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
+		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
+		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
 	})
 	t.Run("capella", func(t *testing.T) {
 		hc := &http.Client{
@@ -230,12 +230,11 @@ func TestClient_GetHeader(t *testing.T) {
 		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
+		value, err := stringToUint256(bidStr)
 		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", bid.Value()))
-		bidValue := bytesutil.ReverseByteOrder(bid.Value())
-		require.DeepEqual(t, bidValue, value.Bytes())
-		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
+		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
+		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
 	})
 	t.Run("deneb", func(t *testing.T) {
 		hc := &http.Client{
@@ -262,12 +261,13 @@ func TestClient_GetHeader(t *testing.T) {
 		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+
+		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
+		value, err := stringToUint256(bidStr)
 		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", bid.Value()))
-		bidValue := bytesutil.ReverseByteOrder(bid.Value())
-		require.DeepEqual(t, bidValue, value.Bytes())
-		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
+		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
+		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
+
 		kcgCommitments, err := bid.BlobKzgCommitments()
 		require.NoError(t, err)
 		require.Equal(t, len(kcgCommitments) > 0, true)
@@ -432,7 +432,7 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
 		require.NoError(t, err)
 		_, _, err = c.SubmitBlindedBlock(ctx, sbbb)
-		require.ErrorContains(t, "not a bellatrix payload", err)
+		require.ErrorIs(t, err, errResponseVersionMismatch)
 	})
 	t.Run("not blinded", func(t *testing.T) {
 		sbb, err := blocks.NewSignedBeaconBlock(&eth.SignedBeaconBlockBellatrix{Block: &eth.BeaconBlockBellatrix{Body: &eth.BeaconBlockBodyBellatrix{ExecutionPayload: &v1.ExecutionPayload{}}}})

api/client/builder/types.go

@@ -9,11 +9,15 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
 )
 
 var errInvalidUint256 = errors.New("invalid Uint256")
@@ -44,6 +48,9 @@ func sszBytesToUint256(b []byte) (Uint256, error) {
 
 // SSZBytes creates an ssz-style (little-endian byte slice) representation of the Uint256.
 func (s Uint256) SSZBytes() []byte {
+	if s.Int == nil {
+		s.Int = big.NewInt(0)
+	}
 	if !math.IsValidUint256(s.Int) {
 		return []byte{}
 	}
@@ -91,6 +98,9 @@ func (s Uint256) MarshalJSON() ([]byte, error) {
 
 // MarshalText returns a text byte representation of Uint256.
 func (s Uint256) MarshalText() ([]byte, error) {
+	if s.Int == nil {
+		s.Int = big.NewInt(0)
+	}
 	if !math.IsValidUint256(s.Int) {
 		return nil, errors.Wrapf(errInvalidUint256, "value=%s", s.Int)
 	}
@@ -146,6 +156,8 @@ func (bb *BuilderBid) ToProto() (*eth.BuilderBid, error) {
 	}
 	return &eth.BuilderBid{
 		Header: header,
+		// Note that SSZBytes() reverses byte order for the little-endian representation.
+		// Uint256.Bytes() is big-endian, SSZBytes takes this value and reverses it.
 		Value:  bb.Value.SSZBytes(),
 		Pubkey: bb.Pubkey,
 	}, nil
@@ -265,6 +277,11 @@ func (r *ExecPayloadResponse) ToProto() (*v1.ExecutionPayload, error) {
 	return r.Data.ToProto()
 }
 
+func (r *ExecutionPayload) PayloadProto() (proto.Message, error) {
+	pb, err := r.ToProto()
+	return pb, err
+}
+
 // ToProto returns a ExecutionPayload Proto
 func (p *ExecutionPayload) ToProto() (*v1.ExecutionPayload, error) {
 	txs := make([][]byte, len(p.Transactions))
@@ -396,6 +413,51 @@ func FromProtoDeneb(payload *v1.ExecutionPayloadDeneb) (ExecutionPayloadDeneb, e
 	}, nil
 }
 
+var errInvalidTypeConversion = errors.New("unable to translate between api and foreign type")
+
+// ExecutionPayloadResponseFromData converts an ExecutionData interface value to a payload response.
+// This involves serializing the execution payload value so that the abstract payload envelope can be used.
+func ExecutionPayloadResponseFromData(ed interfaces.ExecutionData, bundle *v1.BlobsBundle) (*ExecutionPayloadResponse, error) {
+	pb := ed.Proto()
+	var data interface{}
+	var err error
+	var ver string
+	switch pbStruct := pb.(type) {
+	case *v1.ExecutionPayload:
+		ver = version.String(version.Bellatrix)
+		data, err = FromProto(pbStruct)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert a Bellatrix ExecutionPayload to an API response")
+		}
+	case *v1.ExecutionPayloadCapella:
+		ver = version.String(version.Capella)
+		data, err = FromProtoCapella(pbStruct)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert a Capella ExecutionPayload to an API response")
+		}
+	case *v1.ExecutionPayloadDeneb:
+		ver = version.String(version.Deneb)
+		payloadStruct, err := FromProtoDeneb(pbStruct)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert a Deneb ExecutionPayload to an API response")
+		}
+		data = &ExecutionPayloadDenebAndBlobsBundle{
+			ExecutionPayload: &payloadStruct,
+			BlobsBundle:      FromBundleProto(bundle),
+		}
+	default:
+		return nil, errInvalidTypeConversion
+	}
+	encoded, err := json.Marshal(data)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to marshal execution payload version=%s", ver)
+	}
+	return &ExecutionPayloadResponse{
+		Version: ver,
+		Data:    encoded,
+	}, nil
+}
+
 // ExecHeaderResponseCapella is the response of builder API /eth/v1/builder/header/{slot}/{parent_hash}/{pubkey} for Capella.
 type ExecHeaderResponseCapella struct {
 	Data struct {
@@ -424,6 +486,8 @@ func (bb *BuilderBidCapella) ToProto() (*eth.BuilderBidCapella, error) {
 	}
 	return &eth.BuilderBidCapella{
 		Header: header,
+		// Note that SSZBytes() reverses byte order for the little-endian representation.
+		// Uint256.Bytes() is big-endian, SSZBytes takes this value and reverses it.
 		Value:  bytesutil.SafeCopyBytes(bb.Value.SSZBytes()),
 		Pubkey: bytesutil.SafeCopyBytes(bb.Pubkey),
 	}, nil
@@ -523,6 +587,42 @@ type ExecPayloadResponseCapella struct {
 	Data    ExecutionPayloadCapella `json:"data"`
 }
 
+// ExecutionPayloadResponse allows for unmarshaling just the Version field of the payload.
+// This allows it to return different ExecutionPayload types based on the version field.
+type ExecutionPayloadResponse struct {
+	Version string          `json:"version"`
+	Data    json.RawMessage `json:"data"`
+}
+
+// ParsedPayload can retrieve the underlying protobuf message for the given execution payload response.
+type ParsedPayload interface {
+	PayloadProto() (proto.Message, error)
+}
+
+// BlobBundler can retrieve the underlying blob bundle protobuf message for the given execution payload response.
+type BlobBundler interface {
+	BundleProto() (*v1.BlobsBundle, error)
+}
+
+func (r *ExecutionPayloadResponse) ParsePayload() (ParsedPayload, error) {
+	var toProto ParsedPayload
+	switch r.Version {
+	case version.String(version.Bellatrix):
+		toProto = &ExecutionPayload{}
+	case version.String(version.Capella):
+		toProto = &ExecutionPayloadCapella{}
+	case version.String(version.Deneb):
+		toProto = &ExecutionPayloadDenebAndBlobsBundle{}
+	default:
+		return nil, consensusblocks.ErrUnsupportedVersion
+	}
+
+	if err := json.Unmarshal(r.Data, toProto); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal the response .Data field with the stated version schema")
+	}
+	return toProto, nil
+}
+
 // ExecutionPayloadCapella is a field of ExecPayloadResponseCapella.
 type ExecutionPayloadCapella struct {
 	ParentHash    hexutil.Bytes   `json:"parent_hash"`
@@ -547,6 +647,11 @@ func (r *ExecPayloadResponseCapella) ToProto() (*v1.ExecutionPayloadCapella, err
 	return r.Data.ToProto()
 }
 
+func (p *ExecutionPayloadCapella) PayloadProto() (proto.Message, error) {
+	pb, err := p.ToProto()
+	return pb, err
+}
+
 // ToProto returns a ExecutionPayloadCapella Proto.
 func (p *ExecutionPayloadCapella) ToProto() (*v1.ExecutionPayloadCapella, error) {
 	txs := make([][]byte, len(p.Transactions))
@@ -921,8 +1026,10 @@ func (bb *BuilderBidDeneb) ToProto() (*eth.BuilderBidDeneb, error) {
 	return &eth.BuilderBidDeneb{
 		Header:             header,
 		BlobKzgCommitments: kzgCommitments,
-		Value:              bytesutil.SafeCopyBytes(bb.Value.SSZBytes()),
-		Pubkey:             bytesutil.SafeCopyBytes(bb.Pubkey),
+		// Note that SSZBytes() reverses byte order for the little-endian representation.
+		// Uint256.Bytes() is big-endian, SSZBytes takes this value and reverses it.
+		Value:  bytesutil.SafeCopyBytes(bb.Value.SSZBytes()),
+		Pubkey: bytesutil.SafeCopyBytes(bb.Pubkey),
 	}, nil
 }
 
@@ -1128,6 +1235,12 @@ func (r *ExecPayloadResponseDeneb) ToProto() (*v1.ExecutionPayloadDeneb, *v1.Blo
 	if r.Data == nil {
 		return nil, nil, errors.New("data field in response is empty")
 	}
+	if r.Data.ExecutionPayload == nil {
+		return nil, nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload")
+	}
+	if r.Data.BlobsBundle == nil {
+		return nil, nil, errors.Wrap(consensusblocks.ErrNilObject, "nil blobs bundle")
+	}
 	payload, err := r.Data.ExecutionPayload.ToProto()
 	if err != nil {
 		return nil, nil, err
@@ -1139,8 +1252,26 @@ func (r *ExecPayloadResponseDeneb) ToProto() (*v1.ExecutionPayloadDeneb, *v1.Blo
 	return payload, bundle, nil
 }
 
+func (r *ExecutionPayloadDenebAndBlobsBundle) PayloadProto() (proto.Message, error) {
+	if r.ExecutionPayload == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload in combined deneb payload")
+	}
+	pb, err := r.ExecutionPayload.ToProto()
+	return pb, err
+}
+
+func (r *ExecutionPayloadDenebAndBlobsBundle) BundleProto() (*v1.BlobsBundle, error) {
+	if r.BlobsBundle == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil blobs bundle")
+	}
+	return r.BlobsBundle.ToProto()
+}
+
 // ToProto returns the ExecutionPayloadDeneb Proto.
 func (p *ExecutionPayloadDeneb) ToProto() (*v1.ExecutionPayloadDeneb, error) {
+	if p == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload")
+	}
 	txs := make([][]byte, len(p.Transactions))
 	for i := range p.Transactions {
 		txs[i] = bytesutil.SafeCopyBytes(p.Transactions[i])

api/client/builder/types_test.go

@@ -12,12 +12,15 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
@@ -1600,7 +1603,6 @@ func TestBuilderBidUnmarshalUint256(t *testing.T) {
 	require.NoError(t, expectedValue.UnmarshalText([]byte(base10)))
 	r := &ExecHeaderResponse{}
 	require.NoError(t, json.Unmarshal([]byte(testBuilderBid), r))
-	//require.Equal(t, expectedValue, r.Data.Message.Value)
 	marshaled := r.Data.Message.Value.String()
 	require.Equal(t, base10, marshaled)
 	require.Equal(t, 0, expectedValue.Cmp(r.Data.Message.Value.Int))
@@ -1907,3 +1909,41 @@ func TestErrorMessage_non200Err(t *testing.T) {
 		})
 	}
 }
+
+func TestEmptyResponseBody(t *testing.T) {
+	t.Run("empty buffer", func(t *testing.T) {
+		var b []byte
+		r := &ExecutionPayloadResponse{}
+		err := json.Unmarshal(b, r)
+		var syntaxError *json.SyntaxError
+		ok := errors.As(err, &syntaxError)
+		require.Equal(t, true, ok)
+	})
+	t.Run("empty object", func(t *testing.T) {
+		empty := []byte("{}")
+		emptyResponse := &ExecutionPayloadResponse{}
+		require.NoError(t, json.Unmarshal(empty, emptyResponse))
+		_, err := emptyResponse.ParsePayload()
+		require.ErrorIs(t, err, consensusblocks.ErrUnsupportedVersion)
+	})
+	versions := []int{version.Bellatrix, version.Capella, version.Deneb}
+	for i := range versions {
+		vstr := version.String(versions[i])
+		t.Run("populated version without payload"+vstr, func(t *testing.T) {
+			in := &ExecutionPayloadResponse{Version: vstr}
+			encoded, err := json.Marshal(in)
+			require.NoError(t, err)
+			epr := &ExecutionPayloadResponse{}
+			require.NoError(t, json.Unmarshal(encoded, epr))
+			pp, err := epr.ParsePayload()
+			require.NoError(t, err)
+			pb, err := pp.PayloadProto()
+			if err == nil {
+				require.NoError(t, err)
+				require.Equal(t, false, pb == nil)
+			} else {
+				require.ErrorIs(t, err, consensusblocks.ErrNilObject)
+			}
+		})
+	}
+}

api/client/event/BUILD.bazel

@@ -2,7 +2,10 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["event_stream.go"],
+    srcs = [
+        "event_stream.go",
+        "utils.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/client/event",
     visibility = ["//visibility:public"],
     deps = [
@@ -15,7 +18,10 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["event_stream_test.go"],
+    srcs = [
+        "event_stream_test.go",
+        "utils_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//testing/require:go_default_library",

api/client/event/event_stream.go

@@ -102,6 +102,8 @@ func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
 	}()
 	// Create a new scanner to read lines from the response body
 	scanner := bufio.NewScanner(resp.Body)
+	// Set the split function for the scanning operation
+	scanner.Split(scanLinesWithCarriage)
 
 	var eventType, data string // Variables to store event type and data
 
@@ -113,7 +115,7 @@ func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
 			close(eventsChannel)
 			return
 		default:
-			line := scanner.Text() // TODO(13730): scanner does not handle /r and does not fully adhere to https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
+			line := scanner.Text()
 			// Handle the event based on your specific format
 			if line == "" {
 				// Empty line indicates the end of an event

api/client/event/event_stream_test.go

@@ -43,8 +43,9 @@ func TestEventStream(t *testing.T) {
 	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
 		flusher, ok := w.(http.Flusher)
 		require.Equal(t, true, ok)
-		for i := 1; i <= 2; i++ {
-			_, err := fmt.Fprintf(w, "event: head\ndata: data%d\n\n", i)
+		for i := 1; i <= 3; i++ {
+			events := [3]string{"event: head\ndata: data%d\n\n", "event: head\rdata: data%d\r\r", "event: head\r\ndata: data%d\r\n\r\n"}
+			_, err := fmt.Fprintf(w, events[i-1], i)
 			require.NoError(t, err)
 			flusher.Flush()                    // Trigger flush to simulate streaming data
 			time.Sleep(100 * time.Millisecond) // Simulate delay between events
@@ -62,7 +63,7 @@ func TestEventStream(t *testing.T) {
 	// Collect events
 	var events []*Event
 
-	for len(events) != 2 {
+	for len(events) != 3 {
 		select {
 		case event := <-eventsChannel:
 			log.Info(event)
@@ -71,7 +72,7 @@ func TestEventStream(t *testing.T) {
 	}
 
 	// Assertions to verify the events content
-	expectedData := []string{"data1", "data2"}
+	expectedData := []string{"data1", "data2", "data3"}
 	for i, event := range events {
 		if string(event.Data) != expectedData[i] {
 			t.Errorf("Expected event data %q, got %q", expectedData[i], string(event.Data))

api/client/event/utils.go

@@ -0,0 +1,36 @@
+package event
+
+import (
+	"bytes"
+)
+
+// adapted from ScanLines in scan.go to handle carriage return characters as separators
+func scanLinesWithCarriage(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	if atEOF && len(data) == 0 {
+		return 0, nil, nil
+	}
+	if i, j := bytes.IndexByte(data, '\n'), bytes.IndexByte(data, '\r'); i >= 0 || j >= 0 {
+		in := i
+		// Select the first index of \n or \r or the second index of \r if it is followed by \n
+		if i < 0 || (i > j && i != j+1 && j >= 0) {
+			in = j
+		}
+
+		// We have a full newline-terminated line.
+		return in + 1, dropCR(data[0:in]), nil
+	}
+	// If we're at EOF, we have a final, non-terminated line. Return it.
+	if atEOF {
+		return len(data), dropCR(data), nil
+	}
+	// Request more data.
+	return 0, nil, nil
+}
+
+// dropCR drops a terminal \r from the data.
+func dropCR(data []byte) []byte {
+	if len(data) > 0 && data[len(data)-1] == '\r' {
+		return data[0 : len(data)-1]
+	}
+	return data
+}

api/client/event/utils_test.go

@@ -0,0 +1,97 @@
+package event
+
+import (
+	"bufio"
+	"bytes"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestScanLinesWithCarriage(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{
+			name:     "LF line endings",
+			input:    "line1\nline2\nline3",
+			expected: []string{"line1", "line2", "line3"},
+		},
+		{
+			name:     "CR line endings",
+			input:    "line1\rline2\rline3",
+			expected: []string{"line1", "line2", "line3"},
+		},
+		{
+			name:     "CRLF line endings",
+			input:    "line1\r\nline2\r\nline3",
+			expected: []string{"line1", "line2", "line3"},
+		},
+		{
+			name:     "Mixed line endings",
+			input:    "line1\nline2\rline3\r\nline4",
+			expected: []string{"line1", "line2", "line3", "line4"},
+		},
+		{
+			name:     "Empty lines",
+			input:    "line1\n\nline2\r\rline3",
+			expected: []string{"line1", "", "line2", "", "line3"},
+		},
+		{
+			name:     "Empty lines 2",
+			input:    "line1\n\rline2\n\rline3",
+			expected: []string{"line1", "", "line2", "", "line3"},
+		},
+		{
+			name:     "No line endings",
+			input:    "single line without ending",
+			expected: []string{"single line without ending"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			scanner := bufio.NewScanner(bytes.NewReader([]byte(tc.input)))
+			scanner.Split(scanLinesWithCarriage)
+
+			var lines []string
+			for scanner.Scan() {
+				lines = append(lines, scanner.Text())
+			}
+
+			require.NoError(t, scanner.Err())
+			require.Equal(t, len(tc.expected), len(lines), "Number of lines does not match")
+			for i, line := range lines {
+				require.Equal(t, tc.expected[i], line, "Line %d does not match", i)
+			}
+		})
+	}
+}
+
+// TestScanLinesWithCarriageEdgeCases tests edge cases and potential error scenarios
+func TestScanLinesWithCarriageEdgeCases(t *testing.T) {
+	t.Run("Empty input", func(t *testing.T) {
+		scanner := bufio.NewScanner(bytes.NewReader([]byte("")))
+		scanner.Split(scanLinesWithCarriage)
+		require.Equal(t, scanner.Scan(), false)
+		require.NoError(t, scanner.Err())
+	})
+
+	t.Run("Very long line", func(t *testing.T) {
+		longLine := bytes.Repeat([]byte("a"), bufio.MaxScanTokenSize+1)
+		scanner := bufio.NewScanner(bytes.NewReader(longLine))
+		scanner.Split(scanLinesWithCarriage)
+		require.Equal(t, scanner.Scan(), false)
+		require.NotNil(t, scanner.Err())
+	})
+
+	t.Run("Line ending at max token size", func(t *testing.T) {
+		input := append(bytes.Repeat([]byte("a"), bufio.MaxScanTokenSize-1), '\n')
+		scanner := bufio.NewScanner(bytes.NewReader(input))
+		scanner.Split(scanLinesWithCarriage)
+		require.Equal(t, scanner.Scan(), true)
+		require.Equal(t, string(bytes.Repeat([]byte("a"), bufio.MaxScanTokenSize-1)), scanner.Text())
+	})
+}

api/constants.go

@@ -4,4 +4,6 @@ const (
 	WebUrlPrefix        = "/v2/validator/"
 	WebApiUrlPrefix     = "/api/v2/validator/"
 	KeymanagerApiPrefix = "/eth/v1"
+	SystemLogsPrefix    = "health/logs"
+	AuthTokenFileName   = "auth-token"
 )

api/gateway/BUILD.bazel

@@ -14,7 +14,7 @@ go_library(
         "//validator:__subpackages__",
     ],
     deps = [
-        "//api/server:go_default_library",
+        "//api/server/middleware:go_default_library",
         "//runtime:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",

api/gateway/gateway.go

@@ -11,7 +11,7 @@ import (
 	"github.com/gorilla/mux"
 	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/api/server"
+	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
 	"github.com/prysmaticlabs/prysm/v5/runtime"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/connectivity"
@@ -104,7 +104,7 @@ func (g *Gateway) Start() {
 		}
 	}
 
-	corsMux := server.CorsHandler(g.cfg.allowedOrigins).Middleware(g.cfg.router)
+	corsMux := middleware.CorsHandler(g.cfg.allowedOrigins).Middleware(g.cfg.router)
 
 	if g.cfg.muxHandler != nil {
 		g.cfg.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

api/jwt.go

@@ -0,0 +1,32 @@
+package api
+
+import (
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
+)
+
+// GenerateRandomHexString generates a random hex string that follows the standards for jwt token
+// used for beacon node -> execution client
+// used for web client -> validator client
+func GenerateRandomHexString() (string, error) {
+	secret := make([]byte, 32)
+	randGen := rand.NewGenerator()
+	n, err := randGen.Read(secret)
+	if err != nil {
+		return "", err
+	} else if n != 32 {
+		return "", errors.New("rand: unexpected length")
+	}
+	return hexutil.Encode(secret), nil
+}
+
+// ValidateAuthToken validating auth token for web
+func ValidateAuthToken(token string) error {
+	b, err := hexutil.Decode(token)
+	// token should be hex-encoded and at least 256 bits
+	if err != nil || len(b) < 32 {
+		return errors.New("invalid auth token: token should be hex-encoded and at least 256 bits")
+	}
+	return nil
+}

api/jwt_test.go

@@ -0,0 +1,13 @@
+package api
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestGenerateRandomHexString(t *testing.T) {
+	token, err := GenerateRandomHexString()
+	require.NoError(t, err)
+	require.NoError(t, ValidateAuthToken(token))
+}

api/server/BUILD.bazel

@@ -2,29 +2,14 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "error.go",
-        "middleware.go",
-        "util.go",
-    ],
+    srcs = ["error.go"],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/server",
     visibility = ["//visibility:public"],
-    deps = [
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_rs_cors//:go_default_library",
-    ],
 )
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "error_test.go",
-        "middleware_test.go",
-        "util_test.go",
-    ],
+    srcs = ["error_test.go"],
     embed = [":go_default_library"],
-    deps = [
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
+    deps = ["//testing/assert:go_default_library"],
 )

api/server/error.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 )
@@ -15,7 +16,8 @@ type DecodeError struct {
 // NewDecodeError wraps an error (either the initial decoding error or another DecodeError).
 // The current field that failed decoding must be passed in.
 func NewDecodeError(err error, field string) *DecodeError {
-	de, ok := err.(*DecodeError)
+	var de *DecodeError
+	ok := errors.As(err, &de)
 	if ok {
 		return &DecodeError{path: append([]string{field}, de.path...), err: de.err}
 	}

api/server/middleware.go

@@ -1,32 +0,0 @@
-package server
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/rs/cors"
-)
-
-// NormalizeQueryValuesHandler normalizes an input query of "key=value1,value2,value3" to "key=value1&key=value2&key=value3"
-func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		query := r.URL.Query()
-		NormalizeQueryValues(query)
-		r.URL.RawQuery = query.Encode()
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// CorsHandler sets the cors settings on api endpoints
-func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
-	c := cors.New(cors.Options{
-		AllowedOrigins:   allowOrigins,
-		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
-		AllowCredentials: true,
-		MaxAge:           600,
-		AllowedHeaders:   []string{"*"},
-	})
-
-	return c.Handler
-}

api/server/middleware/BUILD.bazel

@@ -0,0 +1,29 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "middleware.go",
+        "util.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/api/server/middleware",
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_gorilla_mux//:go_default_library",
+        "@com_github_rs_cors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "middleware_test.go",
+        "util_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//api:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
+)

api/server/middleware/middleware.go

@@ -0,0 +1,112 @@
+package middleware
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
+	"github.com/rs/cors"
+)
+
+// NormalizeQueryValuesHandler normalizes an input query of "key=value1,value2,value3" to "key=value1&key=value2&key=value3"
+func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		query := r.URL.Query()
+		NormalizeQueryValues(query)
+		r.URL.RawQuery = query.Encode()
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+// CorsHandler sets the cors settings on api endpoints
+func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
+	c := cors.New(cors.Options{
+		AllowedOrigins:   allowOrigins,
+		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
+		AllowCredentials: true,
+		MaxAge:           600,
+		AllowedHeaders:   []string{"*"},
+	})
+
+	return c.Handler
+}
+
+// ContentTypeHandler checks request for the appropriate media types otherwise returning a http.StatusUnsupportedMediaType error
+func ContentTypeHandler(acceptedMediaTypes []string) mux.MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			// skip the GET request
+			if r.Method == http.MethodGet {
+				next.ServeHTTP(w, r)
+				return
+			}
+			contentType := r.Header.Get("Content-Type")
+			if contentType == "" {
+				http.Error(w, "Content-Type header is missing", http.StatusUnsupportedMediaType)
+				return
+			}
+
+			accepted := false
+			for _, acceptedType := range acceptedMediaTypes {
+				if strings.Contains(strings.TrimSpace(contentType), strings.TrimSpace(acceptedType)) {
+					accepted = true
+					break
+				}
+			}
+
+			if !accepted {
+				http.Error(w, fmt.Sprintf("Unsupported media type: %s", contentType), http.StatusUnsupportedMediaType)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+// AcceptHeaderHandler checks if the client's response preference is handled
+func AcceptHeaderHandler(serverAcceptedTypes []string) mux.MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			acceptHeader := r.Header.Get("Accept")
+			// header is optional and should skip if not provided
+			if acceptHeader == "" {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			accepted := false
+			acceptTypes := strings.Split(acceptHeader, ",")
+			// follows rules defined in https://datatracker.ietf.org/doc/html/rfc2616#section-14.1
+			for _, acceptType := range acceptTypes {
+				acceptType = strings.TrimSpace(acceptType)
+				if acceptType == "*/*" {
+					accepted = true
+					break
+				}
+				for _, serverAcceptedType := range serverAcceptedTypes {
+					if strings.HasPrefix(acceptType, serverAcceptedType) {
+						accepted = true
+						break
+					}
+					if acceptType != "/*" && strings.HasSuffix(acceptType, "/*") && strings.HasPrefix(serverAcceptedType, acceptType[:len(acceptType)-2]) {
+						accepted = true
+						break
+					}
+				}
+				if accepted {
+					break
+				}
+			}
+
+			if !accepted {
+				http.Error(w, fmt.Sprintf("Not Acceptable: %s", acceptHeader), http.StatusNotAcceptable)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}

api/server/middleware/middleware_test.go

@@ -0,0 +1,204 @@
+package middleware
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/api"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestNormalizeQueryValuesHandler(t *testing.T) {
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := w.Write([]byte("next handler"))
+		require.NoError(t, err)
+	})
+
+	handler := NormalizeQueryValuesHandler(nextHandler)
+
+	tests := []struct {
+		name          string
+		inputQuery    string
+		expectedQuery string
+	}{
+		{
+			name:          "3 values",
+			inputQuery:    "key=value1,value2,value3",
+			expectedQuery: "key=value1&key=value2&key=value3", // replace with expected normalized value
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			req, err := http.NewRequest("GET", "/test?"+test.inputQuery, http.NoBody)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			rr := httptest.NewRecorder()
+			handler.ServeHTTP(rr, req)
+
+			if rr.Code != http.StatusOK {
+				t.Errorf("handler returned wrong status code: got %v want %v", rr.Code, http.StatusOK)
+			}
+
+			if req.URL.RawQuery != test.expectedQuery {
+				t.Errorf("query not normalized: got %v want %v", req.URL.RawQuery, test.expectedQuery)
+			}
+
+			if rr.Body.String() != "next handler" {
+				t.Errorf("next handler was not executed")
+			}
+		})
+	}
+}
+
+func TestContentTypeHandler(t *testing.T) {
+	acceptedMediaTypes := []string{api.JsonMediaType, api.OctetStreamMediaType}
+
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := w.Write([]byte("next handler"))
+		require.NoError(t, err)
+	})
+
+	handler := ContentTypeHandler(acceptedMediaTypes)(nextHandler)
+
+	tests := []struct {
+		name               string
+		contentType        string
+		expectedStatusCode int
+		isGet              bool
+	}{
+		{
+			name:               "Accepted Content-Type - application/json",
+			contentType:        api.JsonMediaType,
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Accepted Content-Type - ssz format",
+			contentType:        api.OctetStreamMediaType,
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Unsupported Content-Type - text/plain",
+			contentType:        "text/plain",
+			expectedStatusCode: http.StatusUnsupportedMediaType,
+		},
+		{
+			name:               "Missing Content-Type",
+			contentType:        "",
+			expectedStatusCode: http.StatusUnsupportedMediaType,
+		},
+		{
+			name:               "GET request skips content type check",
+			contentType:        "",
+			expectedStatusCode: http.StatusOK,
+			isGet:              true,
+		},
+		{
+			name:               "Content type contains charset is ok",
+			contentType:        "application/json; charset=utf-8",
+			expectedStatusCode: http.StatusOK,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			httpMethod := http.MethodPost
+			if tt.isGet {
+				httpMethod = http.MethodGet
+			}
+			req := httptest.NewRequest(httpMethod, "/", nil)
+			if tt.contentType != "" {
+				req.Header.Set("Content-Type", tt.contentType)
+			}
+			rr := httptest.NewRecorder()
+
+			handler.ServeHTTP(rr, req)
+
+			if status := rr.Code; status != tt.expectedStatusCode {
+				t.Errorf("handler returned wrong status code: got %v want %v", status, tt.expectedStatusCode)
+			}
+		})
+	}
+}
+
+func TestAcceptHeaderHandler(t *testing.T) {
+	acceptedTypes := []string{"application/json", "application/octet-stream"}
+
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := w.Write([]byte("next handler"))
+		require.NoError(t, err)
+	})
+
+	handler := AcceptHeaderHandler(acceptedTypes)(nextHandler)
+
+	tests := []struct {
+		name               string
+		acceptHeader       string
+		expectedStatusCode int
+	}{
+		{
+			name:               "Accepted Accept-Type - application/json",
+			acceptHeader:       "application/json",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Accepted Accept-Type - application/octet-stream",
+			acceptHeader:       "application/octet-stream",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Accepted Accept-Type with parameters",
+			acceptHeader:       "application/json;q=0.9, application/octet-stream;q=0.8",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Unsupported Accept-Type - text/plain",
+			acceptHeader:       "text/plain",
+			expectedStatusCode: http.StatusNotAcceptable,
+		},
+		{
+			name:               "Missing Accept header",
+			acceptHeader:       "",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "*/* is accepted",
+			acceptHeader:       "*/*",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "application/* is accepted",
+			acceptHeader:       "application/*",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "/* is unsupported",
+			acceptHeader:       "/*",
+			expectedStatusCode: http.StatusNotAcceptable,
+		},
+		{
+			name:               "application/ is unsupported",
+			acceptHeader:       "application/",
+			expectedStatusCode: http.StatusNotAcceptable,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest("GET", "/", nil)
+			if tt.acceptHeader != "" {
+				req.Header.Set("Accept", tt.acceptHeader)
+			}
+			rr := httptest.NewRecorder()
+
+			handler.ServeHTTP(rr, req)
+
+			if status := rr.Code; status != tt.expectedStatusCode {
+				t.Errorf("handler returned wrong status code: got %v want %v", status, tt.expectedStatusCode)
+			}
+		})
+	}
+}

api/server/middleware/util.go

@@ -1,4 +1,4 @@
-package server
+package middleware
 
 import (
 	"net/url"

api/server/middleware/util_test.go

@@ -1,4 +1,4 @@
-package server
+package middleware
 
 import (
 	"testing"

api/server/middleware_test.go

@@ -1,54 +0,0 @@
-package server
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-)
-
-func TestNormalizeQueryValuesHandler(t *testing.T) {
-	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, err := w.Write([]byte("next handler"))
-		require.NoError(t, err)
-	})
-
-	handler := NormalizeQueryValuesHandler(nextHandler)
-
-	tests := []struct {
-		name          string
-		inputQuery    string
-		expectedQuery string
-	}{
-		{
-			name:          "3 values",
-			inputQuery:    "key=value1,value2,value3",
-			expectedQuery: "key=value1&key=value2&key=value3", // replace with expected normalized value
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			req, err := http.NewRequest("GET", "/test?"+test.inputQuery, nil)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			rr := httptest.NewRecorder()
-			handler.ServeHTTP(rr, req)
-
-			if rr.Code != http.StatusOK {
-				t.Errorf("handler returned wrong status code: got %v want %v", rr.Code, http.StatusOK)
-			}
-
-			if req.URL.RawQuery != test.expectedQuery {
-				t.Errorf("query not normalized: got %v want %v", req.URL.RawQuery, test.expectedQuery)
-			}
-
-			if rr.Body.String() != "next handler" {
-				t.Errorf("next handler was not executed")
-			}
-		})
-	}
-}

api/server/structs/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "//api/server:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//container/slice:go_default_library",

api/server/structs/block.go

@@ -1,10 +1,34 @@
 package structs
 
+import "encoding/json"
+
+// MessageJsoner describes a signed consensus type wrapper that can return the `.Message` field in a json envelope
+// encoded as a []byte, for use as a json.RawMessage value when encoding the outer envelope.
+type MessageJsoner interface {
+	MessageRawJson() ([]byte, error)
+}
+
+// SignedMessageJsoner embeds MessageJsoner and adds a method to also retrieve the Signature field as a string.
+type SignedMessageJsoner interface {
+	MessageJsoner
+	SigString() string
+}
+
 type SignedBeaconBlock struct {
 	Message   *BeaconBlock `json:"message"`
 	Signature string       `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlock{}
+
+func (s *SignedBeaconBlock) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlock) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlock struct {
 	Slot          string           `json:"slot"`
 	ProposerIndex string           `json:"proposer_index"`
@@ -29,6 +53,16 @@ type SignedBeaconBlockAltair struct {
 	Signature string             `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockAltair{}
+
+func (s *SignedBeaconBlockAltair) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockAltair) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockAltair struct {
 	Slot          string                 `json:"slot"`
 	ProposerIndex string                 `json:"proposer_index"`
@@ -54,6 +88,16 @@ type SignedBeaconBlockBellatrix struct {
 	Signature string                `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockBellatrix{}
+
+func (s *SignedBeaconBlockBellatrix) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockBellatrix) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockBellatrix struct {
 	Slot          string                    `json:"slot"`
 	ProposerIndex string                    `json:"proposer_index"`
@@ -80,6 +124,16 @@ type SignedBlindedBeaconBlockBellatrix struct {
 	Signature string                       `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockBellatrix{}
+
+func (s *SignedBlindedBeaconBlockBellatrix) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockBellatrix) SigString() string {
+	return s.Signature
+}
+
 type BlindedBeaconBlockBellatrix struct {
 	Slot          string                           `json:"slot"`
 	ProposerIndex string                           `json:"proposer_index"`
@@ -106,6 +160,16 @@ type SignedBeaconBlockCapella struct {
 	Signature string              `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockCapella{}
+
+func (s *SignedBeaconBlockCapella) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockCapella) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockCapella struct {
 	Slot          string                  `json:"slot"`
 	ProposerIndex string                  `json:"proposer_index"`
@@ -133,6 +197,16 @@ type SignedBlindedBeaconBlockCapella struct {
 	Signature string                     `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockCapella{}
+
+func (s *SignedBlindedBeaconBlockCapella) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockCapella) SigString() string {
+	return s.Signature
+}
+
 type BlindedBeaconBlockCapella struct {
 	Slot          string                         `json:"slot"`
 	ProposerIndex string                         `json:"proposer_index"`
@@ -172,6 +246,16 @@ type SignedBeaconBlockDeneb struct {
 	Signature string            `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockDeneb{}
+
+func (s *SignedBeaconBlockDeneb) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockDeneb) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockDeneb struct {
 	Slot          string                `json:"slot"`
 	ProposerIndex string                `json:"proposer_index"`
@@ -208,6 +292,16 @@ type SignedBlindedBeaconBlockDeneb struct {
 	Signature string                   `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockDeneb{}
+
+func (s *SignedBlindedBeaconBlockDeneb) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockDeneb) SigString() string {
+	return s.Signature
+}
+
 type BlindedBeaconBlockBodyDeneb struct {
 	RandaoReveal           string                        `json:"randao_reveal"`
 	Eth1Data               *Eth1Data                     `json:"eth1_data"`

api/server/structs/conversions.go

@@ -8,11 +8,10 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
-	"github.com/prysmaticlabs/prysm/v5/container/slice"
-
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
+	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"

api/server/structs/conversions_block.go

@@ -6,8 +6,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -15,6 +17,8 @@ import (
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
+var ErrUnsupportedConversion = errors.New("Could not determine api struct type to use for value")
+
 func (h *SignedBeaconBlockHeader) ToConsensus() (*eth.SignedBeaconBlockHeader, error) {
 	msg, err := h.Message.ToConsensus()
 	if err != nil {
@@ -1852,7 +1856,34 @@ func BeaconBlockFromConsensus(b *eth.BeaconBlock) *BeaconBlock {
 	}
 }
 
-func SignedBeaconBlockFromConsensus(b *eth.SignedBeaconBlock) *SignedBeaconBlock {
+func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock) (SignedMessageJsoner, error) {
+	pb, err := block.Proto()
+	if err != nil {
+		return nil, err
+	}
+	switch pbStruct := pb.(type) {
+	case *eth.SignedBeaconBlock:
+		return SignedBeaconBlockPhase0FromConsensus(pbStruct), nil
+	case *eth.SignedBeaconBlockAltair:
+		return SignedBeaconBlockAltairFromConsensus(pbStruct), nil
+	case *eth.SignedBlindedBeaconBlockBellatrix:
+		return SignedBlindedBeaconBlockBellatrixFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockBellatrix:
+		return SignedBeaconBlockBellatrixFromConsensus(pbStruct)
+	case *eth.SignedBlindedBeaconBlockCapella:
+		return SignedBlindedBeaconBlockCapellaFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockCapella:
+		return SignedBeaconBlockCapellaFromConsensus(pbStruct)
+	case *eth.SignedBlindedBeaconBlockDeneb:
+		return SignedBlindedBeaconBlockDenebFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockDeneb:
+		return SignedBeaconBlockDenebFromConsensus(pbStruct)
+	default:
+		return nil, ErrUnsupportedConversion
+	}
+}
+
+func SignedBeaconBlockPhase0FromConsensus(b *eth.SignedBeaconBlock) *SignedBeaconBlock {
 	return &SignedBeaconBlock{
 		Message:   BeaconBlockFromConsensus(b.Block),
 		Signature: hexutil.Encode(b.Signature),

api/server/structs/endpoints_beacon.go

@@ -196,3 +196,48 @@ type DepositSnapshot struct {
 	ExecutionBlockHash   string   `json:"execution_block_hash"`
 	ExecutionBlockHeight string   `json:"execution_block_height"`
 }
+
+type GetIndividualVotesRequest struct {
+	Epoch      string   `json:"epoch"`
+	PublicKeys []string `json:"public_keys,omitempty"`
+	Indices    []string `json:"indices,omitempty"`
+}
+
+type GetIndividualVotesResponse struct {
+	IndividualVotes []*IndividualVote `json:"individual_votes"`
+}
+
+type IndividualVote struct {
+	Epoch                            string `json:"epoch"`
+	PublicKey                        string `json:"public_keys,omitempty"`
+	ValidatorIndex                   string `json:"validator_index"`
+	IsSlashed                        bool   `json:"is_slashed"`
+	IsWithdrawableInCurrentEpoch     bool   `json:"is_withdrawable_in_current_epoch"`
+	IsActiveInCurrentEpoch           bool   `json:"is_active_in_current_epoch"`
+	IsActiveInPreviousEpoch          bool   `json:"is_active_in_previous_epoch"`
+	IsCurrentEpochAttester           bool   `json:"is_current_epoch_attester"`
+	IsCurrentEpochTargetAttester     bool   `json:"is_current_epoch_target_attester"`
+	IsPreviousEpochAttester          bool   `json:"is_previous_epoch_attester"`
+	IsPreviousEpochTargetAttester    bool   `json:"is_previous_epoch_target_attester"`
+	IsPreviousEpochHeadAttester      bool   `json:"is_previous_epoch_head_attester"`
+	CurrentEpochEffectiveBalanceGwei string `json:"current_epoch_effective_balance_gwei"`
+	InclusionSlot                    string `json:"inclusion_slot"`
+	InclusionDistance                string `json:"inclusion_distance"`
+	InactivityScore                  string `json:"inactivity_score"`
+}
+
+type ChainHead struct {
+	HeadSlot                   string `json:"head_slot"`
+	HeadEpoch                  string `json:"head_epoch"`
+	HeadBlockRoot              string `json:"head_block_root"`
+	FinalizedSlot              string `json:"finalized_slot"`
+	FinalizedEpoch             string `json:"finalized_epoch"`
+	FinalizedBlockRoot         string `json:"finalized_block_root"`
+	JustifiedSlot              string `json:"justified_slot"`
+	JustifiedEpoch             string `json:"justified_epoch"`
+	JustifiedBlockRoot         string `json:"justified_block_root"`
+	PreviousJustifiedSlot      string `json:"previous_justified_slot"`
+	PreviousJustifiedEpoch     string `json:"previous_justified_epoch"`
+	PreviousJustifiedBlockRoot string `json:"previous_justified_block_root"`
+	OptimisticStatus           bool   `json:"optimistic_status"`
+}

api/server/structs/endpoints_validator.go

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

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",
@@ -26,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",
@@ -44,6 +46,7 @@ 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",
@@ -64,6 +67,7 @@ go_library(
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/slasher/types:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
@@ -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",
@@ -137,7 +142,8 @@ go_test(
         "//async/event:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/cache/depositcache:go_default_library",
+        "//beacon-chain/cache/depositsnapshot:go_default_library",
+        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -165,6 +171,7 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/epbs:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/trie:go_default_library",
@@ -181,6 +188,7 @@ go_test(
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -6,12 +6,9 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	f "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -21,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	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
@@ -50,6 +48,8 @@ type ForkchoiceFetcher interface {
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
 	NewSlot(context.Context, primitives.Slot) error
 	ProposerBoost() [32]byte
+	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
+	IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error)
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
@@ -399,14 +399,6 @@ func (s *Service) InForkchoice(root [32]byte) bool {
 	return s.cfg.ForkChoiceStore.HasNode(root)
 }
 
-// IsViableForCheckpoint returns whether the given checkpoint is a checkpoint in any
-// chain known to forkchoice
-func (s *Service) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool, error) {
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.IsViableForCheckpoint(cp)
-}
-
 // 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) {
@@ -518,13 +510,6 @@ func (s *Service) Ancestor(ctx context.Context, root []byte, slot primitives.Slo
 	return ar[:], nil
 }
 
-// SetOptimisticToInvalid wraps the corresponding method in forkchoice
-func (s *Service) SetOptimisticToInvalid(ctx context.Context, root, parent, lvh [32]byte) ([][32]byte, error) {
-	s.cfg.ForkChoiceStore.Lock()
-	defer s.cfg.ForkChoiceStore.Unlock()
-	return s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, parent, lvh)
-}
-
 // SetGenesisTime sets the genesis time of beacon chain.
 func (s *Service) SetGenesisTime(t time.Time) {
 	s.genesisTime = t
@@ -545,6 +530,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

@@ -99,3 +99,10 @@ func (s *Service) FinalizedBlockHash() [32]byte {
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	return s.cfg.ForkChoiceStore.FinalizedPayloadBlockHash()
 }
+
+// ParentRoot wraps a call to the corresponding method in forkchoice
+func (s *Service) ParentRoot(root [32]byte) ([32]byte, error) {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.ParentRoot(root)
+}

beacon-chain/blockchain/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"
@@ -28,8 +27,6 @@ import (
 	"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:
@@ -74,8 +71,8 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	}
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, arg.attributes)
 	if err != nil {
-		switch err {
-		case execution.ErrAcceptedSyncingPayloadStatus:
+		switch {
+		case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 			forkchoiceUpdatedOptimisticNodeCount.Inc()
 			log.WithFields(logrus.Fields{
 				"headSlot":                  headBlk.Slot(),
@@ -83,7 +80,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash[:])),
 			}).Info("Called fork choice updated with optimistic block")
 			return payloadID, nil
-		case execution.ErrInvalidPayloadStatus:
+		case errors.Is(err, execution.ErrInvalidPayloadStatus):
 			forkchoiceUpdatedInvalidNodeCount.Inc()
 			headRoot := arg.headRoot
 			if len(lastValidHash) == 0 {
@@ -139,7 +136,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				"newHeadRoot":          fmt.Sprintf("%#x", bytesutil.Trunc(r[:])),
 			}).Warn("Pruned invalid blocks")
 			return pid, invalidBlock{error: ErrInvalidPayload, root: arg.headRoot, invalidAncestorRoots: invalidRoots}
-
 		default:
 			log.WithError(err).Error(ErrUndefinedExecutionEngineError)
 			return nil, nil
@@ -231,18 +227,18 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 	} else {
 		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, []common.Hash{}, &common.Hash{} /*empty version hashes and root before Deneb*/)
 	}
-	switch err {
-	case nil:
+	switch {
+	case err == nil:
 		newPayloadValidNodeCount.Inc()
 		return true, nil
-	case execution.ErrAcceptedSyncingPayloadStatus:
+	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 		newPayloadOptimisticNodeCount.Inc()
 		log.WithFields(logrus.Fields{
 			"slot":             blk.Block().Slot(),
 			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
 		}).Info("Called new payload with optimistic block")
 		return false, nil
-	case execution.ErrInvalidPayloadStatus:
+	case errors.Is(err, execution.ErrInvalidPayloadStatus):
 		lvh := bytesutil.ToBytes32(lastValidHash)
 		return false, invalidBlock{
 			error:         ErrInvalidPayload,
@@ -256,7 +252,7 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 // reportInvalidBlock deals with the event that an invalid block was detected by the execution layer
 func (s *Service) pruneInvalidBlock(ctx context.Context, root, parentRoot, lvh [32]byte) error {
 	newPayloadInvalidNodeCount.Inc()
-	invalidRoots, err := s.SetOptimisticToInvalid(ctx, root, parentRoot, lvh)
+	invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, parentRoot, lvh)
 	if err != nil {
 		return err
 	}
@@ -324,8 +320,8 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 
 	var attr payloadattribute.Attributer
 	switch st.Version() {
-	case version.Deneb:
-		withdrawals, err := st.ExpectedWithdrawals()
+	case version.Deneb, version.Electra:
+		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
 			return emptyAttri
@@ -342,7 +338,7 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			return emptyAttri
 		}
 	case version.Capella:
-		withdrawals, err := st.ExpectedWithdrawals()
+		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
 			return emptyAttri
@@ -403,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

@@ -855,41 +855,63 @@ func Test_GetPayloadAttributeV2(t *testing.T) {
 	require.Equal(t, 0, len(a))
 }
 
-func Test_GetPayloadAttributeDeneb(t *testing.T) {
-	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
-	ctx := tr.ctx
+func Test_GetPayloadAttributeV3(t *testing.T) {
+	var testCases = []struct {
+		name string
+		st   bstate.BeaconState
+	}{
+		{
+			name: "deneb",
+			st: func() bstate.BeaconState {
+				st, _ := util.DeterministicGenesisStateDeneb(t, 1)
+				return st
+			}(),
+		},
+		{
+			name: "electra",
+			st: func() bstate.BeaconState {
+				st, _ := util.DeterministicGenesisStateElectra(t, 1)
+				return st
+			}(),
+		},
+	}
 
-	st, _ := util.DeterministicGenesisStateDeneb(t, 1)
-	attr := service.getPayloadAttribute(ctx, st, 0, []byte{})
-	require.Equal(t, true, attr.IsEmpty())
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+			service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+			ctx := tr.ctx
 
-	// Cache hit, advance state, no fee recipient
-	slot := primitives.Slot(1)
-	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, Index: 0})
-	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
-	attr = service.getPayloadAttribute(ctx, st, slot, params.BeaconConfig().ZeroHash[:])
-	require.Equal(t, false, attr.IsEmpty())
-	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient()).String())
-	a, err := attr.Withdrawals()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(a))
+			attr := service.getPayloadAttribute(ctx, test.st, 0, []byte{})
+			require.Equal(t, true, attr.IsEmpty())
 
-	// Cache hit, advance state, has fee recipient
-	suggestedAddr := common.HexToAddress("123")
-	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, FeeRecipient: primitives.ExecutionAddress(suggestedAddr), Index: 0})
-	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
-	attr = service.getPayloadAttribute(ctx, st, slot, params.BeaconConfig().ZeroHash[:])
-	require.Equal(t, false, attr.IsEmpty())
-	require.Equal(t, suggestedAddr, common.BytesToAddress(attr.SuggestedFeeRecipient()))
-	a, err = attr.Withdrawals()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(a))
+			// Cache hit, advance state, no fee recipient
+			slot := primitives.Slot(1)
+			service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, Index: 0})
+			service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+			attr = service.getPayloadAttribute(ctx, test.st, slot, params.BeaconConfig().ZeroHash[:])
+			require.Equal(t, false, attr.IsEmpty())
+			require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient()).String())
+			a, err := attr.Withdrawals()
+			require.NoError(t, err)
+			require.Equal(t, 0, len(a))
 
-	attrV3, err := attr.PbV3()
-	require.NoError(t, err)
-	hr := service.headRoot()
-	require.Equal(t, hr, [32]byte(attrV3.ParentBeaconBlockRoot))
+			// Cache hit, advance state, has fee recipient
+			suggestedAddr := common.HexToAddress("123")
+			service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, FeeRecipient: primitives.ExecutionAddress(suggestedAddr), Index: 0})
+			service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+			attr = service.getPayloadAttribute(ctx, test.st, slot, params.BeaconConfig().ZeroHash[:])
+			require.Equal(t, false, attr.IsEmpty())
+			require.Equal(t, suggestedAddr, common.BytesToAddress(attr.SuggestedFeeRecipient()))
+			a, err = attr.Withdrawals()
+			require.NoError(t, err)
+			require.Equal(t, 0, len(a))
 
+			attrV3, err := attr.PbV3()
+			require.NoError(t, err)
+			hr := service.headRoot()
+			require.Equal(t, hr, [32]byte(attrV3.ParentBeaconBlockRoot))
+		})
+	}
 }
 
 func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
@@ -1034,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

@@ -401,7 +401,7 @@ func (s *Service) saveOrphanedOperations(ctx context.Context, orphanedRoot [32]b
 		}
 		for _, a := range orphanedBlk.Block().Body().Attestations() {
 			// if the attestation is one epoch older, it wouldn't been useful to save it.
-			if a.Data.Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
+			if a.GetData().Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
 				continue
 			}
 			if helpers.IsAggregated(a) {

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -61,7 +61,7 @@ func TestService_headNextSyncCommitteeIndices(t *testing.T) {
 	indices, err := c.headNextSyncCommitteeIndices(context.Background(), 0, primitives.Slot(slot))
 	require.NoError(t, err)
 
-	// NextSyncCommittee should be be empty after `ProcessSyncCommitteeUpdates`. Validator should get indices.
+	// NextSyncCommittee should be empty after `ProcessSyncCommitteeUpdates`. Validator should get indices.
 	require.NotEqual(t, 0, len(indices))
 }
 

beacon-chain/blockchain/head_test.go

@@ -312,14 +312,14 @@ func TestSaveOrphanedAtts(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
+	wantAtts := []ethpb.Att{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
 	}
 	atts := service.cfg.AttPool.AggregatedAttestations()
 	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
+		return atts[i].GetData().Slot > atts[j].GetData().Slot
 	})
 	require.DeepEqual(t, wantAtts, atts)
 }
@@ -389,14 +389,14 @@ func TestSaveOrphanedOps(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
+	wantAtts := []ethpb.Att{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
 	}
 	atts := service.cfg.AttPool.AggregatedAttestations()
 	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
+		return atts[i].GetData().Slot > atts[j].GetData().Slot
 	})
 	require.DeepEqual(t, wantAtts, atts)
 	require.Equal(t, 1, len(service.cfg.SlashingPool.PendingProposerSlashings(ctx, st, false)))
@@ -517,14 +517,14 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
+	wantAtts := []ethpb.Att{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
 	}
 	atts := service.cfg.AttPool.AggregatedAttestations()
 	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
+		return atts[i].GetData().Slot > atts[j].GetData().Slot
 	})
 	require.DeepEqual(t, wantAtts, atts)
 }

beacon-chain/blockchain/lightclient.go

@@ -16,7 +16,7 @@ import (
 )
 
 const (
-	finalityBranchNumOfLeaves = 6
+	FinalityBranchNumOfLeaves = 6
 )
 
 // CreateLightClientFinalityUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_finality_update
@@ -69,7 +69,7 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	// assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS
 	syncAggregate, err := block.Block().Body().SyncAggregate()
 	if err != nil {
-		return nil, fmt.Errorf("could not get sync aggregate %v", err)
+		return nil, fmt.Errorf("could not get sync aggregate %w", err)
 	}
 
 	if syncAggregate.SyncCommitteeBits.Count() < params.BeaconConfig().MinSyncCommitteeParticipants {
@@ -85,18 +85,18 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	header := state.LatestBlockHeader()
 	stateRoot, err := state.HashTreeRoot(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("could not get state root %v", err)
+		return nil, fmt.Errorf("could not get state root %w", err)
 	}
 	header.StateRoot = stateRoot[:]
 
 	headerRoot, err := header.HashTreeRoot()
 	if err != nil {
-		return nil, fmt.Errorf("could not get header root %v", err)
+		return nil, fmt.Errorf("could not get header root %w", err)
 	}
 
 	blockRoot, err := block.Block().HashTreeRoot()
 	if err != nil {
-		return nil, fmt.Errorf("could not get block root %v", err)
+		return nil, fmt.Errorf("could not get block root %w", err)
 	}
 
 	if headerRoot != blockRoot {
@@ -114,14 +114,14 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	// attested_header.state_root = hash_tree_root(attested_state)
 	attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("could not get attested state root %v", err)
+		return nil, fmt.Errorf("could not get attested state root %w", err)
 	}
 	attestedHeader.StateRoot = attestedStateRoot[:]
 
 	// assert hash_tree_root(attested_header) == block.message.parent_root
 	attestedHeaderRoot, err := attestedHeader.HashTreeRoot()
 	if err != nil {
-		return nil, fmt.Errorf("could not get attested header root %v", err)
+		return nil, fmt.Errorf("could not get attested header root %w", err)
 	}
 
 	if attestedHeaderRoot != block.Block().ParentRoot() {
@@ -175,13 +175,13 @@ func NewLightClientFinalityUpdateFromBeaconState(
 		if finalizedBlock.Block().Slot() != 0 {
 			tempFinalizedHeader, err := finalizedBlock.Header()
 			if err != nil {
-				return nil, fmt.Errorf("could not get finalized header %v", err)
+				return nil, fmt.Errorf("could not get finalized header %w", err)
 			}
 			finalizedHeader = migration.V1Alpha1SignedHeaderToV1(tempFinalizedHeader).GetMessage()
 
 			finalizedHeaderRoot, err := finalizedHeader.HashTreeRoot()
 			if err != nil {
-				return nil, fmt.Errorf("could not get finalized header root %v", err)
+				return nil, fmt.Errorf("could not get finalized header root %w", err)
 			}
 
 			if finalizedHeaderRoot != bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root) {
@@ -204,7 +204,7 @@ func NewLightClientFinalityUpdateFromBeaconState(
 		var bErr error
 		finalityBranch, bErr = attestedState.FinalizedRootProof(ctx)
 		if bErr != nil {
-			return nil, fmt.Errorf("could not get finalized root proof %v", bErr)
+			return nil, fmt.Errorf("could not get finalized root proof %w", bErr)
 		}
 	} else {
 		finalizedHeader = &ethpbv1.BeaconBlockHeader{
@@ -215,8 +215,8 @@ func NewLightClientFinalityUpdateFromBeaconState(
 			BodyRoot:      make([]byte, 32),
 		}
 
-		finalityBranch = make([][]byte, finalityBranchNumOfLeaves)
-		for i := 0; i < finalityBranchNumOfLeaves; i++ {
+		finalityBranch = make([][]byte, FinalityBranchNumOfLeaves)
+		for i := 0; i < FinalityBranchNumOfLeaves; i++ {
 			finalityBranch[i] = make([]byte, 32)
 		}
 	}

beacon-chain/blockchain/lightclient_test.go

@@ -153,7 +153,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 	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")
+	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()",
@@ -369,6 +373,6 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 
 func reportAttestationInclusion(blk interfaces.ReadOnlyBeaconBlock) {
 	for _, att := range blk.Body().Attestations() {
-		attestationInclusionDelay.Observe(float64(blk.Slot() - att.Data.Slot))
+		attestationInclusionDelay.Observe(float64(blk.Slot() - att.GetData().Slot))
 	}
 }

beacon-chain/blockchain/options.go

@@ -69,6 +69,14 @@ 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
+	}
+}
+
 // WithPayloadIDCache for payload ID cache.
 func WithPayloadIDCache(c *cache.PayloadIDCache) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation.go

@@ -36,17 +36,17 @@ import (
 //
 //	 # Update latest messages for attesting indices
 //	 update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, disparity time.Duration) error {
+func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
 	if err := helpers.ValidateNilAttestation(a); err != nil {
 		return err
 	}
-	if err := helpers.ValidateSlotTargetEpoch(a.Data); err != nil {
+	if err := helpers.ValidateSlotTargetEpoch(a.GetData()); err != nil {
 		return err
 	}
-	tgt := ethpb.CopyCheckpoint(a.Data.Target)
+	tgt := a.GetData().Target.Copy()
 
 	// Note that target root check is ignored here because it was performed in sync's validation pipeline:
 	// validate_aggregate_proof.go and validate_beacon_attestation.go
@@ -67,7 +67,7 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, dispa
 	}
 
 	// Verify attestation beacon block is known and not from the future.
-	if err := s.verifyBeaconBlock(ctx, a.Data); err != nil {
+	if err := s.verifyBeaconBlock(ctx, a.GetData()); err != nil {
 		return errors.Wrap(err, "could not verify attestation beacon block")
 	}
 
@@ -75,16 +75,16 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, dispa
 	// validate_aggregate_proof.go and validate_beacon_attestation.go
 
 	// Verify attestations can only affect the fork choice of subsequent slots.
-	if err := slots.VerifyTime(genesisTime, a.Data.Slot+1, disparity); err != nil {
+	if err := slots.VerifyTime(genesisTime, a.GetData().Slot+1, disparity); err != nil {
 		return err
 	}
 
 	// Use the target state to verify attesting indices are valid.
-	committee, err := helpers.BeaconCommitteeFromState(ctx, baseState, a.Data.Slot, a.Data.CommitteeIndex)
+	committees, err := helpers.AttestationCommittees(ctx, baseState, a)
 	if err != nil {
 		return err
 	}
-	indexedAtt, err := attestation.ConvertToIndexed(ctx, a, committee)
+	indexedAtt, err := attestation.ConvertToIndexed(ctx, a, committees...)
 	if err != nil {
 		return err
 	}
@@ -97,7 +97,7 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, dispa
 	// 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.AttestingIndices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Slot)
 
 	return nil
 }

beacon-chain/blockchain/process_attestation_test.go

@@ -7,9 +7,11 @@ import (
 	"time"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
+	"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/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -73,7 +75,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 
 	tests := []struct {
 		name      string
-		a         *ethpb.Attestation
+		a         ethpb.Att
 		wantedErr string
 	}{
 		{
@@ -125,25 +127,36 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 }
 
 func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
+	eval := func(ctx context.Context, service *Service, genesisState state.BeaconState, pks []bls.SecretKey) {
+		service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
+		require.NoError(t, service.saveGenesisData(ctx, genesisState))
+		att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+		require.NoError(t, err)
+		tRoot := bytesutil.ToBytes32(att[0].GetData().Target.Root)
+		copied := genesisState.Copy()
+		copied, err = transition.ProcessSlots(ctx, copied, 1)
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
+		ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
+		ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
+		state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
+		require.NoError(t, service.OnAttestation(ctx, att[0], 0))
+	}
 
-	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
-	require.NoError(t, err)
-	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
-	copied := genesisState.Copy()
-	copied, err = transition.ProcessSlots(ctx, copied, 1)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-	ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, service.OnAttestation(ctx, att[0], 0))
+	t.Run("pre-Electra", func(t *testing.T) {
+		service, tr := minimalTestService(t)
+		ctx := tr.ctx
+		genesisState, pks := util.DeterministicGenesisState(t, 64)
+		eval(ctx, service, genesisState, pks)
+	})
+	t.Run("post-Electra", func(t *testing.T) {
+		service, tr := minimalTestService(t)
+		ctx := tr.ctx
+		genesisState, pks := util.DeterministicGenesisStateElectra(t, 64)
+		eval(ctx, service, genesisState, pks)
+	})
 }
 
 func TestService_GetRecentPreState(t *testing.T) {

beacon-chain/blockchain/process_block.go

@@ -6,9 +6,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
@@ -32,6 +29,8 @@ import (
 	"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.
@@ -143,7 +142,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	b := blks[0].Block()
 
 	// Retrieve incoming block's pre state.
-	if err := s.verifyBlkPreState(ctx, b); err != nil {
+	if err := s.verifyBlkPreState(ctx, b.ParentRoot()); err != nil {
 		return err
 	}
 	preState, err := s.cfg.StateGen.StateByRootInitialSync(ctx, b.ParentRoot())
@@ -366,17 +365,17 @@ func (s *Service) handleEpochBoundary(ctx context.Context, slot primitives.Slot,
 func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock, st state.BeaconState) error {
 	// Feed in block's attestations to fork choice store.
 	for _, a := range blk.Body().Attestations() {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, st, a.Data.Slot, a.Data.CommitteeIndex)
+		committees, err := helpers.AttestationCommittees(ctx, st, a)
 		if err != nil {
 			return err
 		}
-		indices, err := attestation.AttestingIndices(a.AggregationBits, committee)
+		indices, err := attestation.AttestingIndices(a, committees...)
 		if err != nil {
 			return err
 		}
-		r := bytesutil.ToBytes32(a.Data.BeaconBlockRoot)
+		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
-			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.Data.Target.Epoch)
+			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Slot)
 		} else if err := s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
 			return err
 		}
@@ -387,7 +386,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 // InsertSlashingsToForkChoiceStore inserts attester slashing indices to fork choice store.
 // To call this function, it's caller's responsibility to ensure the slashing object is valid.
 // This function requires a write lock on forkchoice.
-func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {
+func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []ethpb.AttSlashing) {
 	for _, slashing := range slashings {
 		indices := blocks.SlashableAttesterIndices(slashing)
 		for _, index := range indices {

beacon-chain/blockchain/process_block_helpers.go

@@ -7,9 +7,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -17,6 +14,7 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -25,6 +23,8 @@ import (
 	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.
@@ -286,7 +286,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 	defer span.End()
 
 	// Verify incoming block has a valid pre state.
-	if err := s.verifyBlkPreState(ctx, b); err != nil {
+	if err := s.verifyBlkPreState(ctx, b.ParentRoot()); err != nil {
 		return nil, err
 	}
 
@@ -312,11 +312,10 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 }
 
 // verifyBlkPreState validates input block has a valid pre-state.
-func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.ReadOnlyBeaconBlock) error {
+func (s *Service) verifyBlkPreState(ctx context.Context, parentRoot [field_params.RootLength]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()
 
-	parentRoot := b.ParentRoot()
 	// Loosen the check to HasBlock because state summary gets saved in batches
 	// during initial syncing. There's no risk given a state summary object is just a
 	// subset of the block object.

beacon-chain/blockchain/process_block_test.go

@@ -117,7 +117,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: root[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, root, st))
-	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block()))
+	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block().ParentRoot()))
 }
 
 func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
@@ -824,7 +824,10 @@ func TestRemoveBlockAttestationsInPool(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: r[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, r))
 
-	atts := b.Block.Body.Attestations
+	atts := make([]ethpb.Att, len(b.Block.Body.Attestations))
+	for i, a := range b.Block.Body.Attestations {
+		atts[i] = a
+	}
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
@@ -1960,68 +1963,130 @@ func TestNoViableHead_Reboot(t *testing.T) {
 }
 
 func TestOnBlock_HandleBlockAttestations(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
+	t.Run("pre-Electra", func(t *testing.T) {
+		service, tr := minimalTestService(t)
+		ctx := tr.ctx
 
-	st, keys := util.DeterministicGenesisState(t, 64)
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
+		st, keys := util.DeterministicGenesisState(t, 64)
+		stateRoot, err := st.HashTreeRoot(ctx)
+		require.NoError(t, err, "Could not hash genesis state")
 
-	require.NoError(t, service.saveGenesisData(ctx, st))
+		require.NoError(t, service.saveGenesisData(ctx, st))
 
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
+		genesis := blocks.NewGenesisBlock(stateRoot[:])
+		wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
+		parentRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err, "Could not get signing root")
+		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
+		require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
-	st, err = service.HeadState(ctx)
-	require.NoError(t, err)
-	b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	root, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	preState, err := service.getBlockPreState(ctx, wsb.Block())
-	require.NoError(t, err)
-	postState, err := service.validateStateTransition(ctx, preState, wsb)
-	require.NoError(t, err)
-	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
+		st, err = service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
+		require.NoError(t, err)
+		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		preState, err := service.getBlockPreState(ctx, wsb.Block())
+		require.NoError(t, err)
+		postState, err := service.validateStateTransition(ctx, preState, wsb)
+		require.NoError(t, err)
+		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 
-	st, err = service.HeadState(ctx)
-	require.NoError(t, err)
-	b, err = util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
+		st, err = service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err = util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
+		require.NoError(t, err)
+		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
 
-	// prepare another block that is not inserted
-	st3, err := transition.ExecuteStateTransition(ctx, st, wsb)
-	require.NoError(t, err)
-	b3, err := util.GenerateFullBlock(st3, keys, util.DefaultBlockGenConfig(), 3)
-	require.NoError(t, err)
-	wsb3, err := consensusblocks.NewSignedBeaconBlock(b3)
-	require.NoError(t, err)
+		// prepare another block that is not inserted
+		st3, err := transition.ExecuteStateTransition(ctx, st, wsb)
+		require.NoError(t, err)
+		b3, err := util.GenerateFullBlock(st3, keys, util.DefaultBlockGenConfig(), 3)
+		require.NoError(t, err)
+		wsb3, err := consensusblocks.NewSignedBeaconBlock(b3)
+		require.NoError(t, err)
 
-	require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
-	a := wsb.Block().Body().Attestations()[0]
-	r := bytesutil.ToBytes32(a.Data.BeaconBlockRoot)
-	require.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(r))
+		require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
+		a := wsb.Block().Body().Attestations()[0]
+		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
+		require.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(r))
 
-	require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
-	a3 := wsb3.Block().Body().Attestations()[0]
-	r3 := bytesutil.ToBytes32(a3.Data.BeaconBlockRoot)
-	require.Equal(t, false, service.cfg.ForkChoiceStore.HasNode(r3))
+		require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
+		a3 := wsb3.Block().Body().Attestations()[0]
+		r3 := bytesutil.ToBytes32(a3.GetData().BeaconBlockRoot)
+		require.Equal(t, false, service.cfg.ForkChoiceStore.HasNode(r3))
 
-	require.NoError(t, service.handleBlockAttestations(ctx, wsb.Block(), st)) // fine to use the same committee as st
-	require.Equal(t, 0, service.cfg.AttPool.ForkchoiceAttestationCount())
-	require.NoError(t, service.handleBlockAttestations(ctx, wsb3.Block(), st3)) // fine to use the same committee as st
-	require.Equal(t, 1, len(service.cfg.AttPool.BlockAttestations()))
+		require.NoError(t, service.handleBlockAttestations(ctx, wsb.Block(), st)) // fine to use the same committee as st
+		require.Equal(t, 0, service.cfg.AttPool.ForkchoiceAttestationCount())
+		require.NoError(t, service.handleBlockAttestations(ctx, wsb3.Block(), st3)) // fine to use the same committee as st
+		require.Equal(t, 1, len(service.cfg.AttPool.BlockAttestations()))
+	})
+	t.Run("post-Electra", func(t *testing.T) {
+		service, tr := minimalTestService(t)
+		ctx := tr.ctx
+
+		st, keys := util.DeterministicGenesisStateElectra(t, 64)
+		require.NoError(t, service.saveGenesisData(ctx, st))
+
+		genesis, err := blocks.NewGenesisBlockForState(ctx, st)
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, genesis), "Could not save genesis block")
+		parentRoot, err := genesis.Block().HashTreeRoot()
+		require.NoError(t, err, "Could not get signing root")
+		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
+		require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
+
+		st, err = service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 1)
+		require.NoError(t, err)
+		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		preState, err := service.getBlockPreState(ctx, wsb.Block())
+		require.NoError(t, err)
+		postState, err := service.validateStateTransition(ctx, preState, wsb)
+		require.NoError(t, err)
+		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
+
+		st, err = service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err = util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 2)
+		require.NoError(t, err)
+		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		// prepare another block that is not inserted
+		st3, err := transition.ExecuteStateTransition(ctx, st, wsb)
+		require.NoError(t, err)
+		b3, err := util.GenerateFullBlockElectra(st3, keys, util.DefaultBlockGenConfig(), 3)
+		require.NoError(t, err)
+		wsb3, err := consensusblocks.NewSignedBeaconBlock(b3)
+		require.NoError(t, err)
+
+		require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
+		a := wsb.Block().Body().Attestations()[0]
+		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
+		require.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(r))
+
+		require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
+		a3 := wsb3.Block().Body().Attestations()[0]
+		r3 := bytesutil.ToBytes32(a3.GetData().BeaconBlockRoot)
+		require.Equal(t, false, service.cfg.ForkChoiceStore.HasNode(r3))
+
+		require.NoError(t, service.handleBlockAttestations(ctx, wsb.Block(), st)) // fine to use the same committee as st
+		require.Equal(t, 0, service.cfg.AttPool.ForkchoiceAttestationCount())
+		require.NoError(t, service.handleBlockAttestations(ctx, wsb3.Block(), st3)) // fine to use the same committee as st
+		require.Equal(t, 1, len(service.cfg.AttPool.BlockAttestations()))
+	})
 }
 
 func TestFillMissingBlockPayloadId_DiffSlotExitEarly(t *testing.T) {

beacon-chain/blockchain/receive_attestation.go

@@ -31,7 +31,7 @@ type AttestationStateFetcher interface {
 // AttestationReceiver interface defines the methods of chain service receive and processing new attestations.
 type AttestationReceiver interface {
 	AttestationStateFetcher
-	VerifyLmdFfgConsistency(ctx context.Context, att *ethpb.Attestation) error
+	VerifyLmdFfgConsistency(ctx context.Context, att ethpb.Att) error
 	InForkchoice([32]byte) bool
 }
 
@@ -51,13 +51,13 @@ func (s *Service) AttestationTargetState(ctx context.Context, target *ethpb.Chec
 }
 
 // VerifyLmdFfgConsistency verifies that attestation's LMD and FFG votes are consistency to each other.
-func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a *ethpb.Attestation) error {
-	r, err := s.TargetRootForEpoch([32]byte(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a ethpb.Att) error {
+	r, err := s.TargetRootForEpoch([32]byte(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(a.Data.Target.Root, r[:]) {
-		return fmt.Errorf("FFG and LMD votes are not consistent, block root: %#x, target root: %#x, canonical target root: %#x", a.Data.BeaconBlockRoot, a.Data.Target.Root, r)
+	if !bytes.Equal(a.GetData().Target.Root, r[:]) {
+		return fmt.Errorf("FFG and LMD votes are not consistent, block root: %#x, target root: %#x, canonical target root: %#x", a.GetData().BeaconBlockRoot, a.GetData().Target.Root, r)
 	}
 	return nil
 }
@@ -170,13 +170,13 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
 		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
-		nextSlot := a.Data.Slot + 1
+		nextSlot := a.GetData().Slot + 1
 		if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), nextSlot, disparity); err != nil {
 			continue
 		}
 
-		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
+		hasBlock := s.chainHasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
 		if !(hasState && hasBlock) {
 			continue
 		}
@@ -185,17 +185,17 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 			log.WithError(err).Error("Could not delete fork choice attestation in pool")
 		}
 
-		if !helpers.VerifyCheckpointEpoch(a.Data.Target, s.genesisTime) {
+		if !helpers.VerifyCheckpointEpoch(a.GetData().Target, s.genesisTime) {
 			continue
 		}
 
 		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
 			log.WithFields(logrus.Fields{
-				"slot":             a.Data.Slot,
-				"committeeIndex":   a.Data.CommitteeIndex,
-				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.BeaconBlockRoot)),
-				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.Target.Root)),
-				"aggregationCount": a.AggregationBits.Count(),
+				"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")
 		}
 	}
@@ -206,7 +206,7 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 //  1. Validate attestation, update validator's latest vote
 //  2. Apply fork choice to the processed attestation
 //  3. Save latest head info
-func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation, disparity time.Duration) error {
+func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att ethpb.Att, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.receiveAttestationNoPubsub")
 	defer span.End()
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -73,7 +73,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 	atts, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
-	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
+	tRoot := bytesutil.ToBytes32(atts[0].GetData().Target.Root)
 	copied := genesisState.Copy()
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
@@ -83,7 +83,11 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
+	attsToSave := make([]ethpb.Att, len(atts))
+	for i, a := range atts {
+		attsToSave[i] = a
+	}
+	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	service.processAttestations(ctx, 0)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
 	require.LogsDoNotContain(t, hook, "Could not process attestation for fork choice")
@@ -121,10 +125,14 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	// Generate attestations for this block in Slot 1
 	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
+	attsToSave := make([]ethpb.Att, len(atts))
+	for i, a := range atts {
+		attsToSave[i] = a
+	}
+	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	// Verify the target is in forkchoice
-	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].Data.BeaconBlockRoot)))
-	require.Equal(t, tRoot, bytesutil.ToBytes32(atts[0].Data.BeaconBlockRoot))
+	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].GetData().BeaconBlockRoot)))
+	require.Equal(t, tRoot, bytesutil.ToBytes32(atts[0].GetData().BeaconBlockRoot))
 	require.Equal(t, true, fcs.HasNode(service.originBlockRoot))
 
 	// Insert a new block to forkchoice

beacon-chain/blockchain/receive_block.go

@@ -13,6 +13,7 @@ import (
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -52,7 +53,7 @@ type BlobReceiver interface {
 
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
-	ReceiveAttesterSlashing(ctx context.Context, slashings *ethpb.AttesterSlashing)
+	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
 }
 
 // ReceiveBlock is a function that defines the operations (minus pubsub)
@@ -76,59 +77,20 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
-	rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
-	if err != nil {
-		return err
-	}
-
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
 	if err != nil {
 		return errors.Wrap(err, "could not get block's prestate")
 	}
-	// Save current justified and finalized epochs for future use.
-	currStoreJustifiedEpoch := s.CurrentJustifiedCheckpt().Epoch
-	currStoreFinalizedEpoch := s.FinalizedCheckpt().Epoch
-	currentEpoch := coreTime.CurrentEpoch(preState)
 
-	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	currentCheckpoints := s.saveCurrentCheckpoints(preState)
+	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, blockCopy, blockRoot)
 	if err != nil {
 		return err
 	}
-	eg, _ := errgroup.WithContext(ctx)
-	var postState state.BeaconState
-	eg.Go(func() error {
-		var err error
-		postState, err = s.validateStateTransition(ctx, preState, blockCopy)
-		if err != nil {
-			return errors.Wrap(err, "failed to validate consensus state transition function")
-		}
-		return nil
-	})
-	var isValidPayload bool
-	eg.Go(func() error {
-		var err error
-		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, blockCopy, blockRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not notify the engine of the new payload")
-		}
-		return nil
-	})
-	if err := eg.Wait(); err != nil {
+	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
+	if err != nil {
 		return err
 	}
-	daStartTime := time.Now()
-	if avs != nil {
-		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
-			return errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
-		}
-	} else {
-		if err := s.isDataAvailable(ctx, blockRoot, blockCopy); err != nil {
-			return errors.Wrap(err, "could not validate blob data availability")
-		}
-	}
-	daWaitedTime := time.Since(daStartTime)
-	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
-
 	// Defragment the state before continuing block processing.
 	s.defragmentState(postState)
 
@@ -150,34 +112,9 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		tracing.AnnotateError(span, err)
 		return err
 	}
-	if coreTime.CurrentEpoch(postState) > currentEpoch && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
-		headSt, err := s.HeadState(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not get head state")
-		}
-		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
-			log.WithError(err).Error("could not report epoch metrics")
-		}
+	if err := s.updateCheckpoints(ctx, currentCheckpoints, preState, postState, blockRoot); err != nil {
+		return err
 	}
-	if err := s.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch); err != nil {
-		return errors.Wrap(err, "could not update justified checkpoint")
-	}
-
-	newFinalized, err := s.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
-	if err != nil {
-		return errors.Wrap(err, "could not update finalized checkpoint")
-	}
-	// Send finalized events and finalized deposits in the background
-	if newFinalized {
-		finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
-		go s.sendNewFinalizedEvent(blockCopy, postState)
-		depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
-		go func() {
-			s.insertFinalizedDeposits(depCtx, finalized.Root)
-			cancel()
-		}()
-	}
-
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
 	if features.Get().EnableSlasher {
 		go s.sendBlockAttestationsToSlasher(blockCopy, preState)
@@ -197,31 +134,153 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err := s.handleCaches(); err != nil {
 		return err
 	}
+	s.reportPostBlockProcessing(blockCopy, blockRoot, receivedTime, daWaitedTime)
+	return nil
+}
 
+type ffgCheckpoints struct {
+	j, f, c primitives.Epoch
+}
+
+func (s *Service) saveCurrentCheckpoints(state state.BeaconState) (cp ffgCheckpoints) {
+	// Save current justified and finalized epochs for future use.
+	cp.j = s.CurrentJustifiedCheckpt().Epoch
+	cp.f = s.FinalizedCheckpt().Epoch
+	cp.c = coreTime.CurrentEpoch(state)
+	return
+}
+
+func (s *Service) updateCheckpoints(
+	ctx context.Context,
+	cp ffgCheckpoints,
+	preState, postState state.BeaconState,
+	blockRoot [32]byte,
+) error {
+	if coreTime.CurrentEpoch(postState) > cp.c && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
+		headSt, err := s.HeadState(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not get head state")
+		}
+		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
+			log.WithError(err).Error("could not report epoch metrics")
+		}
+	}
+	if err := s.updateJustificationOnBlock(ctx, preState, postState, cp.j); err != nil {
+		return errors.Wrap(err, "could not update justified checkpoint")
+	}
+
+	newFinalized, err := s.updateFinalizationOnBlock(ctx, preState, postState, cp.f)
+	if err != nil {
+		return errors.Wrap(err, "could not update finalized checkpoint")
+	}
+	// Send finalized events and finalized deposits in the background
+	if newFinalized {
+		// hook to process all post state finalization tasks
+		s.executePostFinalizationTasks(ctx, postState)
+	}
+	return nil
+}
+
+func (s *Service) validateExecutionAndConsensus(
+	ctx context.Context,
+	preState state.BeaconState,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
+) (state.BeaconState, bool, error) {
+	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	if err != nil {
+		return nil, false, err
+	}
+	eg, _ := errgroup.WithContext(ctx)
+	var postState state.BeaconState
+	eg.Go(func() error {
+		var err error
+		postState, err = s.validateStateTransition(ctx, preState, block)
+		if err != nil {
+			return errors.Wrap(err, "failed to validate consensus state transition function")
+		}
+		return nil
+	})
+	var isValidPayload bool
+	eg.Go(func() error {
+		var err error
+		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block, blockRoot)
+		if err != nil {
+			return errors.Wrap(err, "could not notify the engine of the new payload")
+		}
+		return nil
+	})
+	if err := eg.Wait(); err != nil {
+		return nil, false, err
+	}
+	return postState, isValidPayload, nil
+}
+
+func (s *Service) handleDA(
+	ctx context.Context,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
+	avs das.AvailabilityStore,
+) (time.Duration, error) {
+	daStartTime := time.Now()
+	if avs != nil {
+		rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
+		if err != nil {
+			return 0, err
+		}
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
+			return 0, errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
+		}
+	} else {
+		if err := s.isDataAvailable(ctx, blockRoot, block); err != nil {
+			return 0, errors.Wrap(err, "could not validate blob data availability")
+		}
+	}
+	daWaitedTime := time.Since(daStartTime)
+	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
+	return daWaitedTime, nil
+}
+
+func (s *Service) reportPostBlockProcessing(
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
+	receivedTime time.Time,
+	daWaitedTime time.Duration,
+) {
 	// Reports on block and fork choice metrics.
 	cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	finalized := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
+	reportSlotMetrics(block.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 
 	// Log block sync status.
 	cp = s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	justified := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix()), daWaitedTime); err != nil {
+	if err := logBlockSyncStatus(block.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix()), daWaitedTime); err != nil {
 		log.WithError(err).Error("Unable to log block sync status")
 	}
 	// Log payload data
-	if err := logPayload(blockCopy.Block()); err != nil {
+	if err := logPayload(block.Block()); err != nil {
 		log.WithError(err).Error("Unable to log debug block payload data")
 	}
 	// Log state transition data.
-	if err := logStateTransitionData(blockCopy.Block()); err != nil {
+	if err := logStateTransitionData(block.Block()); err != nil {
 		log.WithError(err).Error("Unable to log state transition data")
 	}
-
 	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
 	chainServiceProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
+}
 
-	return nil
+func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
+	go func() {
+		finalizedState.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
+		s.sendNewFinalizedEvent(ctx, finalizedState)
+	}()
+	depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
+	go func() {
+		s.insertFinalizedDeposits(depCtx, finalized.Root)
+		cancel()
+	}()
 }
 
 // ReceiveBlockBatch processes the whole block batch at once, assuming the block batch is linear ,transitioning
@@ -295,10 +354,10 @@ func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
 }
 
 // ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
-func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) {
+func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing) {
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	s.InsertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
+	s.InsertSlashingsToForkChoiceStore(ctx, []ethpb.AttSlashing{slashing})
 }
 
 // prunePostBlockOperationPools only runs on new head otherwise should return a nil.
@@ -443,7 +502,7 @@ func (s *Service) updateFinalizationOnBlock(ctx context.Context, preState, postS
 
 // sendNewFinalizedEvent sends a new finalization checkpoint event over the
 // event feed. It needs to be called on the background
-func (s *Service) sendNewFinalizedEvent(signed interfaces.ReadOnlySignedBeaconBlock, postState state.BeaconState) {
+func (s *Service) sendNewFinalizedEvent(ctx context.Context, postState state.BeaconState) {
 	isValidPayload := false
 	s.headLock.RLock()
 	if s.head != nil {
@@ -451,8 +510,17 @@ func (s *Service) sendNewFinalizedEvent(signed interfaces.ReadOnlySignedBeaconBl
 	}
 	s.headLock.RUnlock()
 
+	blk, err := s.cfg.BeaconDB.Block(ctx, bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root))
+	if err != nil {
+		log.WithError(err).Error("Could not retrieve block for finalized checkpoint root. Finalized event will not be emitted")
+		return
+	}
+	if blk == nil || blk.IsNil() || blk.Block() == nil || blk.Block().IsNil() {
+		log.WithError(err).Error("Block retrieved for finalized checkpoint root is nil. Finalized event will not be emitted")
+		return
+	}
+	stateRoot := blk.Block().StateRoot()
 	// Send an event regarding the new finalized checkpoint over a common event feed.
-	stateRoot := signed.Block().StateRoot()
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.FinalizedCheckpoint,
 		Data: &ethpbv1.EventFinalizedCheckpoint{
@@ -470,17 +538,17 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 	// is done in the background to avoid adding more load to this critical code path.
 	ctx := context.TODO()
 	for _, att := range signed.Block().Body().Attestations() {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, preState, att.Data.Slot, att.Data.CommitteeIndex)
+		committees, err := helpers.AttestationCommittees(ctx, preState, att)
 		if err != nil {
-			log.WithError(err).Error("Could not get attestation committee")
+			log.WithError(err).Error("Could not get attestation committees")
 			return
 		}
-		indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
+		indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committees...)
 		if err != nil {
 			log.WithError(err).Error("Could not convert to indexed attestation")
 			return
 		}
-		s.cfg.SlasherAttestationsFeed.Send(indexedAtt)
+		s.cfg.SlasherAttestationsFeed.Send(&types.WrappedIndexedAtt{IndexedAtt: indexedAtt})
 	}
 }
 
@@ -488,7 +556,10 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, signed interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) (bool, error) {
 	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, signed)
 	if err != nil {
-		return false, s.handleInvalidExecutionError(ctx, err, blockRoot, signed.Block().ParentRoot())
+		s.cfg.ForkChoiceStore.Lock()
+		err = s.handleInvalidExecutionError(ctx, err, blockRoot, signed.Block().ParentRoot())
+		s.cfg.ForkChoiceStore.Unlock()
+		return false, err
 	}
 	if signed.Version() < version.Capella && isValidPayload {
 		if err := s.validateMergeTransitionBlock(ctx, ver, header, signed); err != nil {

beacon-chain/blockchain/receive_block_test.go

@@ -6,18 +6,23 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	blockchainTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
+	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/voluntaryexits"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
@@ -378,3 +383,111 @@ func TestHandleBlockBLSToExecutionChanges(t *testing.T) {
 		require.Equal(t, false, pool.ValidatorExists(idx))
 	})
 }
+
+func Test_sendNewFinalizedEvent(t *testing.T) {
+	s, _ := minimalTestService(t)
+	notifier := &blockchainTesting.MockStateNotifier{RecordEvents: true}
+	s.cfg.StateNotifier = notifier
+	finalizedSt, err := util.NewBeaconState()
+	require.NoError(t, err)
+	finalizedStRoot, err := finalizedSt.HashTreeRoot(s.ctx)
+	require.NoError(t, err)
+	b := util.NewBeaconBlock()
+	b.Block.StateRoot = finalizedStRoot[:]
+	sbb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	sbbRoot, err := sbb.Block().HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, s.cfg.BeaconDB.SaveBlock(s.ctx, sbb))
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, st.SetFinalizedCheckpoint(&ethpb.Checkpoint{
+		Epoch: 123,
+		Root:  sbbRoot[:],
+	}))
+
+	s.sendNewFinalizedEvent(s.ctx, st)
+
+	require.Equal(t, 1, len(notifier.ReceivedEvents()))
+	e := notifier.ReceivedEvents()[0]
+	assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
+	fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
+	require.Equal(t, true, ok, "event has wrong data type")
+	assert.Equal(t, primitives.Epoch(123), fc.Epoch)
+	assert.DeepEqual(t, sbbRoot[:], fc.Block)
+	assert.DeepEqual(t, finalizedStRoot[:], fc.State)
+	assert.Equal(t, false, fc.ExecutionOptimistic)
+}
+
+func Test_executePostFinalizationTasks(t *testing.T) {
+	logHook := logTest.NewGlobal()
+
+	headState, err := util.NewBeaconStateElectra()
+	require.NoError(t, err)
+	finalizedStRoot, err := headState.HashTreeRoot(context.Background())
+	require.NoError(t, err)
+
+	genesis := util.NewBeaconBlock()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*122 + 1
+	headBlock := util.NewBeaconBlock()
+	headBlock.Block.Slot = finalizedSlot
+	headBlock.Block.StateRoot = finalizedStRoot[:]
+	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
+	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	hexKey := "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	key, err := hexutil.Decode(hexKey)
+	require.NoError(t, err)
+	require.NoError(t, headState.SetValidators([]*ethpb.Validator{
+		{
+			PublicKey:             key,
+			WithdrawalCredentials: make([]byte, fieldparams.RootLength),
+		},
+	}))
+	require.NoError(t, headState.SetSlot(finalizedSlot))
+	require.NoError(t, headState.SetFinalizedCheckpoint(&ethpb.Checkpoint{
+		Epoch: 123,
+		Root:  headRoot[:],
+	}))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
+
+	s, tr := minimalTestService(t, WithFinalizedStateAtStartUp(headState))
+	ctx, beaconDB, stateGen := tr.ctx, tr.db, tr.sg
+
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, genesis)
+	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+
+	require.NoError(t, err)
+	require.NoError(t, stateGen.SaveState(ctx, headRoot, headState))
+	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+
+	notifier := &blockchainTesting.MockStateNotifier{RecordEvents: true}
+	s.cfg.StateNotifier = notifier
+	s.executePostFinalizationTasks(s.ctx, headState)
+
+	time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+	require.Equal(t, 1, len(notifier.ReceivedEvents()))
+	e := notifier.ReceivedEvents()[0]
+	assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
+	fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
+	require.Equal(t, true, ok, "event has wrong data type")
+	assert.Equal(t, primitives.Epoch(123), fc.Epoch)
+	assert.DeepEqual(t, headRoot[:], fc.Block)
+	assert.DeepEqual(t, finalizedStRoot[:], fc.State)
+	assert.Equal(t, false, fc.ExecutionOptimistic)
+
+	// check the cache
+	index, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(key))
+	require.Equal(t, true, ok)
+	require.Equal(t, primitives.ValidatorIndex(0), index) // first index
+
+	// check deposit
+	require.LogsContain(t, logHook, "Finalized deposit insertion completed at index")
+}

beacon-chain/blockchain/receive_execution_payload_envelope.go

@@ -0,0 +1,166 @@
+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, err := envelope.BeaconBlockRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not get beacon block root")
+	}
+	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")
+	}
+
+	var lastValidHash []byte
+	var versionedHashes []common.Hash
+	versionedHashes, err = envelope.VersionedHashes()
+	if err != nil {
+		return false, errors.Wrap(err, "could not get versioned hashes to feed the engine")
+	}
+	root, err := envelope.BeaconBlockRoot()
+	if err != nil {
+		return false, errors.Wrap(err, "could not get beacon block root")
+	}
+	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, rootErr := e.BeaconBlockRoot()
+	if rootErr != nil {
+		return false, errors.Wrap(rootErr, "could not get beacon block root")
+	}
+	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, err := e.BeaconBlockRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get beacon block root")
+	}
+	// 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,104 @@
+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/epbs"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+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 := &enginev1.ExecutionPayloadEnvelope{
+		Payload:         &enginev1.ExecutionPayloadElectra{},
+		BeaconBlockRoot: service.originBlockRoot[:],
+	}
+	e, err := epbs.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 := &enginev1.ExecutionPayloadEnvelope{
+		Payload:         &enginev1.ExecutionPayloadElectra{},
+		BeaconBlockRoot: service.originBlockRoot[:],
+	}
+	e, err := epbs.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 := &enginev1.ExecutionPayloadEnvelope{
+		Payload:         &enginev1.ExecutionPayloadElectra{},
+		BeaconBlockRoot: service.originBlockRoot[:],
+	}
+	e, err := epbs.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 := epbs.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

@@ -11,8 +11,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
@@ -44,6 +42,7 @@ import (
 	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
@@ -66,6 +65,7 @@ type Service struct {
 	syncComplete                  chan struct{}
 	blobNotifiers                 *blobNotifierMap
 	blockBeingSynced              *currentlySyncingBlock
+	payloadBeingSynced            *currentlySyncingPayload
 	blobStorage                   *filesystem.BlobStorage
 	lastPublishedLightClientEpoch primitives.Epoch
 }
@@ -76,6 +76,7 @@ type config struct {
 	ChainStartFetcher       execution.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
 	DepositCache            cache.DepositCache
+	PayloadAttestationCache *cache.PayloadAttestationCache
 	PayloadIDCache          *cache.PayloadIDCache
 	TrackedValidatorsCache  *cache.TrackedValidatorsCache
 	AttPool                 attestations.Pool
@@ -180,6 +181,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 {
@@ -330,6 +332,8 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
+	saved.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
+
 	return nil
 }
 
@@ -504,7 +508,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	}
 	genesisBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
 	if err != nil || genesisBlk == nil || genesisBlk.IsNil() {
-		return fmt.Errorf("could not load genesis block: %v", err)
+		return fmt.Errorf("could not load genesis block: %w", err)
 	}
 	genesisBlkRoot, err := genesisBlk.Block().HashTreeRoot()
 	if err != nil {
@@ -543,7 +547,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

@@ -8,9 +8,10 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositcache"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositsnapshot"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
@@ -29,6 +30,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -80,7 +82,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	attService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
 	require.NoError(t, err)
 
-	depositCache, err := depositcache.New()
+	depositCache, err := depositsnapshot.New()
 	require.NoError(t, err)
 
 	fc := doublylinkedtree.New()
@@ -203,7 +205,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 		BlockHash:    make([]byte, 32),
 	})
 	require.NoError(t, err)
-	genState, err = blocks.ProcessPreGenesisDeposits(ctx, genState, deposits)
+	genState, err = altair.ProcessPreGenesisDeposits(ctx, genState, deposits)
 	require.NoError(t, err)
 
 	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)})
@@ -380,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) {
@@ -499,6 +501,65 @@ func TestChainService_EverythingOptimistic(t *testing.T) {
 	require.Equal(t, true, op)
 }
 
+func TestStartFromSavedState_ValidatorIndexCacheUpdated(t *testing.T) {
+	resetFn := features.InitWithReset(&features.Flags{
+		EnableStartOptimistic: true,
+	})
+	defer resetFn()
+
+	genesis := util.NewBeaconBlockElectra()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
+	headBlock := util.NewBeaconBlockElectra()
+	headBlock.Block.Slot = finalizedSlot
+	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	hexKey := "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	key, err := hexutil.Decode(hexKey)
+	require.NoError(t, err)
+	hexKey2 := "0x42247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	key2, err := hexutil.Decode(hexKey2)
+	require.NoError(t, err)
+	require.NoError(t, headState.SetValidators([]*ethpb.Validator{
+		{
+			PublicKey:             key,
+			WithdrawalCredentials: make([]byte, fieldparams.RootLength),
+		},
+		{
+			PublicKey:             key2,
+			WithdrawalCredentials: make([]byte, fieldparams.RootLength),
+		},
+	}))
+	require.NoError(t, headState.SetSlot(finalizedSlot))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
+	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	c, tr := minimalTestService(t, WithFinalizedStateAtStartUp(headState))
+	ctx, beaconDB, stateGen := tr.ctx, tr.db, tr.sg
+
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, genesis)
+	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+
+	require.NoError(t, err)
+	require.NoError(t, stateGen.SaveState(ctx, headRoot, headState))
+	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+	require.NoError(t, c.StartFromSavedState(headState))
+
+	index, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(key))
+	require.Equal(t, true, ok)
+	require.Equal(t, primitives.ValidatorIndex(0), index) // first index
+	index2, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(key2))
+	require.Equal(t, true, ok)
+	require.Equal(t, primitives.ValidatorIndex(1), index2) // first index
+}
+
 // MockClockSetter satisfies the ClockSetter interface for testing the conditions where blockchain.Service should
 // call SetGenesis.
 type MockClockSetter struct {

beacon-chain/blockchain/setup_test.go

@@ -8,11 +8,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositcache"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositsnapshot"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	testDB "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
+	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
@@ -49,7 +50,7 @@ func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ *ethpb.Attestation) error {
+func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ ethpb.Att) error {
 	mb.broadcastCalled = true
 	return nil
 }
@@ -79,7 +80,7 @@ type testServiceRequirements struct {
 	attPool attestations.Pool
 	attSrv  *attestations.Service
 	blsPool *blstoexec.Pool
-	dc      *depositcache.DepositCache
+	dc      *depositsnapshot.Cache
 }
 
 func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceRequirements) {
@@ -94,7 +95,7 @@ func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceReq
 	attSrv, err := attestations.NewService(ctx, &attestations.Config{Pool: attPool})
 	require.NoError(t, err)
 	blsPool := blstoexec.NewPool()
-	dc, err := depositcache.New()
+	dc, err := depositsnapshot.New()
 	require.NoError(t, err)
 	req := &testServiceRequirements{
 		ctx:     ctx,
@@ -120,6 +121,7 @@ func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceReq
 		WithTrackedValidatorsCache(cache.NewTrackedValidatorsCache()),
 		WithBlobStorage(filesystem.NewEphemeralBlobStorage(t)),
 		WithSyncChecker(mock.MockChecker{}),
+		WithExecutionEngineCaller(&mockExecution.EngineClient{}),
 	}
 	// append the variadic opts so they override the defaults by being processed afterwards
 	opts = append(defOpts, opts...)

beacon-chain/blockchain/testing/mock.go

@@ -414,8 +414,8 @@ func (*ChainService) HeadGenesisValidatorsRoot() [32]byte {
 }
 
 // VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
-func (*ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
-	if !bytes.Equal(a.Data.BeaconBlockRoot, a.Data.Target.Root) {
+func (*ChainService) VerifyLmdFfgConsistency(_ context.Context, a ethpb.Att) error {
+	if !bytes.Equal(a.GetData().BeaconBlockRoot, a.GetData().Target.Root) {
 		return errors.New("LMD and FFG miss matched")
 	}
 	return nil
@@ -495,7 +495,7 @@ func (s *ChainService) UpdateHead(ctx context.Context, slot primitives.Slot) {
 }
 
 // ReceiveAttesterSlashing mocks the same method in the chain service.
-func (*ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterSlashing) {}
+func (*ChainService) ReceiveAttesterSlashing(context.Context, ethpb.AttSlashing) {}
 
 // IsFinalized mocks the same method in the chain service.
 func (s *ChainService) IsFinalized(_ context.Context, blockRoot [32]byte) bool {

beacon-chain/builder/testing/mock.go

@@ -2,7 +2,6 @@ package testing
 
 import (
 	"context"
-	"math/big"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/client/builder"
@@ -55,13 +54,13 @@ func (s *MockBuilderService) SubmitBlindedBlock(_ context.Context, b interfaces.
 		}
 		return w, nil, s.ErrSubmitBlindedBlock
 	case version.Capella:
-		w, err := blocks.WrappedExecutionPayloadCapella(s.PayloadCapella, big.NewInt(0))
+		w, err := blocks.WrappedExecutionPayloadCapella(s.PayloadCapella)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not wrap capella payload")
 		}
 		return w, nil, s.ErrSubmitBlindedBlock
 	case version.Deneb:
-		w, err := blocks.WrappedExecutionPayloadDeneb(s.PayloadDeneb, big.NewInt(0))
+		w, err := blocks.WrappedExecutionPayloadDeneb(s.PayloadDeneb)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not wrap deneb payload")
 		}

beacon-chain/cache/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "active_balance.go",
         "active_balance_disabled.go",  # keep
         "attestation_data.go",
+        "balance_cache_key.go",
         "checkpoint_state.go",
         "committee.go",
         "committee_disabled.go",  # keep
@@ -14,6 +15,7 @@ go_library(
         "doc.go",
         "error.go",
         "interfaces.go",
+        "payload_attestation.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep
@@ -41,6 +43,7 @@ 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",
@@ -69,7 +72,9 @@ 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",
         "skip_slot_cache_test.go",
@@ -86,6 +91,7 @@ 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",
@@ -93,6 +99,7 @@ go_test(
         "//testing/util: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",
         "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],

beacon-chain/cache/active_balance.go

@@ -3,17 +3,13 @@
 package cache
 
 import (
-	"encoding/binary"
 	"sync"
 
 	lru "github.com/hashicorp/golang-lru"
-	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 const (
@@ -86,36 +82,3 @@ func (c *BalanceCache) Get(st state.ReadOnlyBeaconState) (uint64, error) {
 	balanceCacheHit.Inc()
 	return value.(uint64), nil
 }
-
-// Given input state `st`, balance key is constructed as:
-// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
-func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
-	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
-	if err != nil {
-		// impossible condition due to early division
-		return "", errors.Errorf("start slot calculation overflows: %v", err)
-	}
-	prevSlot := primitives.Slot(0)
-	if epochStartSlot > 1 {
-		prevSlot = epochStartSlot - 1
-	}
-	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
-	if err != nil {
-		// impossible condition because index is always constrained within state
-		return "", err
-	}
-
-	// Mix in current epoch
-	b := make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
-	key := append(r, b...)
-
-	// Mix in validator count
-	b = make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
-	key = append(key, b...)
-
-	return string(key), nil
-}

beacon-chain/cache/active_balance_test.go

@@ -1,12 +1,13 @@
 //go:build !fuzz
 
-package cache
+package cache_test
 
 import (
 	"encoding/binary"
 	"math"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -27,33 +28,33 @@ func TestBalanceCache_AddGetBalance(t *testing.T) {
 	st, err := state_native.InitializeFromProtoPhase0(raw)
 	require.NoError(t, err)
 
-	cache := NewEffectiveBalanceCache()
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
+	cc := cache.NewEffectiveBalanceCache()
+	_, err = cc.Get(st)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 
 	b := uint64(100)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err := cache.Get(st)
+	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
+	cachedB, err := cc.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 
 	require.NoError(t, st.SetSlot(1000))
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
+	_, err = cc.Get(st)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 
 	b = uint64(200)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cache.Get(st)
+	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
+	cachedB, err = cc.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 
 	require.NoError(t, st.SetSlot(1000+params.BeaconConfig().SlotsPerHistoricalRoot))
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
+	_, err = cc.Get(st)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 
 	b = uint64(300)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cache.Get(st)
+	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
+	cachedB, err = cc.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 }
@@ -72,6 +73,6 @@ func TestBalanceCache_BalanceKey(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(primitives.Slot(math.MaxUint64)))
 
-	_, err = balanceCacheKey(st)
+	_, err = cache.BalanceCacheKey(st)
 	require.NoError(t, err)
 }

beacon-chain/cache/balance_cache_key.go

@@ -0,0 +1,43 @@
+package cache
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+// Given input state `st`, balance key is constructed as:
+// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
+func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
+	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
+	if err != nil {
+		// impossible condition due to early division
+		return "", fmt.Errorf("start slot calculation overflows: %w", err)
+	}
+	prevSlot := primitives.Slot(0)
+	if epochStartSlot > 1 {
+		prevSlot = epochStartSlot - 1
+	}
+	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
+	if err != nil {
+		// impossible condition because index is always constrained within state
+		return "", err
+	}
+
+	// Mix in current epoch
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
+	key := append(r, b...)
+
+	// Mix in validator count
+	b = make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
+	key = append(key, b...)
+
+	return string(key), nil
+}

beacon-chain/cache/checkpoint_state_test.go

@@ -1,8 +1,9 @@
-package cache
+package cache_test
 
 import (
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -15,7 +16,7 @@ import (
 )
 
 func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
-	cache := NewCheckpointStateCache()
+	cache := cache.NewCheckpointStateCache()
 
 	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
 	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
@@ -58,16 +59,16 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 }
 
 func TestCheckpointStateCache_MaxSize(t *testing.T) {
-	c := NewCheckpointStateCache()
+	c := cache.NewCheckpointStateCache()
 	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
 		Slot: 0,
 	})
 	require.NoError(t, err)
 
-	for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
+	for i := uint64(0); i < uint64(cache.MaxCheckpointStateSize()+100); i++ {
 		require.NoError(t, st.SetSlot(primitives.Slot(i)))
 		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: primitives.Epoch(i), Root: make([]byte, 32)}, st))
 	}
 
-	assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))
+	assert.Equal(t, cache.MaxCheckpointStateSize(), len(c.Cache().Keys()))
 }

beacon-chain/cache/depositcache/BUILD.bazel

@@ -1,50 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "deposits_cache.go",
-        "log.go",
-        "pending_deposits.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositcache",
-    visibility = [
-        "//beacon-chain:__subpackages__",
-        "//testing/spectest:__subpackages__",
-    ],
-    deps = [
-        "//beacon-chain/cache:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//container/trie:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "deposits_cache_test.go",
-        "pending_deposits_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/cache:go_default_library",
-        "//config/params:go_default_library",
-        "//container/trie:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)

beacon-chain/cache/depositcache/deposits_cache.go

@@ -1,327 +0,0 @@
-// Package depositcache is the source of validator deposits maintained
-// in-memory by the beacon node – deposits processed from the
-// eth1 powchain are then stored in this cache to be accessed by
-// any other service during a beacon node's runtime.
-package depositcache
-
-import (
-	"context"
-	"encoding/hex"
-	"math/big"
-	"sort"
-	"sync"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/container/trie"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-var (
-	historicalDepositsCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "beacondb_all_deposits",
-		Help: "The number of total deposits in the beaconDB in-memory database",
-	})
-)
-
-// FinalizedDeposits stores the trie of deposits that have been included
-// in the beacon state up to the latest finalized checkpoint.
-type FinalizedDeposits struct {
-	deposits        *trie.SparseMerkleTrie
-	merkleTrieIndex int64
-}
-
-// DepositCache stores all in-memory deposit objects. This
-// stores all the deposit related data that is required by the beacon-node.
-type DepositCache struct {
-	// Beacon chain deposits in memory.
-	pendingDeposits   []*ethpb.DepositContainer
-	deposits          []*ethpb.DepositContainer
-	finalizedDeposits FinalizedDeposits
-	depositsByKey     map[[fieldparams.BLSPubkeyLength]byte][]*ethpb.DepositContainer
-	depositsLock      sync.RWMutex
-}
-
-// New instantiates a new deposit cache
-func New() (*DepositCache, error) {
-	finalizedDepositsTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
-	if err != nil {
-		return nil, err
-	}
-
-	// finalizedDeposits.merkleTrieIndex is initialized to -1 because it represents the index of the last trie item.
-	// Inserting the first item into the trie will set the value of the index to 0.
-	return &DepositCache{
-		pendingDeposits:   []*ethpb.DepositContainer{},
-		deposits:          []*ethpb.DepositContainer{},
-		depositsByKey:     map[[fieldparams.BLSPubkeyLength]byte][]*ethpb.DepositContainer{},
-		finalizedDeposits: FinalizedDeposits{deposits: finalizedDepositsTrie, merkleTrieIndex: -1},
-	}, nil
-}
-
-// InsertDeposit into the database. If deposit or block number are nil
-// then this method does nothing.
-func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertDeposit")
-	defer span.End()
-	if d == nil {
-		log.WithFields(logrus.Fields{
-			"block":       blockNum,
-			"deposit":     d,
-			"index":       index,
-			"depositRoot": hex.EncodeToString(depositRoot[:]),
-		}).Warn("Ignoring nil deposit insertion")
-		return errors.New("nil deposit inserted into the cache")
-	}
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-
-	if int(index) != len(dc.deposits) {
-		return errors.Errorf("wanted deposit with index %d to be inserted but received %d", len(dc.deposits), index)
-	}
-	// Keep the slice sorted on insertion in order to avoid costly sorting on retrieval.
-	heightIdx := sort.Search(len(dc.deposits), func(i int) bool { return dc.deposits[i].Index >= index })
-	depCtr := &ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}
-	newDeposits := append(
-		[]*ethpb.DepositContainer{depCtr},
-		dc.deposits[heightIdx:]...)
-	dc.deposits = append(dc.deposits[:heightIdx], newDeposits...)
-	// Append the deposit to our map, in the event no deposits
-	// exist for the pubkey , it is simply added to the map.
-	pubkey := bytesutil.ToBytes48(d.Data.PublicKey)
-	dc.depositsByKey[pubkey] = append(dc.depositsByKey[pubkey], depCtr)
-	historicalDepositsCount.Inc()
-	return nil
-}
-
-// InsertDepositContainers inserts a set of deposit containers into our deposit cache.
-func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*ethpb.DepositContainer) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertDepositContainers")
-	defer span.End()
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-
-	sort.SliceStable(ctrs, func(i int, j int) bool { return ctrs[i].Index < ctrs[j].Index })
-	dc.deposits = ctrs
-	for _, c := range ctrs {
-		// Use a new value, as the reference
-		// of c changes in the next iteration.
-		newPtr := c
-		pKey := bytesutil.ToBytes48(newPtr.Deposit.Data.PublicKey)
-		dc.depositsByKey[pKey] = append(dc.depositsByKey[pKey], newPtr)
-	}
-	historicalDepositsCount.Add(float64(len(ctrs)))
-}
-
-// InsertFinalizedDeposits inserts deposits up to eth1DepositIndex (inclusive) into the finalized deposits cache.
-func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context,
-	eth1DepositIndex int64, _ common.Hash, _ uint64) error {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertFinalizedDeposits")
-	defer span.End()
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-
-	depositTrie := dc.finalizedDeposits.Deposits()
-	insertIndex := int(dc.finalizedDeposits.merkleTrieIndex + 1)
-
-	// Don't insert into finalized trie if there is no deposit to
-	// insert.
-	if len(dc.deposits) == 0 {
-		return nil
-	}
-	// In the event we have less deposits than we need to
-	// finalize we finalize till the index on which we do have it.
-	if len(dc.deposits) <= int(eth1DepositIndex) {
-		eth1DepositIndex = int64(len(dc.deposits)) - 1
-	}
-	// If we finalize to some lower deposit index, we
-	// ignore it.
-	if int(eth1DepositIndex) < insertIndex {
-		return nil
-	}
-	for _, d := range dc.deposits {
-		if d.Index <= dc.finalizedDeposits.merkleTrieIndex {
-			continue
-		}
-		if d.Index > eth1DepositIndex {
-			break
-		}
-		depHash, err := d.Deposit.Data.HashTreeRoot()
-		if err != nil {
-			return errors.Wrap(err, "could not hash deposit data")
-		}
-		if err = depositTrie.Insert(depHash[:], insertIndex); err != nil {
-			return errors.Wrap(err, "could not insert deposit hash")
-		}
-		insertIndex++
-	}
-	tree, ok := depositTrie.(*trie.SparseMerkleTrie)
-	if !ok {
-		return errors.New("not a sparse merkle tree")
-	}
-	dc.finalizedDeposits = FinalizedDeposits{
-		deposits:        tree,
-		merkleTrieIndex: eth1DepositIndex,
-	}
-	return nil
-}
-
-// AllDepositContainers returns all historical deposit containers.
-func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer {
-	_, span := trace.StartSpan(ctx, "DepositsCache.AllDepositContainers")
-	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-
-	// Make a shallow copy of the deposits and return that. This way, the
-	// caller can safely iterate over the returned list of deposits without
-	// the possibility of new deposits showing up. If we were to return the
-	// list without a copy, when a new deposit is added to the cache, it
-	// would also be present in the returned value. This could result in a
-	// race condition if the list is being iterated over.
-	//
-	// It's not necessary to make a deep copy of this list because the
-	// deposits in the cache should never be modified. It is still possible
-	// for the caller to modify one of the underlying deposits and modify
-	// the cache, but that's not a race condition. Also, a deep copy would
-	// take too long and use too much memory.
-	deposits := make([]*ethpb.DepositContainer, len(dc.deposits))
-	copy(deposits, dc.deposits)
-	return deposits
-}
-
-// AllDeposits returns a list of historical deposits until the given block number
-// (inclusive). If no block is specified then this method returns all historical deposits.
-func (dc *DepositCache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-
-	return dc.allDeposits(untilBlk)
-}
-
-func (dc *DepositCache) allDeposits(untilBlk *big.Int) []*ethpb.Deposit {
-	var deposits []*ethpb.Deposit
-	for _, ctnr := range dc.deposits {
-		if untilBlk == nil || untilBlk.Uint64() >= ctnr.Eth1BlockHeight {
-			deposits = append(deposits, ctnr.Deposit)
-		}
-	}
-	return deposits
-}
-
-// DepositsNumberAndRootAtHeight returns number of deposits made up to blockheight and the
-// root that corresponds to the latest deposit at that blockheight.
-func (dc *DepositCache) DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.DepositsNumberAndRootAtHeight")
-	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-	heightIdx := sort.Search(len(dc.deposits), func(i int) bool { return dc.deposits[i].Eth1BlockHeight > blockHeight.Uint64() })
-	// send the deposit root of the empty trie, if eth1follow distance is greater than the time of the earliest
-	// deposit.
-	if heightIdx == 0 {
-		return 0, [32]byte{}
-	}
-	return uint64(heightIdx), bytesutil.ToBytes32(dc.deposits[heightIdx-1].DepositRoot)
-}
-
-// DepositByPubkey looks through historical deposits and finds one which contains
-// a certain public key within its deposit data.
-func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.DepositByPubkey")
-	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-
-	var deposit *ethpb.Deposit
-	var blockNum *big.Int
-	deps, ok := dc.depositsByKey[bytesutil.ToBytes48(pubKey)]
-	if !ok || len(deps) == 0 {
-		return deposit, blockNum
-	}
-	// We always return the first deposit if a particular
-	// validator key has multiple deposits assigned to
-	// it.
-	deposit = deps[0].Deposit
-	blockNum = big.NewInt(int64(deps[0].Eth1BlockHeight))
-	return deposit, blockNum
-}
-
-// FinalizedDeposits returns the finalized deposits trie.
-func (dc *DepositCache) FinalizedDeposits(ctx context.Context) (cache.FinalizedDeposits, error) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.FinalizedDeposits")
-	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-
-	return &FinalizedDeposits{
-		deposits:        dc.finalizedDeposits.deposits.Copy(),
-		merkleTrieIndex: dc.finalizedDeposits.merkleTrieIndex,
-	}, nil
-}
-
-// NonFinalizedDeposits returns the list of non-finalized deposits until the given block number (inclusive).
-// If no block is specified then this method returns all non-finalized deposits.
-func (dc *DepositCache) NonFinalizedDeposits(ctx context.Context, lastFinalizedIndex int64, untilBlk *big.Int) []*ethpb.Deposit {
-	_, span := trace.StartSpan(ctx, "DepositsCache.NonFinalizedDeposits")
-	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-
-	if dc.finalizedDeposits.Deposits() == nil {
-		return dc.allDeposits(untilBlk)
-	}
-
-	var deposits []*ethpb.Deposit
-	for _, d := range dc.deposits {
-		if (d.Index > lastFinalizedIndex) && (untilBlk == nil || untilBlk.Uint64() >= d.Eth1BlockHeight) {
-			deposits = append(deposits, d.Deposit)
-		}
-	}
-
-	return deposits
-}
-
-// PruneProofs removes proofs from all deposits whose index is equal or less than untilDepositIndex.
-func (dc *DepositCache) PruneProofs(ctx context.Context, untilDepositIndex int64) error {
-	_, span := trace.StartSpan(ctx, "DepositsCache.PruneProofs")
-	defer span.End()
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-
-	if untilDepositIndex >= int64(len(dc.deposits)) {
-		untilDepositIndex = int64(len(dc.deposits) - 1)
-	}
-
-	for i := untilDepositIndex; i >= 0; i-- {
-		// Finding a nil proof means that all proofs up to this deposit have been already pruned.
-		if dc.deposits[i].Deposit.Proof == nil {
-			break
-		}
-		dc.deposits[i].Deposit.Proof = nil
-	}
-
-	return nil
-}
-
-// Deposits returns the cached internal deposit tree.
-func (fd *FinalizedDeposits) Deposits() cache.MerkleTree {
-	if fd.deposits != nil {
-		return fd.deposits
-	}
-	return nil
-}
-
-// MerkleTrieIndex represents the last finalized index in
-// the finalized deposit container.
-func (fd *FinalizedDeposits) MerkleTrieIndex() int64 {
-	return fd.merkleTrieIndex
-}

beacon-chain/cache/depositcache/log.go

@@ -1,5 +0,0 @@
-package depositcache
-
-import "github.com/sirupsen/logrus"
-
-var log = logrus.WithField("prefix", "depositcache")

beacon-chain/cache/depositcache/pending_deposits.go

@@ -1,151 +0,0 @@
-package depositcache
-
-import (
-	"context"
-	"math/big"
-	"sort"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-var (
-	pendingDepositsCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacondb_pending_deposits",
-		Help: "The number of pending deposits in the beaconDB in-memory database",
-	})
-)
-
-// PendingDepositsFetcher specifically outlines a struct that can retrieve deposits
-// which have not yet been included in the chain.
-type PendingDepositsFetcher interface {
-	PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer
-}
-
-// InsertPendingDeposit into the database. If deposit or block number are nil
-// then this method does nothing.
-func (dc *DepositCache) InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertPendingDeposit")
-	defer span.End()
-	if d == nil {
-		log.WithFields(logrus.Fields{
-			"block":   blockNum,
-			"deposit": d,
-		}).Debug("Ignoring nil deposit insertion")
-		return
-	}
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-	dc.pendingDeposits = append(dc.pendingDeposits,
-		&ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, Index: index, DepositRoot: depositRoot[:]})
-	pendingDepositsCount.Inc()
-	span.AddAttributes(trace.Int64Attribute("count", int64(len(dc.pendingDeposits))))
-}
-
-// PendingDeposits returns a list of deposits until the given block number
-// (inclusive). If no block is specified then this method returns all pending
-// deposits.
-func (dc *DepositCache) PendingDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
-	defer span.End()
-
-	depositCntrs := dc.PendingContainers(ctx, untilBlk)
-
-	deposits := make([]*ethpb.Deposit, 0, len(depositCntrs))
-	for _, dep := range depositCntrs {
-		deposits = append(deposits, dep.Deposit)
-	}
-
-	return deposits
-}
-
-// PendingContainers returns a list of deposit containers until the given block number
-// (inclusive).
-func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer {
-	_, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
-	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
-
-	depositCntrs := make([]*ethpb.DepositContainer, 0, len(dc.pendingDeposits))
-	for _, ctnr := range dc.pendingDeposits {
-		if untilBlk == nil || untilBlk.Uint64() >= ctnr.Eth1BlockHeight {
-			depositCntrs = append(depositCntrs, ctnr)
-		}
-	}
-	// Sort the deposits by Merkle index.
-	sort.SliceStable(depositCntrs, func(i, j int) bool {
-		return depositCntrs[i].Index < depositCntrs[j].Index
-	})
-
-	span.AddAttributes(trace.Int64Attribute("count", int64(len(depositCntrs))))
-
-	return depositCntrs
-}
-
-// RemovePendingDeposit from the database. The deposit is indexed by the
-// Index. This method does nothing if deposit ptr is nil.
-func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Deposit) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.RemovePendingDeposit")
-	defer span.End()
-
-	if d == nil {
-		log.Debug("Ignoring nil deposit removal")
-		return
-	}
-
-	depRoot, err := hash.Proto(d)
-	if err != nil {
-		log.WithError(err).Error("Could not remove deposit")
-		return
-	}
-
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-
-	idx := -1
-	for i, ctnr := range dc.pendingDeposits {
-		h, err := hash.Proto(ctnr.Deposit)
-		if err != nil {
-			log.WithError(err).Error("Could not hash deposit")
-			continue
-		}
-		if h == depRoot {
-			idx = i
-			break
-		}
-	}
-
-	if idx >= 0 {
-		dc.pendingDeposits = append(dc.pendingDeposits[:idx], dc.pendingDeposits[idx+1:]...)
-		pendingDepositsCount.Dec()
-	}
-}
-
-// PrunePendingDeposits removes any deposit which is older than the given deposit merkle tree index.
-func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.PrunePendingDeposits")
-	defer span.End()
-
-	if merkleTreeIndex == 0 {
-		log.Debug("Ignoring 0 deposit removal")
-		return
-	}
-
-	dc.depositsLock.Lock()
-	defer dc.depositsLock.Unlock()
-
-	cleanDeposits := make([]*ethpb.DepositContainer, 0, len(dc.pendingDeposits))
-	for _, dp := range dc.pendingDeposits {
-		if dp.Index >= merkleTreeIndex {
-			cleanDeposits = append(cleanDeposits, dp)
-		}
-	}
-
-	dc.pendingDeposits = cleanDeposits
-	pendingDepositsCount.Set(float64(len(dc.pendingDeposits)))
-}

beacon-chain/cache/depositsnapshot/BUILD.bazel

@@ -34,6 +34,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "deposit_cache_test.go",
+        "deposit_fetcher_test.go",
         "deposit_tree_snapshot_test.go",
         "merkle_tree_test.go",
         "spec_test.go",

beacon-chain/cache/depositsnapshot/deposit_fetcher.go

@@ -262,6 +262,12 @@ func toFinalizedDepositsContainer(deposits *DepositTree, index int64) finalizedD
 	}
 }
 
+// PendingDepositsFetcher specifically outlines a struct that can retrieve deposits
+// which have not yet been included in the chain.
+type PendingDepositsFetcher interface {
+	PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer
+}
+
 // PendingDeposits returns a list of deposits until the given block number
 // (inclusive). If no block is specified then this method returns all pending
 // deposits.

beacon-chain/cache/depositsnapshot/deposit_fetcher_test.go

@@ -1,82 +1,32 @@
-package depositcache
+package depositsnapshot
 
 import (
 	"context"
 	"math/big"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"google.golang.org/protobuf/proto"
 )
 
-var _ PendingDepositsFetcher = (*DepositCache)(nil)
+var _ PendingDepositsFetcher = (*Cache)(nil)
 
 func TestInsertPendingDeposit_OK(t *testing.T) {
-	dc := DepositCache{}
+	dc := Cache{}
 	dc.InsertPendingDeposit(context.Background(), &ethpb.Deposit{}, 111, 100, [32]byte{})
 
 	assert.Equal(t, 1, len(dc.pendingDeposits), "deposit not inserted")
 }
 
 func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
-	dc := DepositCache{}
+	dc := Cache{}
 	dc.InsertPendingDeposit(context.Background(), nil /*deposit*/, 0 /*blockNum*/, 0, [32]byte{})
 
 	assert.Equal(t, 0, len(dc.pendingDeposits))
 }
 
-func TestRemovePendingDeposit_OK(t *testing.T) {
-	db := DepositCache{}
-	proof1 := makeDepositProof()
-	proof1[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	proof2 := makeDepositProof()
-	proof2[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	data := &ethpb.Deposit_Data{
-		PublicKey:             make([]byte, 48),
-		WithdrawalCredentials: make([]byte, 32),
-		Amount:                0,
-		Signature:             make([]byte, 96),
-	}
-	depToRemove := &ethpb.Deposit{Proof: proof1, Data: data}
-	otherDep := &ethpb.Deposit{Proof: proof2, Data: data}
-	db.pendingDeposits = []*ethpb.DepositContainer{
-		{Deposit: depToRemove, Index: 1},
-		{Deposit: otherDep, Index: 5},
-	}
-	db.RemovePendingDeposit(context.Background(), depToRemove)
-
-	if len(db.pendingDeposits) != 1 || !proto.Equal(db.pendingDeposits[0].Deposit, otherDep) {
-		t.Error("Failed to remove deposit")
-	}
-}
-
-func TestRemovePendingDeposit_IgnoresNilDeposit(t *testing.T) {
-	dc := DepositCache{}
-	dc.pendingDeposits = []*ethpb.DepositContainer{{Deposit: &ethpb.Deposit{}}}
-	dc.RemovePendingDeposit(context.Background(), nil /*deposit*/)
-	assert.Equal(t, 1, len(dc.pendingDeposits), "deposit unexpectedly removed")
-}
-
-func TestPendingDeposit_RoundTrip(t *testing.T) {
-	dc := DepositCache{}
-	proof := makeDepositProof()
-	proof[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	data := &ethpb.Deposit_Data{
-		PublicKey:             make([]byte, 48),
-		WithdrawalCredentials: make([]byte, 32),
-		Amount:                0,
-		Signature:             make([]byte, 96),
-	}
-	dep := &ethpb.Deposit{Proof: proof, Data: data}
-	dc.InsertPendingDeposit(context.Background(), dep, 111, 100, [32]byte{})
-	dc.RemovePendingDeposit(context.Background(), dep)
-	assert.Equal(t, 0, len(dc.pendingDeposits), "Failed to insert & delete a pending deposit")
-}
-
 func TestPendingDeposits_OK(t *testing.T) {
-	dc := DepositCache{}
+	dc := Cache{}
 
 	dc.pendingDeposits = []*ethpb.DepositContainer{
 		{Eth1BlockHeight: 2, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("A")}}},
@@ -96,7 +46,7 @@ func TestPendingDeposits_OK(t *testing.T) {
 }
 
 func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
-	dc := DepositCache{}
+	dc := Cache{}
 
 	dc.pendingDeposits = []*ethpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
@@ -120,7 +70,7 @@ func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
 }
 
 func TestPrunePendingDeposits_OK(t *testing.T) {
-	dc := DepositCache{}
+	dc := Cache{}
 
 	dc.pendingDeposits = []*ethpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},

beacon-chain/cache/depositsnapshot/deposit_tree.go

@@ -99,11 +99,23 @@ func (d *DepositTree) getProof(index uint64) ([32]byte, [][32]byte, error) {
 	if d.depositCount <= 0 {
 		return [32]byte{}, nil, ErrInvalidDepositCount
 	}
-	finalizedDeposits, _ := d.tree.GetFinalized([][32]byte{})
-	if finalizedDeposits != 0 {
-		finalizedDeposits = finalizedDeposits - 1
+	if index >= d.depositCount {
+		return [32]byte{}, nil, ErrInvalidIndex
 	}
-	if index <= finalizedDeposits {
+	finalizedDeposits, _ := d.tree.GetFinalized([][32]byte{})
+	finalizedIdx := -1
+	if finalizedDeposits != 0 {
+		fd, err := math.Int(finalizedDeposits)
+		if err != nil {
+			return [32]byte{}, nil, err
+		}
+		finalizedIdx = fd - 1
+	}
+	i, err := math.Int(index)
+	if err != nil {
+		return [32]byte{}, nil, err
+	}
+	if finalizedDeposits > 0 && i <= finalizedIdx {
 		return [32]byte{}, nil, ErrInvalidIndex
 	}
 	leaf, proof := generateProof(d.tree, index, DepositContractDepth)

beacon-chain/cache/payload_attestation.go

@@ -0,0 +1,116 @@
+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
+}
+
+// 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,95 @@
+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)
+}

beacon-chain/cache/private_access_test.go

@@ -0,0 +1,18 @@
+package cache
+
+import (
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+)
+
+func BalanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
+	return balanceCacheKey(st)
+}
+
+func MaxCheckpointStateSize() int {
+	return maxCheckpointStateSize
+}
+
+func (c *CheckpointStateCache) Cache() *lru.Cache {
+	return c.cache
+}

beacon-chain/cache/sync_committee_head_state_test.go

@@ -1,8 +1,9 @@
-package cache
+package cache_test
 
 import (
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -125,7 +126,7 @@ func TestSyncCommitteeHeadState(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := NewSyncCommitteeHeadState()
+			c := cache.NewSyncCommitteeHeadState()
 			if tt.put != nil {
 				err := c.Put(tt.put.slot, tt.put.state)
 				if (err != nil) != tt.wantPutErr {

beacon-chain/core/altair/BUILD.bazel

@@ -36,6 +36,7 @@ go_library(
         "//math: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",
@@ -78,6 +79,7 @@ go_test(
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -48,7 +48,7 @@ func ProcessAttestationsNoVerifySignature(
 func ProcessAttestationNoVerifySignature(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	att *ethpb.Attestation,
+	att ethpb.Att,
 	totalBalance uint64,
 ) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "altair.ProcessAttestationNoVerifySignature")
@@ -58,24 +58,24 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	delay, err := beaconState.Slot().SafeSubSlot(att.Data.Slot)
+	delay, err := beaconState.Slot().SafeSubSlot(att.GetData().Slot)
 	if err != nil {
-		return nil, fmt.Errorf("att slot %d can't be greater than state slot %d", att.Data.Slot, beaconState.Slot())
+		return nil, fmt.Errorf("att slot %d can't be greater than state slot %d", att.GetData().Slot, beaconState.Slot())
 	}
-	participatedFlags, err := AttestationParticipationFlagIndices(beaconState, att.Data, delay)
+	participatedFlags, err := AttestationParticipationFlagIndices(beaconState, att.GetData(), delay)
 	if err != nil {
 		return nil, err
 	}
-	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	committees, err := helpers.AttestationCommittees(ctx, beaconState, att)
 	if err != nil {
 		return nil, err
 	}
-	indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
+	indices, err := attestation.AttestingIndices(att, committees...)
 	if err != nil {
 		return nil, err
 	}
 
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.Data.Target.Epoch, indices, participatedFlags, totalBalance)
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards

beacon-chain/core/altair/attestation_test.go

@@ -195,47 +195,95 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 }
 
 func TestProcessAttestations_OK(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 100)
+	t.Run("pre-Electra", func(t *testing.T) {
+		beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 100)
 
-	aggBits := bitfield.NewBitlist(3)
-	aggBits.SetBitAt(0, true)
-	var mockRoot [32]byte
-	copy(mockRoot[:], "hello-world")
-	att := util.HydrateAttestation(&ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Root: mockRoot[:]},
-			Target: &ethpb.Checkpoint{Root: mockRoot[:]},
-		},
-		AggregationBits: aggBits,
+		aggBits := bitfield.NewBitlist(3)
+		aggBits.SetBitAt(0, true)
+		var mockRoot [32]byte
+		copy(mockRoot[:], "hello-world")
+		att := util.HydrateAttestation(&ethpb.Attestation{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Root: mockRoot[:]},
+				Target: &ethpb.Checkpoint{Root: mockRoot[:]},
+			},
+			AggregationBits: aggBits,
+		})
+
+		cfc := beaconState.CurrentJustifiedCheckpoint()
+		cfc.Root = mockRoot[:]
+		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, 0)
+		require.NoError(t, err)
+		attestingIndices, err := attestation.AttestingIndices(att, committee)
+		require.NoError(t, err)
+		sigs := make([]bls.Signature, len(attestingIndices))
+		for i, indice := range attestingIndices {
+			sb, err := signing.ComputeDomainAndSign(beaconState, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+			require.NoError(t, err)
+			sig, err := bls.SignatureFromBytes(sb)
+			require.NoError(t, err)
+			sigs[i] = sig
+		}
+		att.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+		block := util.NewBeaconBlockAltair()
+		block.Block.Body.Attestations = []*ethpb.Attestation{att}
+
+		err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
+		require.NoError(t, err)
+		wsb, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+		_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
+		require.NoError(t, err)
 	})
+	t.Run("post-Electra", func(t *testing.T) {
+		beaconState, privKeys := util.DeterministicGenesisStateElectra(t, 100)
 
-	cfc := beaconState.CurrentJustifiedCheckpoint()
-	cfc.Root = mockRoot[:]
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+		aggBits := bitfield.NewBitlist(3)
+		aggBits.SetBitAt(0, true)
+		committeeBits := primitives.NewAttestationCommitteeBits()
+		committeeBits.SetBitAt(0, true)
+		var mockRoot [32]byte
+		copy(mockRoot[:], "hello-world")
+		att := util.HydrateAttestationElectra(&ethpb.AttestationElectra{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Root: mockRoot[:]},
+				Target: &ethpb.Checkpoint{Root: mockRoot[:]},
+			},
+			AggregationBits: aggBits,
+			CommitteeBits:   committeeBits,
+		})
 
-	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
-	require.NoError(t, err)
-	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
-	require.NoError(t, err)
-	sigs := make([]bls.Signature, len(attestingIndices))
-	for i, indice := range attestingIndices {
-		sb, err := signing.ComputeDomainAndSign(beaconState, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		cfc := beaconState.CurrentJustifiedCheckpoint()
+		cfc.Root = mockRoot[:]
+		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, 0)
 		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
+		attestingIndices, err := attestation.AttestingIndices(att, committee)
 		require.NoError(t, err)
-		sigs[i] = sig
-	}
-	att.Signature = bls.AggregateSignatures(sigs).Marshal()
+		sigs := make([]bls.Signature, len(attestingIndices))
+		for i, indice := range attestingIndices {
+			sb, err := signing.ComputeDomainAndSign(beaconState, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+			require.NoError(t, err)
+			sig, err := bls.SignatureFromBytes(sb)
+			require.NoError(t, err)
+			sigs[i] = sig
+		}
+		att.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	block := util.NewBeaconBlockAltair()
-	block.Block.Body.Attestations = []*ethpb.Attestation{att}
+		block := util.NewBeaconBlockElectra()
+		block.Block.Body.Attestations = []*ethpb.AttestationElectra{att}
 
-	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
-	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
-	require.NoError(t, err)
+		err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
+		require.NoError(t, err)
+		wsb, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+		_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
+		require.NoError(t, err)
+	})
 }
 
 func TestProcessAttestationNoVerify_SourceTargetHead(t *testing.T) {
@@ -273,7 +321,7 @@ func TestProcessAttestationNoVerify_SourceTargetHead(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
+	indices, err := attestation.AttestingIndices(att, committee)
 	require.NoError(t, err)
 	for _, index := range indices {
 		has, err := altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelyHeadFlagIndex)

beacon-chain/core/altair/deposit.go

@@ -5,11 +5,32 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
+// ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
+func ProcessPreGenesisDeposits(
+	ctx context.Context,
+	beaconState state.BeaconState,
+	deposits []*ethpb.Deposit,
+) (state.BeaconState, error) {
+	var err error
+	beaconState, err = ProcessDeposits(ctx, beaconState, deposits)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process deposit")
+	}
+	beaconState, err = blocks.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
+	if err != nil {
+		return nil, err
+	}
+	return beaconState, nil
+}
+
 // ProcessDeposits processes validator deposits for beacon state Altair.
 func ProcessDeposits(
 	ctx context.Context,
@@ -33,23 +54,158 @@ func ProcessDeposits(
 	return beaconState, nil
 }
 
-// ProcessDeposit processes validator deposit for beacon state Altair.
+// ProcessDeposit takes in a deposit object and inserts it
+// into the registry as a new validator or balance change.
+// Returns the resulting state, a boolean to indicate whether or not the deposit
+// resulted in a new validator entry into the beacon state, and any error.
+//
+// Spec pseudocode definition:
+// def process_deposit(state: BeaconState, deposit: Deposit) -> None:
+//
+//	# Verify the Merkle branch
+//	assert is_valid_merkle_branch(
+//		leaf=hash_tree_root(deposit.data),
+//		branch=deposit.proof,
+//		depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
+//		index=state.eth1_deposit_index,
+//		root=state.eth1_data.deposit_root,
+//	)
+//
+//	 # Deposits must be processed in order
+//	 state.eth1_deposit_index += 1
+//
+//	 apply_deposit(
+//	  state=state,
+//	  pubkey=deposit.data.pubkey,
+//	  withdrawal_credentials=deposit.data.withdrawal_credentials,
+//	  amount=deposit.data.amount,
+//	  signature=deposit.data.signature,
+//	 )
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
-	beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
-	if err != nil {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
+		if deposit == nil || deposit.Data == nil {
+			return nil, err
+		}
+		return nil, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+	}
+	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
 		return nil, err
 	}
-	if isNewValidator {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
+
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
+}
+
+// ApplyDeposit
+// Spec pseudocode definition:
+// def apply_deposit(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> None:
+//
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//	if pubkey not in validator_pubkeys:
+//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	    deposit_message = DepositMessage(
+//	        pubkey=pubkey,
+//	        withdrawal_credentials=withdrawal_credentials,
+//	        amount=amount,
+//	    )
+//	    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//	    signing_root = compute_signing_root(deposit_message, domain)
+//	    if bls.Verify(pubkey, signing_root, signature):
+//	        add_validator_to_registry(state, pubkey, withdrawal_credentials, amount)
+//	else:
+//	    # Increase balance by deposit amount
+//	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//	    increase_balance(state, index, amount)
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
+	pubKey := data.PublicKey
+	amount := data.Amount
+	withdrawalCredentials := data.WithdrawalCredentials
+	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+	if !ok {
+		if verifySignature {
+			valid, err := blocks.IsValidDepositSignature(data)
+			if err != nil {
+				return nil, err
+			}
+			if !valid {
+				return beaconState, nil
+			}
+		}
+		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
 			return nil, err
 		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return nil, err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+	} else {
+		if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
 			return nil, err
 		}
 	}
-
 	return beaconState, nil
 }
+
+// AddValidatorToRegistry updates the beacon state with validator information
+// def add_validator_to_registry(state: BeaconState,
+//
+//	                          pubkey: BLSPubkey,
+//	                          withdrawal_credentials: Bytes32,
+//	                          amount: uint64) -> None:
+//	index = get_index_for_new_validator(state)
+//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, 0)
+//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.inactivity_scores, index, uint64(0)) // New in Altair
+func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
+	val := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
+	if err := beaconState.AppendValidator(val); err != nil {
+		return err
+	}
+	if err := beaconState.AppendBalance(amount); err != nil {
+		return err
+	}
+
+	// only active in altair and only when it's a new validator (after append balance)
+	if beaconState.Version() >= version.Altair {
+		if err := beaconState.AppendInactivityScore(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetValidatorFromDeposit gets a new validator object with provided parameters
+//
+// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
+//
+//	effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
+//
+//	return Validator(
+//	    pubkey=pubkey,
+//	    withdrawal_credentials=withdrawal_credentials,
+//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
+//	    activation_epoch=FAR_FUTURE_EPOCH,
+//	    exit_epoch=FAR_FUTURE_EPOCH,
+//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	    effective_balance=effective_balance,
+//	)
+func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
+	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+	}
+
+	return &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           effectiveBalance,
+	}
+}

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -30,6 +30,59 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 	}
 }
 
+func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconStateAltair{}
+	deposit := &ethpb.Deposit{}
+	ctx := context.Background()
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafeAltair(state)
+		require.NoError(t, err)
+		r, err := altair.ProcessPreGenesisDeposits(ctx, s, []*ethpb.Deposit{deposit})
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}
+
+func TestFuzzProcessPreGenesisDeposit_Phase0_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconState{}
+	deposit := &ethpb.Deposit{}
+	ctx := context.Background()
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
+		require.NoError(t, err)
+		r, err := altair.ProcessPreGenesisDeposits(ctx, s, []*ethpb.Deposit{deposit})
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}
+
+func TestFuzzProcessDeposit_Phase0_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconState{}
+	deposit := &ethpb.Deposit{}
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
+		require.NoError(t, err)
+		r, err := altair.ProcessDeposit(s, deposit, true)
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}
+
 func TestFuzzProcessDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateAltair{}

beacon-chain/core/altair/deposit_test.go

@@ -7,11 +7,14 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"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/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
@@ -44,36 +47,6 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 	require.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
 }
 
-func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
-			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, 96),
-		},
-	}
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	beaconState, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: []byte{0},
-			BlockHash:   []byte{1},
-		},
-	})
-	require.NoError(t, err)
-	want := "deposit root did not verify"
-	_, err = altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{deposit})
-	require.ErrorContains(t, want, err)
-}
-
 func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
 	dep, _, err := util.DeterministicDepositsAndKeys(1)
 	require.NoError(t, err)
@@ -245,3 +218,158 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
 	}
 }
+
+func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
+
+	dep, _, err := util.DeterministicDepositsAndKeys(100)
+	require.NoError(t, err)
+	dep[0].Data.Signature = make([]byte, 96)
+	dt, _, err := util.DepositTrieFromDeposits(dep)
+	require.NoError(t, err)
+
+	for i := range dep {
+		proof, err := dt.MerkleProof(i)
+		require.NoError(t, err)
+		dep[i].Proof = proof
+	}
+	root, err := dt.HashTreeRoot()
+	require.NoError(t, err)
+
+	eth1Data := &ethpb.Eth1Data{
+		DepositRoot:  root[:],
+		DepositCount: 1,
+	}
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &ethpb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	newState, err := altair.ProcessPreGenesisDeposits(context.Background(), beaconState, dep)
+	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
+
+	_, ok := newState.ValidatorIndexByPubkey(bytesutil.ToBytes48(dep[0].Data.PublicKey))
+	require.Equal(t, false, ok, "bad pubkey should not exist in state")
+
+	for i := 1; i < newState.NumValidators(); i++ {
+		val, err := newState.ValidatorAtIndex(primitives.ValidatorIndex(i))
+		require.NoError(t, err)
+		require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance, "unequal effective balance")
+		require.Equal(t, primitives.Epoch(0), val.ActivationEpoch)
+		require.Equal(t, primitives.Epoch(0), val.ActivationEligibilityEpoch)
+	}
+	if newState.Eth1DepositIndex() != 100 {
+		t.Errorf(
+			"Expected Eth1DepositIndex to be increased by 99 after processing an invalid deposit, received change: %v",
+			newState.Eth1DepositIndex(),
+		)
+	}
+	if len(newState.Validators()) != 100 {
+		t.Errorf("Expected validator list to have length 100, received: %v", len(newState.Validators()))
+	}
+	if len(newState.Balances()) != 100 {
+		t.Errorf("Expected validator balances list to have length 100, received: %v", len(newState.Balances()))
+	}
+	if newState.Balances()[0] != 0 {
+		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
+	}
+}
+
+func TestProcessDeposit_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             sk.PublicKey().Marshal(),
+			Amount:                1000,
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
+		},
+	}
+	sr, err := signing.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	deposit.Data.Signature = sig.Marshal()
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// We then create a merkle branch for the test.
+	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err, "Could not generate trie")
+	proof, err := depositTrie.MerkleProof(0)
+	require.NoError(t, err, "Could not generate proof")
+
+	deposit.Proof = proof
+	registry := []*ethpb.Validator{
+		{
+			PublicKey: []byte{1, 2, 3},
+		},
+		{
+			PublicKey:             sk.PublicKey().Marshal(),
+			WithdrawalCredentials: []byte{1},
+		},
+	}
+	balances := []uint64{0, 50}
+	root, err := depositTrie.HashTreeRoot()
+	require.NoError(t, err)
+
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: root[:],
+			BlockHash:   root[:],
+		},
+	})
+	require.NoError(t, err)
+	newState, err := altair.ProcessDeposit(beaconState, deposit, true /*verifySignature*/)
+	require.NoError(t, err, "Process deposit failed")
+	require.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
+}
+
+func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, fieldparams.BLSPubkeyLength),
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, fieldparams.BLSSignatureLength),
+		},
+	}
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// We then create a merkle branch for the test.
+	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err, "Could not generate trie")
+	proof, err := depositTrie.MerkleProof(0)
+	require.NoError(t, err, "Could not generate proof")
+
+	deposit.Proof = proof
+	b := util.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Deposits: []*ethpb.Deposit{deposit},
+		},
+	}
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: []byte{0},
+			BlockHash:   []byte{1},
+		},
+	})
+	require.NoError(t, err)
+	want := "deposit root did not verify"
+	_, err = altair.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
+	assert.ErrorContains(t, want, err)
+}

beacon-chain/core/altair/sync_committee.go

@@ -18,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -101,7 +102,8 @@ func NextSyncCommittee(ctx context.Context, s state.BeaconState) (*ethpb.SyncCom
 //	    candidate_index = active_validator_indices[shuffled_index]
 //	    random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
 //	    effective_balance = state.validators[candidate_index].effective_balance
-//	    if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
+//	    # [Modified in Electra:EIP7251]
+//	    if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte:
 //	        sync_committee_indices.append(candidate_index)
 //	    i += 1
 //	return sync_committee_indices
@@ -121,6 +123,11 @@ func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconState) ([]primi
 	cIndices := make([]primitives.ValidatorIndex, 0, syncCommitteeSize)
 	hashFunc := hash.CustomSHA256Hasher()
 
+	maxEB := cfg.MaxEffectiveBalanceElectra
+	if s.Version() < version.Electra {
+		maxEB = cfg.MaxEffectiveBalance
+	}
+
 	for i := primitives.ValidatorIndex(0); uint64(len(cIndices)) < params.BeaconConfig().SyncCommitteeSize; i++ {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
@@ -140,7 +147,7 @@ func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconState) ([]primi
 		}
 
 		effectiveBal := v.EffectiveBalance()
-		if effectiveBal*maxRandomByte >= cfg.MaxEffectiveBalance*uint64(randomByte) {
+		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
 			cIndices = append(cIndices, cIndex)
 		}
 	}

beacon-chain/core/altair/sync_committee_test.go

@@ -13,13 +13,14 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 )
 
 func TestSyncCommitteeIndices_CanGet(t *testing.T) {
-	getState := func(t *testing.T, count uint64) state.BeaconState {
+	getState := func(t *testing.T, count uint64, vers int) state.BeaconState {
 		validators := make([]*ethpb.Validator, count)
 		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
@@ -27,17 +28,28 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
 			}
 		}
-		st, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
-			RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		})
+		var st state.BeaconState
+		var err error
+		switch vers {
+		case version.Altair:
+			st, err = state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
+				RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+			})
+		case version.Electra:
+			st, err = state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
+				RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+			})
+		default:
+			t.Fatal("Unknown version")
+		}
 		require.NoError(t, err)
 		require.NoError(t, st.SetValidators(validators))
 		return st
 	}
 
 	type args struct {
-		state state.BeaconState
-		epoch primitives.Epoch
+		validatorCount uint64
+		epoch          primitives.Epoch
 	}
 	tests := []struct {
 		name      string
@@ -48,32 +60,32 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 		{
 			name: "genesis validator count, epoch 0",
 			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 0,
+				validatorCount: params.BeaconConfig().MinGenesisActiveValidatorCount,
+				epoch:          0,
 			},
 			wantErr: false,
 		},
 		{
 			name: "genesis validator count, epoch 100",
 			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 100,
+				validatorCount: params.BeaconConfig().MinGenesisActiveValidatorCount,
+				epoch:          100,
 			},
 			wantErr: false,
 		},
 		{
 			name: "less than optimal validator count, epoch 100",
 			args: args{
-				state: getState(t, params.BeaconConfig().MaxValidatorsPerCommittee),
-				epoch: 100,
+				validatorCount: params.BeaconConfig().MaxValidatorsPerCommittee,
+				epoch:          100,
 			},
 			wantErr: false,
 		},
 		{
 			name: "no active validators, epoch 100",
 			args: args{
-				state: getState(t, 0), // Regression test for divide by zero. Issue #13051.
-				epoch: 100,
+				validatorCount: 0, // Regression test for divide by zero. Issue #13051.
+				epoch:          100,
 			},
 			wantErr:   true,
 			errString: "no active validator indices",
@@ -81,13 +93,18 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			helpers.ClearCache()
-			got, err := altair.NextSyncCommitteeIndices(context.Background(), tt.args.state)
-			if tt.wantErr {
-				require.ErrorContains(t, tt.errString, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, int(params.BeaconConfig().SyncCommitteeSize), len(got))
+			for _, v := range []int{version.Altair, version.Electra} {
+				t.Run(version.String(v), func(t *testing.T) {
+					helpers.ClearCache()
+					st := getState(t, tt.args.validatorCount, v)
+					got, err := altair.NextSyncCommitteeIndices(context.Background(), st)
+					if tt.wantErr {
+						require.ErrorContains(t, tt.errString, err)
+					} else {
+						require.NoError(t, err)
+						require.Equal(t, int(params.BeaconConfig().SyncCommitteeSize), len(got))
+					}
+				})
 			}
 		})
 	}

beacon-chain/core/altair/transition.go

@@ -28,87 +28,87 @@ import (
 //	process_historical_roots_update(state)
 //	process_participation_flag_updates(state)  # [New in Altair]
 //	process_sync_committee_updates(state)  # [New in Altair]
-func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	ctx, span := trace.StartSpan(ctx, "altair.ProcessEpoch")
 	defer span.End()
 
 	if state == nil || state.IsNil() {
-		return nil, errors.New("nil state")
+		return errors.New("nil state")
 	}
 	vp, bp, err := InitializePrecomputeValidators(ctx, state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// New in Altair.
 	vp, bp, err = ProcessEpochParticipation(ctx, state, bp, vp)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	state, err = precompute.ProcessJustificationAndFinalizationPreCompute(state, bp)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not process justification")
+		return errors.Wrap(err, "could not process justification")
 	}
 
 	// New in Altair.
 	state, vp, err = ProcessInactivityScores(ctx, state, vp)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not process inactivity updates")
+		return errors.Wrap(err, "could not process inactivity updates")
 	}
 
 	// New in Altair.
 	state, err = ProcessRewardsAndPenaltiesPrecompute(state, bp, vp)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not process rewards and penalties")
+		return errors.Wrap(err, "could not process rewards and penalties")
 	}
 
 	state, err = e.ProcessRegistryUpdates(ctx, state)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not process registry updates")
+		return errors.Wrap(err, "could not process registry updates")
 	}
 
 	// Modified in Altair and Bellatrix.
 	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	state, err = e.ProcessSlashings(state, proportionalSlashingMultiplier)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	state, err = e.ProcessEth1DataReset(state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	state, err = e.ProcessEffectiveBalanceUpdates(state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	state, err = e.ProcessSlashingsReset(state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	state, err = e.ProcessRandaoMixesReset(state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	state, err = e.ProcessHistoricalDataUpdate(state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// New in Altair.
 	state, err = ProcessParticipationFlagUpdates(state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// New in Altair.
-	state, err = ProcessSyncCommitteeUpdates(ctx, state)
+	_, err = ProcessSyncCommitteeUpdates(ctx, state)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return state, nil
+	return nil
 }