Fix Execution Block Unmarshalling in Deneb (#12860)

Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com>

.bazelrc

@@ -3,6 +3,7 @@ import %workspace%/build/bazelrc/convenience.bazelrc
 import %workspace%/build/bazelrc/correctness.bazelrc
 import %workspace%/build/bazelrc/cross.bazelrc
 import %workspace%/build/bazelrc/debug.bazelrc
+import %workspace%/build/bazelrc/hermetic-cc.bazelrc
 import %workspace%/build/bazelrc/performance.bazelrc
 
 # E2E run with debug gotag
@@ -14,7 +15,7 @@ coverage --define=coverage_enabled=1
 # Stamp binaries with git information
 build --workspace_status_command=./hack/workspace_status.sh
 
-build --define blst_disabled=false
+build --define blst_disabled=false --define blst_modern=true
 run --define blst_disabled=false
 
 build:blst_disabled --define blst_disabled=true
@@ -27,30 +28,7 @@ build:minimal --@io_bazel_rules_go//go/config:tags=minimal
 build:release --compilation_mode=opt
 build:release --stamp
 
-# LLVM compiler for building C/C++ dependencies.
-build:llvm --define compiler=llvm
-build:llvm --copt -fno-sanitize=vptr,function
-build:llvm --linkopt -fno-sanitize=vptr,function
-# --incompatible_enable_cc_toolchain_resolution not needed after this issue is closed https://github.com/bazelbuild/bazel/issues/7260
-build:llvm --incompatible_enable_cc_toolchain_resolution
-
-build:asan --copt -fsanitize=address,undefined
-build:asan --copt -fno-omit-frame-pointer
-build:asan --linkopt -fsanitize=address,undefined
-build:asan --copt -fno-sanitize=vptr,function
-build:asan --linkopt -fno-sanitize=vptr,function
-build:asan --copt -DADDRESS_SANITIZER=1
-build:asan --copt -D__SANITIZE_ADDRESS__
-build:asan --linkopt -ldl
-
-build:llvm-asan --config=llvm
-build:llvm-asan --config=asan
-build:llvm-asan --linkopt -fuse-ld=ld.lld
-
-build:fuzz --@io_bazel_rules_go//go/config:tags=fuzz
-
 # Build binary with cgo symbolizer for debugging / profiling.
-build:cgo_symbolizer --config=llvm
 build:cgo_symbolizer --copt=-g
 build:cgo_symbolizer --define=USE_CGO_SYMBOLIZER=true
 build:cgo_symbolizer -c dbg
@@ -59,9 +37,13 @@ build:cgo_symbolizer --define=gotags=cgosymbolizer_enabled
 # toolchain build debug configs
 #------------------------------
 build:debug --sandbox_debug
-build:debug --toolchain_resolution_debug
+build:debug --toolchain_resolution_debug=".*"
 build:debug --verbose_failures
 build:debug -s
 
 # Set bazel gotag
 build --define gotags=bazel
+
+# Abseil requires c++14 or greater.
+build --cxxopt=-std=c++20
+build --host_cxxopt=-std=c++20

.bazelversion

@@ -1 +1 @@
-6.1.0
+6.3.2

.github/workflows/fuzz.yml

@@ -0,0 +1,45 @@
+name: "fuzz"
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 12 * * *"
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  list:
+    runs-on: ubuntu-latest
+    timeout-minutes: 180
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v4
+        with:
+          go-version: '1.20'
+      - id: list
+        uses: shogo82148/actions-go-fuzz/list@v0
+        with:
+          tags: fuzz,develop
+    outputs:
+      fuzz-tests: ${{steps.list.outputs.fuzz-tests}}
+
+  fuzz:
+    runs-on: ubuntu-latest
+    timeout-minutes: 360
+    needs: list
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{fromJson(needs.list.outputs.fuzz-tests)}}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v4
+        with:
+          go-version: '1.20'
+      - uses: shogo82148/actions-go-fuzz/run@v0
+        with:
+          packages: ${{ matrix.package }}
+          fuzz-regexp: ${{ matrix.func }}
+          fuzz-time: "20m"
+          tags: fuzz,develop

BUILD.bazel

@@ -3,7 +3,6 @@ load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
-load("@vaticle_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
 load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"
@@ -134,8 +133,8 @@ nogo(
         # nogo checks that fail with coverage enabled.
         ":coverage_enabled": [],
         "//conditions:default": [
-            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_default_library",
             "@org_golang_x_tools//go/analysis/passes/composite:go_default_library",
+            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_default_library",
         ],
     }),
 )

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contribution Guidelines
 
-Note: The latest and most up to date documenation can be found on our [docs portal](https://docs.prylabs.network/docs/contribute/contribution-guidelines).
+Note: The latest and most up-to-date documentation can be found on our [docs portal](https://docs.prylabs.network/docs/contribute/contribution-guidelines).
 
 Excited by our work and want to get involved in building out our sharding releases? Or maybe you haven't learned as much about the Ethereum protocol but are a savvy developer? 
 
@@ -10,9 +10,9 @@ You can explore our [Open Issues](https://github.com/prysmaticlabs/prysm/issues)
 
 **1. Set up Prysm following the instructions in README.md.**
 
-**2. Fork the prysm repo.**
+**2. Fork the Prysm repo.**
 
-Sign in to your Github account or create a new account if you do not have one already. Then navigate your browser to https://github.com/prysmaticlabs/prysm/. In the upper right hand corner of the page, click “fork”. This will create a copy of the Prysm repo in your account.
+Sign in to your GitHub account or create a new account if you do not have one already. Then navigate your browser to https://github.com/prysmaticlabs/prysm/. In the upper right hand corner of the page, click “fork”. This will create a copy of the Prysm repo in your account.
 
 **3. Create a local clone of Prysm.**
 
@@ -23,7 +23,7 @@ $ git clone https://github.com/prysmaticlabs/prysm.git
 $ cd $GOPATH/src/github.com/prysmaticlabs/prysm
 ```
 
-**4. Link your local clone to the fork on your Github repo.**
+**4. Link your local clone to the fork on your GitHub repo.**
 
 ```
 $ git remote add myprysmrepo https://github.com/<your_github_user_name>/prysm.git
@@ -68,7 +68,7 @@ $ go test <file_you_are_working_on>
 $ git add --all
 ```
 
-This command stages all of the files that you have changed. You can add individual files by specifying the file name or names and eliminating the “-- all”.
+This command stages all the files that you have changed. You can add individual files by specifying the file name or names and eliminating the “-- all”.
 
 **11. Commit the file or files.**
 
@@ -96,8 +96,7 @@ If there are conflicts between your edits and those made by others since you sta
 $ git status
 ```
 
-Open those files one at a time and you
-will see lines inserted by Git that identify the conflicts:
+Open those files one at a time, and you will see lines inserted by Git that identify the conflicts:
 
 ```
 <<<<<< HEAD
@@ -119,7 +118,7 @@ $ git push myrepo feature-in-progress-branch
 
 **15. Check to be sure your fork of the Prysm repo contains your feature branch with the latest edits.**
 
-Navigate to your fork of the repo on Github. On the upper left where the current branch is listed, change the branch to your feature-in-progress-branch. Open the files that you have worked on and check to make sure they include your changes.
+Navigate to your fork of the repo on GitHub. On the upper left where the current branch is listed, change the branch to your feature-in-progress-branch. Open the files that you have worked on and check to make sure they include your changes.
 
 **16. Create a pull request.**
 
@@ -151,7 +150,7 @@ pick 	hash 	fix a bug
 pick 	hash 	add a feature
 ```
 
-Replace the word pick with the word “squash” for every line but the first so you end with ….
+Replace the word pick with the word “squash” for every line but the first, so you end with ….
 
 ```
 pick    hash	do some work
@@ -178,7 +177,7 @@ We consider two types of contributions to our repo and categorize them as follow
 Anyone can become a part-time contributor and help out on implementing Ethereum consensus. The responsibilities of a part-time contributor include:
 
 -   Engaging in Gitter conversations, asking the questions on how to begin contributing to the project
--   Opening up github issues to express interest in code to implement
+-   Opening up GitHub issues to express interest in code to implement
 -   Opening up PRs referencing any open issue in the repo. PRs should include:
     -   Detailed context of what would be required for merge
     -   Tests that are consistent with how other tests are written in our implementation
@@ -188,12 +187,12 @@ Anyone can become a part-time contributor and help out on implementing Ethereum
 
 ### Core Contributors
 
-Core contributors are remote contractors of Prysmatic Labs, LLC. and are considered critical team members of our organization. Core devs have all of the responsibilities of part-time contributors plus the majority of the following:
+Core contributors are remote contractors of Prysmatic Labs, LLC. and are considered critical team members of our organization. Core devs have all the responsibilities of part-time contributors plus the majority of the following:
 
 -   Stay up to date on the latest beacon chain specification
--   Monitor github issues and PR’s to make sure owner, labels, descriptions are correct
+-   Monitor GitHub issues and PR’s to make sure owner, labels, descriptions are correct
 -   Formulate independent ideas, suggest new work to do, point out improvements to existing approaches
--   Participate in code review, ensure code quality is excellent, and have ensure high code coverage
+-   Participate in code review, ensure code quality is excellent, and ensure high code coverage
 -   Help with social media presence, write bi-weekly development update
 -   Represent Prysmatic Labs at events to help spread the word on scalability research and solutions
 

WORKSPACE

@@ -17,26 +17,34 @@ load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies")
 rules_pkg_dependencies()
 
 http_archive(
-    name = "com_grail_bazel_toolchain",
-    sha256 = "b210fc8e58782ef171f428bfc850ed7179bdd805543ebd1aa144b9c93489134f",
-    strip_prefix = "bazel-toolchain-83e69ba9e4b4fdad0d1d057fcb87addf77c281c9",
-    urls = ["https://github.com/grailbio/bazel-toolchain/archive/83e69ba9e4b4fdad0d1d057fcb87addf77c281c9.tar.gz"],
+    name = "hermetic_cc_toolchain",
+    sha256 = "973ab22945b921ef45b8e1d6ce01ca7ce1b8a462167449a36e297438c4ec2755",
+    strip_prefix = "hermetic_cc_toolchain-5098046bccc15d2962f3cc8e7e53d6a2a26072dc",
+    urls = [
+        "https://github.com/uber/hermetic_cc_toolchain/archive/5098046bccc15d2962f3cc8e7e53d6a2a26072dc.tar.gz",  # 2023-06-28
+    ],
 )
 
-load("@com_grail_bazel_toolchain//toolchain:deps.bzl", "bazel_toolchain_dependencies")
+load("@hermetic_cc_toolchain//toolchain:defs.bzl", zig_toolchains = "toolchains")
 
-bazel_toolchain_dependencies()
+zig_toolchains()
 
-load("@com_grail_bazel_toolchain//toolchain:rules.bzl", "llvm_toolchain")
-
-llvm_toolchain(
-    name = "llvm_toolchain",
-    llvm_version = "13.0.1",
+# 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
+register_toolchains(
+    "@zig_sdk//toolchain:linux_amd64_gnu.2.31",
+    "@zig_sdk//toolchain:linux_arm64_gnu.2.31",
+    # Hermetic cc toolchain is not yet supported on darwin. Sysroot needs to be provided.
+    # See https://github.com/uber/hermetic_cc_toolchain#osx-sysroot
+    #    "@zig_sdk//toolchain:darwin_amd64",
+    #    "@zig_sdk//toolchain:darwin_arm64",
+    # Windows builds are not supported yet.
+    #    "@zig_sdk//toolchain:windows_amd64",
 )
 
-load("@llvm_toolchain//:toolchains.bzl", "llvm_register_toolchains")
+load("@prysm//tools/cross-toolchain:darwin_cc_hack.bzl", "configure_nonhermetic_darwin")
 
-llvm_register_toolchains()
+configure_nonhermetic_darwin()
 
 load("@prysm//tools/cross-toolchain:prysm_toolchains.bzl", "configure_prysm_toolchains")
 
@@ -59,10 +67,10 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "bazel_gazelle",
-    sha256 = "5982e5463f171da99e3bdaeff8c0f48283a7a5f396ec5282910b9e8a49c0dd7e",
+    sha256 = "29d5dafc2a5582995488c6735115d1d366fcd6a0fc2e2a153f02988706349825",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.25.0/bazel-gazelle-v0.25.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.25.0/bazel-gazelle-v0.25.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.31.0/bazel-gazelle-v0.31.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.31.0/bazel-gazelle-v0.31.0.tar.gz",
     ],
 )
 
@@ -86,10 +94,10 @@ http_archive(
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "6b65cb7917b4d1709f9410ffe00ecf3e160edf674b78c54a894471320862184f",
+    sha256 = "bfc5ce70b9d1634ae54f4e7b495657a18a04e0d596785f672d35d5f505ab491a",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.39.0/rules_go-v0.39.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.39.0/rules_go-v0.39.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.40.0/rules_go-v0.40.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.40.0/rules_go-v0.40.0.zip",
     ],
 )
 
@@ -164,7 +172,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.20.3",
+    go_version = "1.20.7",
     nogo = "@//:nogo",
 )
 
@@ -205,7 +213,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.4.0-alpha.1"
+consensus_spec_version = "v1.4.0-beta.1"
 
 bls_test_version = "v0.1.1"
 
@@ -221,7 +229,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "1118a663be4a00ba00f0635eb20287157f2b2f993aed64335bfbcd04af424c2b",
+    sha256 = "24399b60ce3fbeb2311952d213dc3731b6dcb0f8881b016c283de5b518d2bbba",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -237,7 +245,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "acde6e10940d14f22277eda5b55b65a24623ac88e4c7a2e34134a6069f5eea82",
+    sha256 = "8e656ee48d2e2ebc9cf9baedb81f27925bc625b3e3fbb2883444a08758a5884a",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -253,7 +261,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "49c022f3a3478cea849ba8f877a9f7e4c1ded549edddc09993550bbc5bb192e1",
+    sha256 = "8bd137da6cc57a25383bfac5bc37e31265098145278bd8002b88e24c8b4718b9",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -268,7 +276,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "c3e246ff01f6b7b9e9e41939954a6ff89dfca7297415f88781809165fa83267c",
+    sha256 = "2bc1edb6e4a4f86c00317c04618a90b0ca29ee1eba833d0a64dd67fdd83fdbe3",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -305,39 +313,34 @@ filegroup(
 )
 
 http_archive(
-    name = "com_github_bazelbuild_buildtools",
-    sha256 = "7a182df18df1debabd9e36ae07c8edfa1378b8424a04561b674d933b965372b3",
-    strip_prefix = "buildtools-f2aed9ee205d62d45c55cfabbfd26342f8526862",
-    url = "https://github.com/bazelbuild/buildtools/archive/f2aed9ee205d62d45c55cfabbfd26342f8526862.zip",
+    name = "holesky_testnet",
+    build_file_content = """
+filegroup(
+    name = "configs",
+    srcs = [
+        "custom_config_data/config.yaml",
+    ],
+    visibility = ["//visibility:public"],
+)
+""",
+    sha256 = "4116c8acb54eb3ca28cc4dc9bc688e08e25da91d70ed1f2622f02d3c33eba922",
+    strip_prefix = "holesky-76057d57ab1f585519ecb606a9e5f7780e925a37",
+    url = "https://github.com/eth-clients/holesky/archive/76057d57ab1f585519ecb606a9e5f7780e925a37.tar.gz",  # Aug 27, 2023
 )
 
-git_repository(
+http_archive(
     name = "com_google_protobuf",
-    commit = "436bd7880e458532901c58f4d9d1ea23fa7edd52",
-    remote = "https://github.com/protocolbuffers/protobuf",
-    shallow_since = "1617835118 -0700",
+    sha256 = "4e176116949be52b0408dfd24f8925d1eb674a781ae242a75296b17a1c721395",
+    strip_prefix = "protobuf-23.3",
+    urls = [
+        "https://github.com/protocolbuffers/protobuf/archive/v23.3.tar.gz",
+    ],
 )
 
 # Group the sources of the library so that CMake rule have access to it
 all_content = """filegroup(name = "all", srcs = glob(["**"]), visibility = ["//visibility:public"])"""
 
 # External dependencies
-
-http_archive(
-    name = "prysm_web_ui",
-    build_file_content = """
-filegroup(
-    name = "site",
-    srcs = glob(["**/*"]),
-    visibility = ["//visibility:public"],
-)
-""",
-    sha256 = "5006614c33e358699b4e072c649cd4c3866f7d41a691449d5156f6c6e07a4c60",
-    urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v2.0.3/prysm-web-ui.tar.gz",
-    ],
-)
-
 load("//:deps.bzl", "prysm_deps")
 
 # gazelle:repository_macro deps.bzl%prysm_deps
@@ -369,10 +372,6 @@ load(
 
 _cc_image_repos()
 
-load("@io_bazel_rules_go//extras:embed_data_deps.bzl", "go_embed_data_dependencies")
-
-go_embed_data_dependencies()
-
 load("@com_github_atlassian_bazel_tools//gometalinter:deps.bzl", "gometalinter_dependencies")
 
 gometalinter_dependencies()
@@ -381,10 +380,6 @@ load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
 
 gazelle_dependencies()
 
-load("@com_github_bazelbuild_buildtools//buildifier:deps.bzl", "buildifier_dependencies")
-
-buildifier_dependencies()
-
 load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
 
 protobuf_deps()

api/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["headers.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v4/api",
+    visibility = ["//visibility:public"],
+)

api/client/beacon/checkpoint.go

@@ -5,12 +5,14 @@ import (
 	"fmt"
 	"path"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	base "github.com/prysmaticlabs/prysm/v4/api/client"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/encoding/ssz/detect"
 	"github.com/prysmaticlabs/prysm/v4/io/file"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
@@ -19,6 +21,8 @@ import (
 	"golang.org/x/mod/semver"
 )
 
+var errCheckpointBlockMismatch = errors.New("mismatch between checkpoint sync state and block")
+
 // OriginData represents the BeaconState and ReadOnlySignedBeaconBlock necessary to start an empty Beacon Node
 // using Checkpoint Sync.
 type OriginData struct {
@@ -75,37 +79,40 @@ func DownloadFinalizedData(ctx context.Context, client *Client) (*OriginData, er
 	if err != nil {
 		return nil, errors.Wrap(err, "error unmarshaling finalized state to correct version")
 	}
-	if s.Slot() != s.LatestBlockHeader().Slot {
-		return nil, fmt.Errorf("finalized state slot does not match latest block header slot %d != %d", s.Slot(), s.LatestBlockHeader().Slot)
-	}
 
-	sr, err := s.HashTreeRoot(ctx)
+	slot := s.LatestBlockHeader().Slot
+	bb, err := client.GetBlock(ctx, IdFromSlot(slot))
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to compute htr for finalized state at slot=%d", s.Slot())
-	}
-	header := s.LatestBlockHeader()
-	header.StateRoot = sr[:]
-	br, err := header.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error while computing block root using state data")
-	}
-
-	bb, err := client.GetBlock(ctx, IdFromRoot(br))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by root = %#x", br)
+		return nil, errors.Wrapf(err, "error requesting block by slot = %d", slot)
 	}
 	b, err := vu.UnmarshalBeaconBlock(bb)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
 	}
-	realBlockRoot, err := b.Block().HashTreeRoot()
+	br, err := b.Block().HashTreeRoot()
 	if err != nil {
 		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
 	}
+	bodyRoot, err := b.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block body")
+	}
 
-	log.Printf("BeaconState slot=%d, Block slot=%d", s.Slot(), b.Block().Slot())
-	log.Printf("BeaconState htr=%#x, Block state_root=%#x", sr, b.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#x, block htr=%#x", br, realBlockRoot)
+	sbr := bytesutil.ToBytes32(s.LatestBlockHeader().BodyRoot)
+	if sbr != bodyRoot {
+		return nil, errors.Wrapf(errCheckpointBlockMismatch, "state body root = %#x, block body root = %#x", sbr, bodyRoot)
+	}
+	sr, err := s.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to compute htr for finalized state at slot=%d", s.Slot())
+	}
+
+	log.
+		WithField("block_slot", b.Block().Slot()).
+		WithField("state_slot", s.Slot()).
+		WithField("state_root", hexutil.Encode(sr[:])).
+		WithField("block_root", hexutil.Encode(br[:])).
+		Info("Downloaded checkpoint sync state and block.")
 	return &OriginData{
 		st: s,
 		b:  b,

api/client/beacon/checkpoint_test.go

@@ -128,6 +128,7 @@ func TestDownloadWeakSubjectivityCheckpoint(t *testing.T) {
 	wst, err := util.NewBeaconState()
 	require.NoError(t, err)
 	fork, err := forkForEpoch(cfg, epoch)
+	require.NoError(t, err)
 	require.NoError(t, wst.SetFork(fork))
 
 	// set up checkpoint block
@@ -226,6 +227,7 @@ func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
 	wst, err := util.NewBeaconState()
 	require.NoError(t, err)
 	fork, err := forkForEpoch(cfg, cfg.GenesisEpoch)
+	require.NoError(t, err)
 	require.NoError(t, wst.SetFork(fork))
 
 	// set up checkpoint block
@@ -399,6 +401,7 @@ func TestDownloadFinalizedData(t *testing.T) {
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	fork, err := forkForEpoch(cfg, epoch)
+	require.NoError(t, err)
 	require.NoError(t, st.SetFork(fork))
 	require.NoError(t, st.SetSlot(slot))
 
@@ -440,7 +443,7 @@ func TestDownloadFinalizedData(t *testing.T) {
 		case renderGetStatePath(IdFinalized):
 			res.StatusCode = http.StatusOK
 			res.Body = io.NopCloser(bytes.NewBuffer(ms))
-		case renderGetBlockPath(IdFromRoot(br)):
+		case renderGetBlockPath(IdFromSlot(b.Block().Slot())):
 			res.StatusCode = http.StatusOK
 			res.Body = io.NopCloser(bytes.NewBuffer(mb))
 		default:

api/client/builder/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v4/api/client/builder",
     visibility = ["//visibility:public"],
     deps = [
+        "//config/fieldparams:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
@@ -40,10 +41,12 @@ go_test(
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",

api/client/builder/bid.go

@@ -1,15 +1,12 @@
 package builder
 
 import (
-	"math/big"
-
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	consensus_types "github.com/prysmaticlabs/prysm/v4/consensus-types"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v4/math"
+	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 )
@@ -25,6 +22,7 @@ type SignedBid interface {
 // Bid is an interface describing the method set of a builder bid.
 type Bid interface {
 	Header() (interfaces.ExecutionData, error)
+	BlindedBlobsBundle() (*enginev1.BlindedBlobsBundle, error)
 	Value() []byte
 	Pubkey() []byte
 	Version() int
@@ -117,6 +115,11 @@ func (b builderBid) Header() (interfaces.ExecutionData, error) {
 	return blocks.WrappedExecutionPayloadHeader(b.p.Header)
 }
 
+// BlindedBlobsBundle --
+func (b builderBid) BlindedBlobsBundle() (*enginev1.BlindedBlobsBundle, error) {
+	return nil, errors.New("blinded blobs bundle not available before Deneb")
+}
+
 // Version --
 func (b builderBid) Version() int {
 	return version.Bellatrix
@@ -162,12 +165,13 @@ func WrappedBuilderBidCapella(p *ethpb.BuilderBidCapella) (Bid, error) {
 
 // Header returns the execution data interface.
 func (b builderBidCapella) Header() (interfaces.ExecutionData, error) {
-	if b.p == nil {
-		return nil, errors.New("builder bid is nil")
-	}
 	// We have to convert big endian to little endian because the value is coming from the execution layer.
-	v := big.NewInt(0).SetBytes(bytesutil.ReverseByteOrder(b.p.Value))
-	return blocks.WrappedExecutionPayloadHeaderCapella(b.p.Header, math.WeiToGwei(v))
+	return blocks.WrappedExecutionPayloadHeaderCapella(b.p.Header, blocks.PayloadValueToGwei(b.p.Value))
+}
+
+// BlindedBlobsBundle --
+func (b builderBidCapella) BlindedBlobsBundle() (*enginev1.BlindedBlobsBundle, error) {
+	return nil, errors.New("blinded blobs bundle not available before Deneb")
 }
 
 // Version --
@@ -199,3 +203,90 @@ func (b builderBidCapella) HashTreeRoot() ([32]byte, error) {
 func (b builderBidCapella) HashTreeRootWith(hh *ssz.Hasher) error {
 	return b.p.HashTreeRootWith(hh)
 }
+
+type builderBidDeneb struct {
+	p *ethpb.BuilderBidDeneb
+}
+
+// WrappedBuilderBidDeneb is a constructor which wraps a protobuf bid into an interface.
+func WrappedBuilderBidDeneb(p *ethpb.BuilderBidDeneb) (Bid, error) {
+	w := builderBidDeneb{p: p}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// Version --
+func (b builderBidDeneb) Version() int {
+	return version.Deneb
+}
+
+// Value --
+func (b builderBidDeneb) Value() []byte {
+	return b.p.Value
+}
+
+// Pubkey --
+func (b builderBidDeneb) Pubkey() []byte {
+	return b.p.Pubkey
+}
+
+// IsNil --
+func (b builderBidDeneb) IsNil() bool {
+	return b.p == nil
+}
+
+// HashTreeRoot --
+func (b builderBidDeneb) HashTreeRoot() ([32]byte, error) {
+	return b.p.HashTreeRoot()
+}
+
+// HashTreeRootWith --
+func (b builderBidDeneb) HashTreeRootWith(hh *ssz.Hasher) error {
+	return b.p.HashTreeRootWith(hh)
+}
+
+// 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.PayloadValueToGwei(b.p.Value))
+}
+
+// BlindedBlobsBundle --
+func (b builderBidDeneb) BlindedBlobsBundle() (*enginev1.BlindedBlobsBundle, error) {
+	return b.p.BlindedBlobsBundle, nil
+}
+
+type signedBuilderBidDeneb struct {
+	p *ethpb.SignedBuilderBidDeneb
+}
+
+// WrappedSignedBuilderBidDeneb is a constructor which wraps a protobuf signed bit into an interface.
+func WrappedSignedBuilderBidDeneb(p *ethpb.SignedBuilderBidDeneb) (SignedBid, error) {
+	w := signedBuilderBidDeneb{p: p}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// Message --
+func (b signedBuilderBidDeneb) Message() (Bid, error) {
+	return WrappedBuilderBidDeneb(b.p.Message)
+}
+
+// Signature --
+func (b signedBuilderBidDeneb) Signature() []byte {
+	return b.p.Signature
+}
+
+// Version --
+func (b signedBuilderBidDeneb) Version() int {
+	return version.Deneb
+}
+
+// IsNil --
+func (b signedBuilderBidDeneb) IsNil() bool {
+	return b.p == nil
+}

api/client/builder/client.go

@@ -19,6 +19,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/v4/network"
 	"github.com/prysmaticlabs/prysm/v4/network/authorization"
+	v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	log "github.com/sirupsen/logrus"
@@ -86,7 +87,7 @@ type BuilderClient interface {
 	NodeURL() string
 	GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubkey [48]byte) (SignedBid, error)
 	RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error
-	SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, error)
+	SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock, blobs []*ethpb.SignedBlindedBlobSidecar) (interfaces.ExecutionData, *v1.BlobsBundle, error)
 	Status(ctx context.Context) error
 }
 
@@ -220,6 +221,16 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 		return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
 	}
 	switch strings.ToLower(v.Version) {
+	case strings.ToLower(version.String(version.Deneb)):
+		hr := &ExecHeaderResponseDeneb{}
+		if err := json.Unmarshal(hb, hr); err != nil {
+			return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
+		}
+		p, err := hr.ToProto()
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not extract proto message from header")
+		}
+		return WrappedSignedBuilderBidDeneb(p)
 	case strings.ToLower(version.String(version.Capella)):
 		hr := &ExecHeaderResponseCapella{}
 		if err := json.Unmarshal(hb, hr); err != nil {
@@ -274,20 +285,20 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 
 // 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, error) {
+func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock, blobs []*ethpb.SignedBlindedBlobSidecar) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
 	if !sb.IsBlinded() {
-		return nil, errNotBlinded
+		return nil, nil, errNotBlinded
 	}
 	switch sb.Version() {
 	case version.Bellatrix:
 		psb, err := sb.PbBlindedBellatrixBlock()
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not get protobuf block")
+			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
 		}
 		b := &SignedBlindedBeaconBlockBellatrix{SignedBlindedBeaconBlockBellatrix: psb}
 		body, err := json.Marshal(b)
 		if err != nil {
-			return nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockBellatrix value body in SubmitBlindedBlock")
+			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockBellatrix value body in SubmitBlindedBlock")
 		}
 
 		versionOpt := func(r *http.Request) {
@@ -296,29 +307,33 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 
 		if err != nil {
-			return nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockBellatrix to the builder api")
+			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, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlock response")
+			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlock response")
 		}
 		if strings.ToLower(ep.Version) != version.String(version.Bellatrix) {
-			return nil, errors.New("not a bellatrix payload")
+			return nil, nil, errors.New("not a bellatrix payload")
 		}
 		p, err := ep.ToProto()
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not extract proto message from payload")
+			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
 		}
-		return blocks.WrappedExecutionPayload(p)
+		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, errors.Wrapf(err, "could not get protobuf block")
+			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
 		}
 		b := &SignedBlindedBeaconBlockCapella{SignedBlindedBeaconBlockCapella: psb}
 		body, err := json.Marshal(b)
 		if err != nil {
-			return nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockCapella value body in SubmitBlindedBlockCapella")
+			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockCapella value body in SubmitBlindedBlockCapella")
 		}
 
 		versionOpt := func(r *http.Request) {
@@ -327,22 +342,61 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 
 		if err != nil {
-			return nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockCapella to the builder api")
+			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, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockCapella response")
+			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockCapella response")
 		}
 		if strings.ToLower(ep.Version) != version.String(version.Capella) {
-			return nil, errors.New("not a capella payload")
+			return nil, nil, errors.New("not a capella payload")
 		}
 		p, err := ep.ToProto()
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not extract proto message from payload")
+			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
 		}
-		return blocks.WrappedExecutionPayloadCapella(p, 0)
+		payload, err := blocks.WrappedExecutionPayloadCapella(p, 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 := &ethpb.SignedBlindedBeaconBlockAndBlobsDeneb{Block: psb, Blobs: blobs}
+		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))
+		}
+		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, 0)
+		if err != nil {
+			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
+		}
+		return payload, blobBundle, nil
 	default:
-		return nil, fmt.Errorf("unsupported block version %s", version.String(sb.Version()))
+		return nil, nil, fmt.Errorf("unsupported block version %s", version.String(sb.Version()))
 	}
 }
 

api/client/builder/client_test.go

@@ -12,7 +12,9 @@ import (
 	"strconv"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/go-bitfield"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
@@ -125,7 +127,6 @@ func TestClient_GetHeader(t *testing.T) {
 	var slot types.Slot = 23
 	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
 	pubkey := ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
-
 	t.Run("server error", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -236,6 +237,88 @@ func TestClient_GetHeader(t *testing.T) {
 		require.DeepEqual(t, bidValue, value.Bytes())
 		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
 	})
+	t.Run("deneb", func(t *testing.T) {
+		hc := &http.Client{
+			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+				require.Equal(t, expectedPath, r.URL.Path)
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewBufferString(testExampleHeaderResponseDeneb)),
+					Request:    r.Clone(ctx),
+				}, nil
+			}),
+		}
+		c := &Client{
+			hc:      hc,
+			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+		}
+		h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
+		require.NoError(t, err)
+		expectedWithdrawalsRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+		bid, err := h.Message()
+		require.NoError(t, err)
+		bidHeader, err := bid.Header()
+		require.NoError(t, err)
+		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
+		require.NoError(t, err)
+		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
+		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+		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)
+		bundle, err := bid.BlindedBlobsBundle()
+		require.NoError(t, err)
+		require.Equal(t, len(bundle.BlobRoots) <= fieldparams.MaxBlobsPerBlock && len(bundle.BlobRoots) > 0, true)
+		for i := range bundle.BlobRoots {
+			require.Equal(t, len(bundle.BlobRoots[i]) == fieldparams.RootLength, true)
+		}
+		require.Equal(t, len(bundle.KzgCommitments) > 0, true)
+		for i := range bundle.KzgCommitments {
+			require.Equal(t, len(bundle.KzgCommitments[i]) == 48, true)
+		}
+		require.Equal(t, len(bundle.Proofs) > 0, true)
+		for i := range bundle.Proofs {
+			require.Equal(t, len(bundle.Proofs[i]) == 48, true)
+		}
+	})
+	t.Run("deneb, no bundle", func(t *testing.T) {
+		hc := &http.Client{
+			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+				require.Equal(t, expectedPath, r.URL.Path)
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewBufferString(testExampleHeaderResponseDenebNoBundle)),
+					Request:    r.Clone(ctx),
+				}, nil
+			}),
+		}
+		c := &Client{
+			hc:      hc,
+			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+		}
+		h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
+		require.NoError(t, err)
+		expectedWithdrawalsRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+		bid, err := h.Message()
+		require.NoError(t, err)
+		bidHeader, err := bid.Header()
+		require.NoError(t, err)
+		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
+		require.NoError(t, err)
+		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
+		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+		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)
+		bundle, err := bid.BlindedBlobsBundle()
+		require.NoError(t, err)
+		require.Equal(t, (*v1.BlindedBlobsBundle)(nil), bundle)
+	})
+
 	t.Run("unsupported version", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -277,7 +360,7 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		}
 		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
 		require.NoError(t, err)
-		ep, err := c.SubmitBlindedBlock(ctx, sbbb)
+		ep, _, err := c.SubmitBlindedBlock(ctx, sbbb, nil)
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"), ep.ParentHash()))
 		bfpg, err := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
@@ -303,7 +386,7 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		}
 		sbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockCapella(t))
 		require.NoError(t, err)
-		ep, err := c.SubmitBlindedBlock(ctx, sbb)
+		ep, _, err := c.SubmitBlindedBlock(ctx, sbb, nil)
 		require.NoError(t, err)
 		withdrawals, err := ep.Withdrawals()
 		require.NoError(t, err)
@@ -313,6 +396,40 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 	})
+	t.Run("deneb", func(t *testing.T) {
+		hc := &http.Client{
+			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
+				require.Equal(t, "deneb", r.Header.Get("Eth-Consensus-Version"))
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayloadDeneb)),
+					Request:    r.Clone(ctx),
+				}, nil
+			}),
+		}
+		c := &Client{
+			hc:      hc,
+			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+		}
+		test := testSignedBlindedBeaconBlockAndBlobsDeneb(t)
+		sbb, err := blocks.NewSignedBeaconBlock(test.Block)
+		require.NoError(t, err)
+
+		ep, blobBundle, err := c.SubmitBlindedBlock(ctx, sbb, test.Blobs)
+		require.NoError(t, err)
+		withdrawals, err := ep.Withdrawals()
+		require.NoError(t, err)
+		require.Equal(t, 1, len(withdrawals))
+		assert.Equal(t, uint64(1), withdrawals[0].Index)
+		assert.Equal(t, types.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
+		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
+		assert.Equal(t, uint64(1), withdrawals[0].Amount)
+		require.NotNil(t, blobBundle)
+		require.Equal(t, hexutil.Encode(blobBundle.Blobs[0]), hexutil.Encode(make([]byte, fieldparams.BlobLength)))
+		require.Equal(t, hexutil.Encode(blobBundle.KzgCommitments[0]), "0x8dab030c51e16e84be9caab84ee3d0b8bbec1db4a0e4de76439da8424d9b957370a10a78851f97e4b54d2ce1ab0d686f")
+		require.Equal(t, hexutil.Encode(blobBundle.Proofs[0]), "0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a")
+	})
 	t.Run("mismatched versions, expected bellatrix got capella", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -330,13 +447,13 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		}
 		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
 		require.NoError(t, err)
-		_, err = c.SubmitBlindedBlock(ctx, sbbb)
+		_, _, err = c.SubmitBlindedBlock(ctx, sbbb, nil)
 		require.ErrorContains(t, "not a bellatrix payload", err)
 	})
 	t.Run("not blinded", func(t *testing.T) {
 		sbb, err := blocks.NewSignedBeaconBlock(&eth.SignedBeaconBlockBellatrix{Block: &eth.BeaconBlockBellatrix{Body: &eth.BeaconBlockBodyBellatrix{}}})
 		require.NoError(t, err)
-		_, err = (&Client{}).SubmitBlindedBlock(ctx, sbb)
+		_, _, err = (&Client{}).SubmitBlindedBlock(ctx, sbb, nil)
 		require.ErrorIs(t, err, errNotBlinded)
 	})
 }
@@ -626,6 +743,168 @@ func testSignedBlindedBeaconBlockCapella(t *testing.T) *eth.SignedBlindedBeaconB
 	}
 }
 
+func testSignedBlindedBeaconBlockAndBlobsDeneb(t *testing.T) *eth.SignedBlindedBeaconBlockAndBlobsDeneb {
+	return &eth.SignedBlindedBeaconBlockAndBlobsDeneb{
+		Block: &eth.SignedBlindedBeaconBlockDeneb{
+			Block: &eth.BlindedBeaconBlockDeneb{
+				Slot:          1,
+				ProposerIndex: 1,
+				ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				Body: &eth.BlindedBeaconBlockBodyDeneb{
+					RandaoReveal: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+					Eth1Data: &eth.Eth1Data{
+						DepositRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						DepositCount: 1,
+						BlockHash:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					},
+					Graffiti: ezDecode(t, "0xdeadbeefc0ffee"),
+					ProposerSlashings: []*eth.ProposerSlashing{
+						{
+							Header_1: &eth.SignedBeaconBlockHeader{
+								Header: &eth.BeaconBlockHeader{
+									Slot:          1,
+									ProposerIndex: 1,
+									ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+								Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+							},
+							Header_2: &eth.SignedBeaconBlockHeader{
+								Header: &eth.BeaconBlockHeader{
+									Slot:          1,
+									ProposerIndex: 1,
+									ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+								Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+							},
+						},
+					},
+					AttesterSlashings: []*eth.AttesterSlashing{
+						{
+							Attestation_1: &eth.IndexedAttestation{
+								AttestingIndices: []uint64{1},
+								Data: &eth.AttestationData{
+									Slot:            1,
+									CommitteeIndex:  1,
+									BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									Source: &eth.Checkpoint{
+										Epoch: 1,
+										Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									},
+									Target: &eth.Checkpoint{
+										Epoch: 1,
+										Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									},
+								},
+								Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+							},
+							Attestation_2: &eth.IndexedAttestation{
+								AttestingIndices: []uint64{1},
+								Data: &eth.AttestationData{
+									Slot:            1,
+									CommitteeIndex:  1,
+									BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									Source: &eth.Checkpoint{
+										Epoch: 1,
+										Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									},
+									Target: &eth.Checkpoint{
+										Epoch: 1,
+										Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+									},
+								},
+								Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+							},
+						},
+					},
+					Attestations: []*eth.Attestation{
+						{
+							AggregationBits: bitfield.Bitlist{0x01},
+							Data: &eth.AttestationData{
+								Slot:            1,
+								CommitteeIndex:  1,
+								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								Source: &eth.Checkpoint{
+									Epoch: 1,
+									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+								Target: &eth.Checkpoint{
+									Epoch: 1,
+									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+							},
+							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+					},
+					Deposits: []*eth.Deposit{
+						{
+							Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
+							Data: &eth.Deposit_Data{
+								PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
+								WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								Amount:                1,
+								Signature:             ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+							},
+						},
+					},
+					VoluntaryExits: []*eth.SignedVoluntaryExit{
+						{
+							Exit: &eth.VoluntaryExit{
+								Epoch:          1,
+								ValidatorIndex: 1,
+							},
+							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+					},
+					SyncAggregate: &eth.SyncAggregate{
+						SyncCommitteeSignature: make([]byte, 48),
+						SyncCommitteeBits:      bitfield.Bitvector512{0x01},
+					},
+					ExecutionPayloadHeader: &v1.ExecutionPayloadHeaderDeneb{
+						ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
+						StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+						PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						BlockNumber:      1,
+						GasLimit:         1,
+						GasUsed:          1,
+						Timestamp:        1,
+						ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						BaseFeePerGas:    []byte(strconv.FormatUint(1, 10)),
+						BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						WithdrawalsRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+						BlobGasUsed:      1,
+						ExcessBlobGas:    2,
+					},
+				},
+			},
+			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+		},
+		Blobs: []*eth.SignedBlindedBlobSidecar{
+			{
+				Message: &eth.BlindedBlobSidecar{
+					BlockRoot:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					Index:           0,
+					Slot:            1,
+					BlockParentRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					ProposerIndex:   1,
+					BlobRoot:        ezDecode(t, "0x24564723180fcb3d994104538d351c8dcbde12d541676bb736cf678018ca4739"),
+					KzgCommitment:   ezDecode(t, "0x8dab030c51e16e84be9caab84ee3d0b8bbec1db4a0e4de76439da8424d9b957370a10a78851f97e4b54d2ce1ab0d686f"),
+					KzgProof:        ezDecode(t, "0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a"),
+				},
+				Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+			},
+		},
+	}
+}
+
 func TestRequestLogger(t *testing.T) {
 	wo := WithObserver(&requestLogger{})
 	c, err := NewClient("localhost:3500", wo)

api/client/builder/testing/BUILD.bazel

@@ -10,6 +10,7 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
     ],
 )

api/client/builder/testing/mock.go

@@ -7,6 +7,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
+	v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
@@ -40,8 +41,8 @@ func (m MockClient) RegisterValidator(_ context.Context, svr []*ethpb.SignedVali
 }
 
 // SubmitBlindedBlock --
-func (MockClient) SubmitBlindedBlock(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, error) {
-	return nil, nil
+func (MockClient) SubmitBlindedBlock(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock, _ []*ethpb.SignedBlindedBlobSidecar) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
+	return nil, nil, nil
 }
 
 // Status --

api/client/builder/types_test.go

@@ -14,6 +14,8 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/golang/protobuf/proto"
 	"github.com/prysmaticlabs/go-bitfield"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v4/math"
 	v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
@@ -116,6 +118,77 @@ var testExampleHeaderResponseCapella = `{
   }
 }`
 
+var testExampleHeaderResponseDeneb = `{
+  "version": "deneb",
+  "data": {
+    "message": {
+      "header": {
+        "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+        "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "block_number": "1",
+        "gas_limit": "1",
+        "gas_used": "1",
+        "timestamp": "1",
+        "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
+		"block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "transactions_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "withdrawals_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"blob_gas_used": "1",	
+		"excess_blob_gas": "2"	
+      },
+      "blinded_blobs_bundle": {
+        "commitments": [
+          "0x8dab030c51e16e84be9caab84ee3d0b8bbec1db4a0e4de76439da8424d9b957370a10a78851f97e4b54d2ce1ab0d686f"
+        ],
+        "proofs": [
+          "0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a"
+        ],
+        "blob_roots": [
+          "0x24564723180fcb3d994104538d351c8dcbde12d541676bb736cf678018ca4739"
+        ]
+      },
+      "value": "652312848583266388373324160190187140051835877600158453279131187530910662656",
+      "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  }
+}`
+
+var testExampleHeaderResponseDenebNoBundle = `{
+  "version": "deneb",
+  "data": {
+    "message": {
+      "header": {
+        "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+        "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "block_number": "1",
+        "gas_limit": "1",
+        "gas_used": "1",
+        "timestamp": "1",
+        "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
+		"block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "transactions_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "withdrawals_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"blob_gas_used": "1",	
+		"excess_blob_gas": "2"	
+      },
+      "value": "652312848583266388373324160190187140051835877600158453279131187530910662656",
+      "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  }
+}`
+
 var testExampleHeaderResponseUnknownVersion = `{
   "version": "bad",
   "data": {
@@ -518,6 +591,51 @@ var testExampleExecutionPayloadCapella = `{
   }
 }`
 
+var testExampleExecutionPayloadDeneb = fmt.Sprintf(`{
+  "version": "deneb",
+  "data": {
+	"execution_payload":{
+		"parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+		"state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+		"prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"block_number": "1",
+		"gas_limit": "1",
+		"gas_used": "1",
+		"timestamp": "1",
+		"extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
+		"block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		"transactions": [
+		  "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
+		],
+		"withdrawals": [
+		  {
+			"index": "1",
+			"validator_index": "1",
+			"address": "0xcf8e0d4e9587369b2301d0790347320302cc0943",
+			"amount": "1"
+		  }
+		],
+		"blob_gas_used": "2",
+ 		"excess_blob_gas": "3"
+	  },
+	"blobs_bundle": {
+      "commitments": [
+        "0x8dab030c51e16e84be9caab84ee3d0b8bbec1db4a0e4de76439da8424d9b957370a10a78851f97e4b54d2ce1ab0d686f"
+      ],
+      "proofs": [
+        "0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a"
+      ],
+      "blobs": [
+        "%s"
+      ]
+    }
+  }
+}`, hexutil.Encode(make([]byte, fieldparams.BlobLength)))
+
 func TestExecutionPayloadResponseUnmarshal(t *testing.T) {
 	epr := &ExecPayloadResponse{}
 	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), epr))
@@ -689,6 +807,107 @@ func TestExecutionPayloadResponseCapellaUnmarshal(t *testing.T) {
 	assert.Equal(t, uint64(1), w.Amount.Uint64())
 }
 
+func TestExecutionPayloadResponseDenebUnmarshal(t *testing.T) {
+	epr := &ExecPayloadResponseDeneb{}
+	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadDeneb), epr))
+	cases := []struct {
+		expected string
+		actual   string
+		name     string
+	}{
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.ParentHash),
+			name:     "ExecPayloadResponse.ExecutionPayload.ParentHash",
+		},
+		{
+			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.FeeRecipient),
+			name:     "ExecPayloadResponse.ExecutionPayload.FeeRecipient",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.StateRoot),
+			name:     "ExecPayloadResponse.ExecutionPayload.StateRoot",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.ReceiptsRoot),
+			name:     "ExecPayloadResponse.ExecutionPayload.ReceiptsRoot",
+		},
+		{
+			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.LogsBloom),
+			name:     "ExecPayloadResponse.ExecutionPayload.LogsBloom",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.PrevRandao),
+			name:     "ExecPayloadResponse.ExecutionPayload.PrevRandao",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.BlockNumber),
+			name:     "ExecPayloadResponse.ExecutionPayload.BlockNumber",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.GasLimit),
+			name:     "ExecPayloadResponse.ExecutionPayload.GasLimit",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.GasUsed),
+			name:     "ExecPayloadResponse.ExecutionPayload.GasUsed",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.Timestamp),
+			name:     "ExecPayloadResponse.ExecutionPayload.Timestamp",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.ExtraData),
+			name:     "ExecPayloadResponse.ExecutionPayload.ExtraData",
+		},
+		{
+			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.BaseFeePerGas),
+			name:     "ExecPayloadResponse.ExecutionPayload.BaseFeePerGas",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExecutionPayload.BlockHash),
+			name:     "ExecPayloadResponse.ExecutionPayload.BlockHash",
+		},
+		{
+			expected: "2",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.BlobGasUsed),
+			name:     "ExecPayloadResponse.ExecutionPayload.BlobGasUsed",
+		},
+		{
+			expected: "3",
+			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.ExcessBlobGas),
+			name:     "ExecPayloadResponse.ExecutionPayload.ExcessBlobGas",
+		},
+	}
+	for _, c := range cases {
+		require.Equal(t, c.expected, c.actual, fmt.Sprintf("unexpected value for field %s", c.name))
+	}
+	require.Equal(t, 1, len(epr.Data.ExecutionPayload.Transactions))
+	txHash := "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
+	require.Equal(t, txHash, hexutil.Encode(epr.Data.ExecutionPayload.Transactions[0]))
+
+	require.Equal(t, 1, len(epr.Data.ExecutionPayload.Withdrawals))
+	w := epr.Data.ExecutionPayload.Withdrawals[0]
+	assert.Equal(t, uint64(1), w.Index.Uint64())
+	assert.Equal(t, uint64(1), w.ValidatorIndex.Uint64())
+	assert.DeepEqual(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943", w.Address.String())
+	assert.Equal(t, uint64(1), w.Amount.Uint64())
+	assert.Equal(t, uint64(2), uint64(epr.Data.ExecutionPayload.BlobGasUsed))
+	assert.Equal(t, uint64(3), uint64(epr.Data.ExecutionPayload.ExcessBlobGas))
+}
+
 func TestExecutionPayloadResponseToProto(t *testing.T) {
 	hr := &ExecPayloadResponse{}
 	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), hr))
@@ -796,6 +1015,85 @@ func TestExecutionPayloadResponseCapellaToProto(t *testing.T) {
 
 }
 
+func TestExecutionPayloadResponseDenebToProto(t *testing.T) {
+	hr := &ExecPayloadResponseDeneb{}
+	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadDeneb), hr))
+	p, blobsBundle, err := hr.ToProto()
+	require.NoError(t, err)
+
+	parentHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	feeRecipient, err := hexutil.Decode("0xabcf8e0d4e9587369b2301d0790347320302cc09")
+	require.NoError(t, err)
+	stateRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	receiptsRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	logsBloom, err := hexutil.Decode("0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+	require.NoError(t, err)
+	prevRandao, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	extraData, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	blockHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+
+	tx, err := hexutil.Decode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")
+	require.NoError(t, err)
+	txList := [][]byte{tx}
+	address, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943")
+	require.NoError(t, err)
+
+	bfpg, err := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
+	require.NoError(t, err)
+	expected := &v1.ExecutionPayloadDeneb{
+		ParentHash:    parentHash,
+		FeeRecipient:  feeRecipient,
+		StateRoot:     stateRoot,
+		ReceiptsRoot:  receiptsRoot,
+		LogsBloom:     logsBloom,
+		PrevRandao:    prevRandao,
+		BlockNumber:   1,
+		GasLimit:      1,
+		GasUsed:       1,
+		Timestamp:     1,
+		ExtraData:     extraData,
+		BaseFeePerGas: bfpg.SSZBytes(),
+		BlockHash:     blockHash,
+		Transactions:  txList,
+		Withdrawals: []*v1.Withdrawal{
+			{
+				Index:          1,
+				ValidatorIndex: 1,
+				Address:        address,
+				Amount:         1,
+			},
+		},
+		BlobGasUsed:   2,
+		ExcessBlobGas: 3,
+	}
+	require.DeepEqual(t, expected, p)
+	commitment, err := hexutil.Decode("0x8dab030c51e16e84be9caab84ee3d0b8bbec1db4a0e4de76439da8424d9b957370a10a78851f97e4b54d2ce1ab0d686f")
+	require.NoError(t, err)
+	proof, err := hexutil.Decode("0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a")
+	require.NoError(t, err)
+
+	expectedBlobs := &v1.BlobsBundle{
+		KzgCommitments: [][]byte{
+			commitment,
+		},
+		Proofs: [][]byte{
+			proof,
+		},
+		Blobs: [][]byte{
+			make([]byte, fieldparams.BlobLength),
+		},
+	}
+
+	require.DeepEqual(t, blobsBundle, expectedBlobs)
+
+}
+
 func pbEth1Data() *eth.Eth1Data {
 	return &eth.Eth1Data{
 		DepositRoot:  make([]byte, 32),
@@ -1026,6 +1324,30 @@ func pbExecutionPayloadHeaderCapella(t *testing.T) *v1.ExecutionPayloadHeaderCap
 	}
 }
 
+func pbExecutionPayloadHeaderDeneb(t *testing.T) *v1.ExecutionPayloadHeaderDeneb {
+	bfpg, err := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
+	require.NoError(t, err)
+	return &v1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
+		StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+		PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		BlockNumber:      1,
+		GasLimit:         1,
+		GasUsed:          1,
+		Timestamp:        1,
+		ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		BaseFeePerGas:    bfpg.SSZBytes(),
+		BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		WithdrawalsRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		BlobGasUsed:      1,
+		ExcessBlobGas:    2,
+	}
+}
+
 func TestExecutionPayloadHeader_MarshalJSON(t *testing.T) {
 	h := &ExecutionPayloadHeader{
 		ExecutionPayloadHeader: pbExecutionPayloadHeader(t),
@@ -1046,6 +1368,16 @@ func TestExecutionPayloadHeaderCapella_MarshalJSON(t *testing.T) {
 	require.Equal(t, expected, string(b))
 }
 
+func TestExecutionPayloadHeaderDeneb_MarshalJSON(t *testing.T) {
+	h := &ExecutionPayloadHeaderDeneb{
+		ExecutionPayloadHeaderDeneb: pbExecutionPayloadHeaderDeneb(t),
+	}
+	b, err := json.Marshal(h)
+	require.NoError(t, err)
+	expected := `{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"452312848583266388373324160190187140051835877600158453279131187530910662656","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","withdrawals_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","blob_gas_used":"1","excess_blob_gas":"2"}`
+	require.Equal(t, expected, string(b))
+}
+
 var testBuilderBid = `{
     "version":"bellatrix",
 	"data":{
@@ -1104,40 +1436,40 @@ func TestIsValidUint256(t *testing.T) {
 	_, ok = value.SetString("-10000000000000000000000000000000000000000000000000000000000000000", 16)
 	require.Equal(t, true, ok)
 	require.Equal(t, 257, value.BitLen())
-	require.Equal(t, false, isValidUint256(value))
+	require.Equal(t, false, math.IsValidUint256(value))
 
 	// negative uint256.max
 	_, ok = value.SetString("-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)
 	require.Equal(t, true, ok)
 	require.Equal(t, 256, value.BitLen())
-	require.Equal(t, false, isValidUint256(value))
+	require.Equal(t, false, math.IsValidUint256(value))
 
 	// negative number
 	_, ok = value.SetString("-1", 16)
 	require.Equal(t, true, ok)
-	require.Equal(t, false, isValidUint256(value))
+	require.Equal(t, false, math.IsValidUint256(value))
 
 	// uint256.min
 	_, ok = value.SetString("0", 16)
 	require.Equal(t, true, ok)
-	require.Equal(t, true, isValidUint256(value))
+	require.Equal(t, true, math.IsValidUint256(value))
 
 	// positive number
 	_, ok = value.SetString("1", 16)
 	require.Equal(t, true, ok)
-	require.Equal(t, true, isValidUint256(value))
+	require.Equal(t, true, math.IsValidUint256(value))
 
 	// uint256.max
 	_, ok = value.SetString("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)
 	require.Equal(t, true, ok)
 	require.Equal(t, 256, value.BitLen())
-	require.Equal(t, true, isValidUint256(value))
+	require.Equal(t, true, math.IsValidUint256(value))
 
 	// uint256.max + 1
 	_, ok = value.SetString("10000000000000000000000000000000000000000000000000000000000000000", 16)
 	require.Equal(t, true, ok)
 	require.Equal(t, 257, value.BitLen())
-	require.Equal(t, false, isValidUint256(value))
+	require.Equal(t, false, math.IsValidUint256(value))
 }
 
 func TestUint256Unmarshal(t *testing.T) {
@@ -1156,6 +1488,14 @@ func TestUint256Unmarshal(t *testing.T) {
 	require.Equal(t, expected, string(m))
 }
 
+func TestUint256Unmarshal_BadData(t *testing.T) {
+	var bigNum Uint256
+
+	assert.ErrorContains(t, "provided Uint256 json string is too short", bigNum.UnmarshalJSON([]byte{'"'}))
+	assert.ErrorContains(t, "provided Uint256 json string is malformed", bigNum.UnmarshalJSON([]byte{'"', '1', '2'}))
+
+}
+
 func TestUint256UnmarshalNegative(t *testing.T) {
 	m := "-1"
 	var value Uint256

api/gateway/apimiddleware/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v4/api/gateway/apimiddleware",
     visibility = ["//visibility:public"],
     deps = [
+        "//api:go_default_library",
         "//api/grpc:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
@@ -32,6 +33,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api:go_default_library",
         "//api/grpc:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",

api/gateway/apimiddleware/process_request.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/api"
 	"github.com/prysmaticlabs/prysm/v4/api/grpc"
 )
 
@@ -116,7 +117,11 @@ func HandleGrpcResponseError(errJson ErrorJson, resp *http.Response, respBody []
 		// Something went wrong, but the request completed, meaning we can write headers and the error message.
 		for h, vs := range resp.Header {
 			for _, v := range vs {
-				w.Header().Set(h, v)
+				if strings.HasSuffix(h, api.VersionHeader) {
+					w.Header().Set(api.VersionHeader, v)
+				} else {
+					w.Header().Set(h, v)
+				}
 			}
 		}
 		// Handle gRPC timeout.
@@ -187,9 +192,11 @@ func WriteMiddlewareResponseHeadersAndBody(grpcResp *http.Response, responseJson
 	var statusCodeHeader string
 	for h, vs := range grpcResp.Header {
 		// We don't want to expose any gRPC metadata in the HTTP response, so we skip forwarding metadata headers.
-		if strings.HasPrefix(h, "Grpc-Metadata") {
-			if h == "Grpc-Metadata-"+grpc.HttpCodeMetadataKey {
+		if strings.HasPrefix(h, grpc.MetadataPrefix) {
+			if h == grpc.WithPrefix(grpc.HttpCodeMetadataKey) {
 				statusCodeHeader = vs[0]
+			} else if strings.HasSuffix(h, api.VersionHeader) {
+				w.Header().Set(api.VersionHeader, vs[0])
 			}
 		} else {
 			for _, v := range vs {
@@ -223,7 +230,7 @@ func WriteError(w http.ResponseWriter, errJson ErrorJson, responseHeader http.He
 	// Include custom error in the error JSON.
 	hasCustomError := false
 	if responseHeader != nil {
-		customError, ok := responseHeader["Grpc-Metadata-"+grpc.CustomErrorMetadataKey]
+		customError, ok := responseHeader[grpc.WithPrefix(grpc.CustomErrorMetadataKey)]
 		if ok {
 			hasCustomError = true
 			// Assume header has only one value and read the 0 index.

api/gateway/apimiddleware/process_request_test.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v4/api"
 	"github.com/prysmaticlabs/prysm/v4/api/grpc"
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
@@ -280,7 +281,8 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		response := &http.Response{
 			Header: http.Header{
 				"Foo": []string{"foo"},
-				"Grpc-Metadata-" + grpc.HttpCodeMetadataKey: []string{"204"},
+				grpc.WithPrefix(grpc.HttpCodeMetadataKey): []string{"204"},
+				grpc.WithPrefix(api.VersionHeader):        []string{"capella"},
 			},
 		}
 		container := defaultResponseContainer()
@@ -299,6 +301,9 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		require.Equal(t, true, ok, "header not found")
 		require.Equal(t, 1, len(v), "wrong number of header values")
 		assert.Equal(t, "224", v[0])
+		v, ok = writer.Header()["Eth-Consensus-Version"]
+		require.Equal(t, true, ok, "header not found")
+		assert.Equal(t, "capella", v[0])
 		assert.Equal(t, 204, writer.Code)
 		assert.DeepEqual(t, responseJson, writer.Body.Bytes())
 	})
@@ -320,11 +325,12 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 
 	t.Run("GET_invalid_status_code", func(t *testing.T) {
 		response := &http.Response{
-			Header: http.Header{},
+			Header: http.Header{"Grpc-Metadata-Eth-Consensus-Version": []string{"capella"}},
 		}
 
 		// Set invalid status code.
-		response.Header["Grpc-Metadata-"+grpc.HttpCodeMetadataKey] = []string{"invalid"}
+		response.Header[grpc.WithPrefix(grpc.HttpCodeMetadataKey)] = []string{"invalid"}
+		response.Header[grpc.WithPrefix(api.VersionHeader)] = []string{"capella"}
 
 		container := defaultResponseContainer()
 		responseJson, err := json.Marshal(container)
@@ -390,7 +396,7 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 func TestWriteError(t *testing.T) {
 	t.Run("ok", func(t *testing.T) {
 		responseHeader := http.Header{
-			"Grpc-Metadata-" + grpc.CustomErrorMetadataKey: []string{"{\"CustomField\":\"bar\"}"},
+			grpc.WithPrefix(grpc.CustomErrorMetadataKey): []string{"{\"CustomField\":\"bar\"}"},
 		}
 		errJson := &testErrorJson{
 			Message: "foo",
@@ -420,7 +426,7 @@ func TestWriteError(t *testing.T) {
 		logHook := test.NewGlobal()
 
 		responseHeader := http.Header{
-			"Grpc-Metadata-" + grpc.CustomErrorMetadataKey: []string{"invalid"},
+			grpc.WithPrefix(grpc.CustomErrorMetadataKey): []string{"invalid"},
 		}
 
 		WriteError(httptest.NewRecorder(), &testErrorJson{}, responseHeader)

api/grpc/parameters.go

@@ -6,3 +6,11 @@ const CustomErrorMetadataKey = "Custom-Error"
 
 // HttpCodeMetadataKey is the key to use when setting custom HTTP status codes in gRPC metadata.
 const HttpCodeMetadataKey = "X-Http-Code"
+
+// MetadataPrefix is the prefix for grpc headers on metadata
+const MetadataPrefix = "Grpc-Metadata"
+
+// WithPrefix creates a new string with grpc metadata prefix
+func WithPrefix(value string) string {
+	return MetadataPrefix + "-" + value
+}

api/headers.go

@@ -0,0 +1,9 @@
+package api
+
+const (
+	VersionHeader                 = "Eth-Consensus-Version"
+	ExecutionPayloadBlindedHeader = "Eth-Execution-Payload-Blinded"
+	ExecutionPayloadValueHeader   = "Eth-Execution-Payload-Value"
+	JsonMediaType                 = "application/json"
+	OctetStreamMediaType          = "application/octet-stream"
+)

beacon-chain/blockchain/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
         "process_block.go",
         "process_block_helpers.go",
         "receive_attestation.go",
+        "receive_blob.go",
         "receive_block.go",
         "service.go",
         "weak_subjectivity_checks.go",
@@ -35,8 +36,8 @@ go_library(
     deps = [
         "//async:go_default_library",
         "//async/event:go_default_library",
+        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
@@ -88,6 +89,7 @@ go_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",
+        "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )
 

beacon-chain/blockchain/chain_info.go

@@ -340,7 +340,13 @@ func (s *Service) IsOptimistic(_ context.Context) (bool, error) {
 	}
 	s.headLock.RLock()
 	headRoot := s.head.root
+	headSlot := s.head.slot
+	headOptimistic := s.head.optimistic
 	s.headLock.RUnlock()
+	// we trust the head package for recent head slots, otherwise fallback to forkchoice
+	if headSlot+2 >= s.CurrentSlot() {
+		return headOptimistic, nil
+	}
 
 	s.cfg.ForkChoiceStore.RLock()
 	defer s.cfg.ForkChoiceStore.RUnlock()
@@ -381,7 +387,7 @@ func (s *Service) InForkchoice(root [32]byte) bool {
 	return s.cfg.ForkChoiceStore.HasNode(root)
 }
 
-// IsViableForkCheckpoint returns whether the given checkpoint is a checkpoint in any
+// 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()
@@ -493,6 +499,13 @@ 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

beacon-chain/blockchain/chain_info_test.go

@@ -422,6 +422,12 @@ func TestService_IsOptimistic(t *testing.T) {
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
+	require.Equal(t, primitives.Slot(0), c.CurrentSlot())
+	require.Equal(t, false, opt)
+
+	c.SetGenesisTime(time.Now().Add(-time.Second * time.Duration(4*params.BeaconConfig().SecondsPerSlot)))
+	opt, err = c.IsOptimistic(ctx)
+	require.NoError(t, err)
 	require.Equal(t, true, opt)
 }
 

beacon-chain/blockchain/error.go

@@ -17,8 +17,6 @@ var (
 	errNilJustifiedCheckpoint = errors.New("nil justified checkpoint returned from state")
 	// errBlockDoesNotExist is returned when a block does not exist for a particular state summary.
 	errBlockDoesNotExist = errors.New("could not find block in DB")
-	// errWrongBlockCount is returned when the wrong number of blocks or block roots is used
-	errWrongBlockCount = errors.New("wrong number of blocks or block roots")
 	// errBlockNotFoundInCacheOrDB is returned when a block is not found in the cache or DB.
 	errBlockNotFoundInCacheOrDB = errors.New("block not found in cache or db")
 	// errWSBlockNotFound is returned when a block is not found in the WS cache or DB.
@@ -41,13 +39,15 @@ var (
 type invalidBlock struct {
 	invalidAncestorRoots [][32]byte
 	error
-	root [32]byte
+	root          [32]byte
+	lastValidHash [32]byte
 }
 
 type invalidBlockError interface {
 	Error() string
 	InvalidAncestorRoots() [][32]byte
 	BlockRoot() [32]byte
+	LastValidHash() [32]byte
 }
 
 // BlockRoot returns the invalid block root.
@@ -55,6 +55,11 @@ func (e invalidBlock) BlockRoot() [32]byte {
 	return e.root
 }
 
+// LastValidHash returns the last valid hash root.
+func (e invalidBlock) LastValidHash() [32]byte {
+	return e.lastValidHash
+}
+
 // InvalidAncestorRoots returns an optional list of invalid roots of the invalid block which leads up last valid root.
 func (e invalidBlock) InvalidAncestorRoots() [][32]byte {
 	return e.invalidAncestorRoots
@@ -72,6 +77,19 @@ func IsInvalidBlock(e error) bool {
 	return true
 }
 
+// InvalidBlockLVH returns the invalid block last valid hash root. If the error
+// doesn't have a last valid hash, [32]byte{} is returned.
+func InvalidBlockLVH(e error) [32]byte {
+	if e == nil {
+		return [32]byte{}
+	}
+	d, ok := e.(invalidBlockError)
+	if !ok {
+		return [32]byte{}
+	}
+	return d.LastValidHash()
+}
+
 // InvalidBlockRoot returns the invalid block root. If the error
 // doesn't have an invalid blockroot. [32]byte{} is returned.
 func InvalidBlockRoot(e error) [32]byte {

beacon-chain/blockchain/execution_engine.go

@@ -2,8 +2,10 @@ package blockchain
 
 import (
 	"context"
+	"crypto/sha256"
 	"fmt"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
@@ -26,6 +28,8 @@ import (
 	"go.opencensus.io/trace"
 )
 
+const blobCommitmentVersionKZG uint8 = 0x01
+
 var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
 
 // notifyForkchoiceUpdateArg is the argument for the forkchoice update notification `notifyForkchoiceUpdate`.
@@ -154,7 +158,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 		var pId [8]byte
 		copy(pId[:], payloadID[:])
 		s.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(nextSlot, proposerId, pId, arg.headRoot)
-	} else if hasAttr && payloadID == nil {
+	} else if hasAttr && payloadID == nil && !features.Get().PrepareAllPayloads {
 		log.WithFields(logrus.Fields{
 			"blockHash": fmt.Sprintf("%#x", headPayload.BlockHash()),
 			"slot":      headBlk.Slot(),
@@ -182,21 +186,24 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 
 // notifyNewPayload signals execution engine on a new payload.
 // It returns true if the EL has returned VALID for the block
-func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
-	postStateHeader interfaces.ExecutionData, blk interfaces.ReadOnlySignedBeaconBlock) (bool, error) {
+func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
+	preStateHeader interfaces.ExecutionData, blk interfaces.ReadOnlySignedBeaconBlock) (bool, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
 	defer span.End()
 
 	// Execution payload is only supported in Bellatrix and beyond. Pre
 	// merge blocks are never optimistic
-	if blocks.IsPreBellatrixVersion(postStateVersion) {
+	if blk == nil {
+		return false, errors.New("signed beacon block can't be nil")
+	}
+	if preStateVersion < version.Bellatrix {
 		return true, nil
 	}
 	if err := consensusblocks.BeaconBlockIsNil(blk); err != nil {
 		return false, err
 	}
 	body := blk.Block().Body()
-	enabled, err := blocks.IsExecutionEnabledUsingHeader(postStateHeader, body)
+	enabled, err := blocks.IsExecutionEnabledUsingHeader(preStateHeader, body)
 	if err != nil {
 		return false, errors.Wrap(invalidBlock{error: err}, "could not determine if execution is enabled")
 	}
@@ -207,7 +214,19 @@ func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
 	if err != nil {
 		return false, errors.Wrap(invalidBlock{error: err}, "could not get execution payload")
 	}
-	lastValidHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
+
+	var lastValidHash []byte
+	if blk.Version() >= version.Deneb {
+		var versionedHashes []common.Hash
+		versionedHashes, err = kzgCommitmentsToVersionedHashes(blk.Block().Body())
+		if err != nil {
+			return false, errors.Wrap(err, "could not get versioned hashes to feed the engine")
+		}
+		pr := common.Hash(blk.Block().ParentRoot())
+		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr)
+	} else {
+		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, []common.Hash{}, &common.Hash{} /*empty version hashes and root before Deneb*/)
+	}
 	switch err {
 	case nil:
 		newPayloadValidNodeCount.Inc()
@@ -220,35 +239,37 @@ func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
 		}).Info("Called new payload with optimistic block")
 		return false, nil
 	case execution.ErrInvalidPayloadStatus:
-		newPayloadInvalidNodeCount.Inc()
-		root, err := blk.Block().HashTreeRoot()
-		if err != nil {
-			return false, err
-		}
-		invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, blk.Block().ParentRoot(), bytesutil.ToBytes32(lastValidHash))
-		if err != nil {
-			return false, err
-		}
-		if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
-			return false, err
-		}
-		log.WithFields(logrus.Fields{
-			"slot":                 blk.Block().Slot(),
-			"blockRoot":            fmt.Sprintf("%#x", root),
-			"invalidChildrenCount": len(invalidRoots),
-		}).Warn("Pruned invalid blocks")
+		lvh := bytesutil.ToBytes32(lastValidHash)
 		return false, invalidBlock{
-			invalidAncestorRoots: invalidRoots,
-			error:                ErrInvalidPayload,
+			error:         ErrInvalidPayload,
+			lastValidHash: lvh,
 		}
-	case execution.ErrInvalidBlockHashPayloadStatus:
-		newPayloadInvalidNodeCount.Inc()
-		return false, ErrInvalidBlockHashPayloadStatus
 	default:
 		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 	}
 }
 
+// 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)
+	if err != nil {
+		return err
+	}
+	if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
+		return err
+	}
+	log.WithFields(logrus.Fields{
+		"blockRoot":            fmt.Sprintf("%#x", root),
+		"invalidChildrenCount": len(invalidRoots),
+	}).Warn("Pruned invalid blocks")
+	return invalidBlock{
+		invalidAncestorRoots: invalidRoots,
+		error:                ErrInvalidPayload,
+		lastValidHash:        lvh,
+	}
+}
+
 // getPayloadAttributes returns the payload attributes for the given state and slot.
 // The attribute is required to initiate a payload build process in the context of an `engine_forkchoiceUpdated` call.
 func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState, slot primitives.Slot, headRoot []byte) (bool, payloadattribute.Attributer, primitives.ValidatorIndex) {
@@ -305,6 +326,23 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 
 	var attr payloadattribute.Attributer
 	switch st.Version() {
+	case version.Deneb:
+		withdrawals, err := st.ExpectedWithdrawals()
+		if err != nil {
+			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
+			return false, emptyAttri, 0
+		}
+		attr, err = payloadattribute.New(&enginev1.PayloadAttributesV3{
+			Timestamp:             uint64(t.Unix()),
+			PrevRandao:            prevRando,
+			SuggestedFeeRecipient: feeRecipient.Bytes(),
+			Withdrawals:           withdrawals,
+			ParentBeaconBlockRoot: headRoot,
+		})
+		if err != nil {
+			log.WithError(err).Error("Could not get payload attribute")
+			return false, emptyAttri, 0
+		}
 	case version.Capella:
 		withdrawals, err := st.ExpectedWithdrawals()
 		if err != nil {
@@ -339,19 +377,36 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 	return true, attr, proposerID
 }
 
-// removeInvalidBlockAndState removes the invalid block and its corresponding state from the cache and DB.
+// removeInvalidBlockAndState removes the invalid block, blob and its corresponding state from the cache and DB.
 func (s *Service) removeInvalidBlockAndState(ctx context.Context, blkRoots [][32]byte) error {
 	for _, root := range blkRoots {
 		if err := s.cfg.StateGen.DeleteStateFromCaches(ctx, root); err != nil {
 			return err
 		}
-
 		// Delete block also deletes the state as well.
 		if err := s.cfg.BeaconDB.DeleteBlock(ctx, root); err != nil {
 			// TODO(10487): If a caller requests to delete a root that's justified and finalized. We should gracefully shutdown.
 			// This is an irreparable condition, it would me a justified or finalized block has become invalid.
 			return err
 		}
+		// No op if the sidecar does not exist.
+		if err := s.cfg.BeaconDB.DeleteBlobSidecar(ctx, root); err != nil {
+			return err
+		}
 	}
 	return nil
 }
+
+func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([]common.Hash, error) {
+	commitments, err := body.BlobKzgCommitments()
+	if err != nil {
+		return nil, errors.Wrap(invalidBlock{error: err}, "could not get blob kzg commitments")
+	}
+
+	versionedHashes := make([]common.Hash, len(commitments))
+	for i, commitment := range commitments {
+		versionedHashes[i] = sha256.Sum256(commitment)
+		versionedHashes[i][0] = blobCommitmentVersionKZG
+	}
+	return versionedHashes, nil
+}

beacon-chain/blockchain/execution_engine_test.go

@@ -525,11 +525,13 @@ func Test_NotifyNewPayload(t *testing.T) {
 		{
 			name:           "phase 0 post state",
 			postState:      phase0State,
+			blk:            altairBlk, // same as phase 0 for this test
 			isValidPayload: true,
 		},
 		{
 			name:           "altair post state",
 			postState:      altairState,
+			blk:            altairBlk,
 			isValidPayload: true,
 		},
 		{
@@ -743,6 +745,37 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	require.Equal(t, true, validated)
 }
 
+func Test_reportInvalidBlock(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	params.OverrideBeaconConfig(params.MainnetConfig())
+	service, tr := minimalTestService(t)
+	ctx, _, fcs := tr.ctx, tr.db, tr.fcs
+	jcp := &ethpb.Checkpoint{}
+	st, root, err := prepareForkchoiceState(ctx, 0, [32]byte{'A'}, [32]byte{}, [32]byte{'a'}, jcp, jcp)
+	require.NoError(t, err)
+	require.NoError(t, fcs.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 1, [32]byte{'B'}, [32]byte{'A'}, [32]byte{'b'}, jcp, jcp)
+	require.NoError(t, err)
+	require.NoError(t, fcs.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'C'}, [32]byte{'B'}, [32]byte{'c'}, jcp, jcp)
+	require.NoError(t, err)
+	require.NoError(t, fcs.InsertNode(ctx, st, root))
+
+	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'d'}, jcp, jcp)
+	require.NoError(t, err)
+	require.NoError(t, fcs.InsertNode(ctx, st, root))
+
+	require.NoError(t, fcs.SetOptimisticToValid(ctx, [32]byte{'A'}))
+	err = service.pruneInvalidBlock(ctx, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'a'})
+	require.Equal(t, IsInvalidBlock(err), true)
+	require.Equal(t, InvalidBlockLVH(err), [32]byte{'a'})
+	invalidRoots := InvalidAncestorRoots(err)
+	require.Equal(t, 3, len(invalidRoots))
+	require.Equal(t, [32]byte{'D'}, invalidRoots[0])
+	require.Equal(t, [32]byte{'C'}, invalidRoots[1])
+	require.Equal(t, [32]byte{'B'}, invalidRoots[2])
+}
+
 func Test_GetPayloadAttribute(t *testing.T) {
 	service, tr := minimalTestService(t, WithProposerIdsCache(cache.NewProposerPayloadIDsCache()))
 	ctx := tr.ctx
@@ -827,6 +860,48 @@ func Test_GetPayloadAttributeV2(t *testing.T) {
 	require.Equal(t, 0, len(a))
 }
 
+func Test_GetPayloadAttributeDeneb(t *testing.T) {
+	service, tr := minimalTestService(t, WithProposerIdsCache(cache.NewProposerPayloadIDsCache()))
+	ctx := tr.ctx
+
+	st, _ := util.DeterministicGenesisStateDeneb(t, 1)
+	hasPayload, _, vId := service.getPayloadAttribute(ctx, st, 0, []byte{})
+	require.Equal(t, false, hasPayload)
+	require.Equal(t, primitives.ValidatorIndex(0), vId)
+
+	// Cache hit, advance state, no fee recipient
+	suggestedVid := primitives.ValidatorIndex(1)
+	slot := primitives.Slot(1)
+	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(slot, suggestedVid, [8]byte{}, [32]byte{})
+	hook := logTest.NewGlobal()
+	hasPayload, attr, vId := service.getPayloadAttribute(ctx, st, slot, params.BeaconConfig().ZeroHash[:])
+	require.Equal(t, true, hasPayload)
+	require.Equal(t, suggestedVid, vId)
+	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient()).String())
+	require.LogsContain(t, hook, "Fee recipient is currently using the burn address")
+	a, err := attr.Withdrawals()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(a))
+
+	// Cache hit, advance state, has fee recipient
+	suggestedAddr := common.HexToAddress("123")
+	require.NoError(t, service.cfg.BeaconDB.SaveFeeRecipientsByValidatorIDs(ctx, []primitives.ValidatorIndex{suggestedVid}, []common.Address{suggestedAddr}))
+	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(slot, suggestedVid, [8]byte{}, [32]byte{})
+	hasPayload, attr, vId = service.getPayloadAttribute(ctx, st, slot, params.BeaconConfig().ZeroHash[:])
+	require.Equal(t, true, hasPayload)
+	require.Equal(t, suggestedVid, vId)
+	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) {
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.MainnetConfig())
@@ -1012,3 +1087,28 @@ func TestService_getPayloadHash(t *testing.T) {
 	require.NoError(t, err)
 	require.DeepEqual(t, [32]byte{'a'}, h)
 }
+
+func TestKZGCommitmentToVersionedHashes(t *testing.T) {
+	kzg1 := make([]byte, 96)
+	kzg1[10] = 'a'
+	kzg2 := make([]byte, 96)
+	kzg2[1] = 'b'
+	commitments := [][]byte{kzg1, kzg2}
+
+	blk := &ethpb.SignedBeaconBlockDeneb{
+		Block: &ethpb.BeaconBlockDeneb{
+			Body: &ethpb.BeaconBlockBodyDeneb{
+				BlobKzgCommitments: commitments,
+			},
+		},
+	}
+	b, err := consensusblocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	vhs, err := kzgCommitmentsToVersionedHashes(b.Block().Body())
+	require.NoError(t, err)
+	vh0 := "0x01cf2315c97658a7ed54ada181765e23b3fadb5150fab39509f631c0b9af4566"
+	vh1 := "0x01e27ce28e527eb07196b31af0f5fa1882ace701a682022ab779f816ac39d47e"
+	require.Equal(t, 2, len(vhs))
+	require.Equal(t, vhs[0].String(), vh0)
+	require.Equal(t, vhs[1].String(), vh1)
+}

beacon-chain/blockchain/head.go

@@ -47,9 +47,11 @@ func (s *Service) UpdateAndSaveHeadWithBalances(ctx context.Context) error {
 
 // This defines the current chain service's view of head.
 type head struct {
-	root  [32]byte                             // current head root.
-	block interfaces.ReadOnlySignedBeaconBlock // current head block.
-	state state.BeaconState                    // current head state.
+	root       [32]byte                             // current head root.
+	block      interfaces.ReadOnlySignedBeaconBlock // current head block.
+	state      state.BeaconState                    // current head state.
+	slot       primitives.Slot                      // the head block slot number
+	optimistic bool                                 // optimistic status when saved head
 }
 
 // This saves head info to the local service cache, it also saves the
@@ -94,6 +96,10 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 		return errors.Wrap(err, "could not get old head root")
 	}
 	oldHeadRoot := bytesutil.ToBytes32(r)
+	isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(newHeadRoot)
+	if err != nil {
+		log.WithError(err).Error("could not check if node is optimistically synced")
+	}
 	if headBlock.Block().ParentRoot() != oldHeadRoot {
 		// A chain re-org occurred, so we fire an event notifying the rest of the services.
 		commonRoot, forkSlot, err := s.cfg.ForkChoiceStore.CommonAncestor(ctx, oldHeadRoot, newHeadRoot)
@@ -125,10 +131,6 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 		reorgDistance.Observe(float64(dis))
 		reorgDepth.Observe(float64(dep))
 
-		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(newHeadRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
-		}
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
@@ -150,7 +152,14 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 	}
 
 	// Cache the new head info.
-	if err := s.setHead(newHeadRoot, headBlock, headState); err != nil {
+	newHead := &head{
+		root:       newHeadRoot,
+		block:      headBlock,
+		state:      headState,
+		optimistic: isOptimistic,
+		slot:       headBlock.Block().Slot(),
+	}
+	if err := s.setHead(newHead); err != nil {
 		return errors.Wrap(err, "could not set head")
 	}
 
@@ -173,7 +182,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 // This gets called to update canonical root mapping. It does not save head block
 // root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
-func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.ReadOnlySignedBeaconBlock, r [32]byte, hs state.BeaconState) error {
+func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.ReadOnlySignedBeaconBlock, r [32]byte, hs state.BeaconState, optimistic bool) error {
 	if err := blocks.BeaconBlockIsNil(b); err != nil {
 		return err
 	}
@@ -189,26 +198,28 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.ReadOnlySignedB
 	if err != nil {
 		return err
 	}
-	if err := s.setHeadInitialSync(r, bCp, hs); err != nil {
+	if err := s.setHeadInitialSync(r, bCp, hs, optimistic); err != nil {
 		return errors.Wrap(err, "could not set head")
 	}
 	return nil
 }
 
-// This sets head view object which is used to track the head slot, root, block and state.
-func (s *Service) setHead(root [32]byte, block interfaces.ReadOnlySignedBeaconBlock, state state.BeaconState) error {
+// This sets head view object which is used to track the head slot, root, block, state and optimistic status
+func (s *Service) setHead(newHead *head) error {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
 	// This does a full copy of the block and state.
-	bCp, err := block.Copy()
+	bCp, err := newHead.block.Copy()
 	if err != nil {
 		return err
 	}
 	s.head = &head{
-		root:  root,
-		block: bCp,
-		state: state.Copy(),
+		root:       newHead.root,
+		block:      bCp,
+		state:      newHead.state.Copy(),
+		optimistic: newHead.optimistic,
+		slot:       newHead.slot,
 	}
 	return nil
 }
@@ -216,7 +227,7 @@ func (s *Service) setHead(root [32]byte, block interfaces.ReadOnlySignedBeaconBl
 // This sets head view object which is used to track the head slot, root, block and state. The method
 // assumes that state being passed into the method will not be modified by any other alternate
 // caller which holds the state's reference.
-func (s *Service) setHeadInitialSync(root [32]byte, block interfaces.ReadOnlySignedBeaconBlock, state state.BeaconState) error {
+func (s *Service) setHeadInitialSync(root [32]byte, block interfaces.ReadOnlySignedBeaconBlock, state state.BeaconState, optimistic bool) error {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
@@ -226,9 +237,10 @@ func (s *Service) setHeadInitialSync(root [32]byte, block interfaces.ReadOnlySig
 		return err
 	}
 	s.head = &head{
-		root:  root,
-		block: bCp,
-		state: state,
+		root:       root,
+		block:      bCp,
+		state:      state,
+		optimistic: optimistic,
 	}
 	return nil
 }

beacon-chain/blockchain/head_sync_committee_info.go

@@ -157,7 +157,11 @@ func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot primitives
 		if headState == nil || headState.IsNil() {
 			return nil, errors.New("nil state")
 		}
-		headState, err = transition.ProcessSlotsIfPossible(ctx, headState, slot)
+		headRoot, err := s.HeadRoot(ctx)
+		if err != nil {
+			return nil, err
+		}
+		headState, err = transition.ProcessSlotsUsingNextSlotCache(ctx, headState, headRoot, slot)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing"
+	dbTest "github.com/prysmaticlabs/prysm/v4/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
@@ -15,7 +16,7 @@ import (
 
 func TestService_HeadSyncCommitteeIndices(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
 	c.head = &head{state: s}
 
 	// Current period
@@ -38,7 +39,7 @@ func TestService_HeadSyncCommitteeIndices(t *testing.T) {
 
 func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
 	c.head = &head{state: s}
 
 	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
@@ -66,7 +67,7 @@ func TestService_headNextSyncCommitteeIndices(t *testing.T) {
 
 func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
 	c.head = &head{state: s}
 
 	// Process slot up to 2 * `EpochsPerSyncCommitteePeriod` so it can run `ProcessSyncCommitteeUpdates` twice.
@@ -81,7 +82,7 @@ func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
 
 func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
 	c.head = &head{state: s}
 
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -0,0 +1,31 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "trusted_setup.go",
+        "validation.go",
+    ],
+    embedsrcs = ["trusted_setup.json"],
+    importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/kzg",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "trusted_setup_test.go",
+        "validation_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
+    ],
+)

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -0,0 +1,28 @@
+package kzg
+
+import (
+	_ "embed"
+	"encoding/json"
+
+	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	"github.com/pkg/errors"
+)
+
+var (
+	//go:embed trusted_setup.json
+	embeddedTrustedSetup []byte // 1.2Mb
+	kzgContext           *GoKZG.Context
+)
+
+func Start() error {
+	parsedSetup := GoKZG.JSONTrustedSetup{}
+	err := json.Unmarshal(embeddedTrustedSetup, &parsedSetup)
+	if err != nil {
+		return errors.Wrap(err, "could not parse trusted setup JSON")
+	}
+	kzgContext, err = GoKZG.NewContext4096(&parsedSetup)
+	if err != nil {
+		return errors.Wrap(err, "could not initialize go-kzg context")
+	}
+	return nil
+}

beacon-chain/blockchain/kzg/trusted_setup_test.go

@@ -0,0 +1,12 @@
+package kzg
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v4/testing/require"
+)
+
+func TestStart(t *testing.T) {
+	require.NoError(t, Start())
+	require.NotNil(t, kzgContext)
+}

beacon-chain/blockchain/kzg/validation.go

@@ -0,0 +1,47 @@
+package kzg
+
+import (
+	"fmt"
+
+	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+)
+
+// IsDataAvailable checks that
+// - all blobs in the block are available
+// - Expected KZG commitments match the number of blobs in the block
+// - That the number of proofs match the number of blobs
+// - That the proofs are verified against the KZG commitments
+func IsDataAvailable(commitments [][]byte, sidecars []*ethpb.BlobSidecar) error {
+	if len(commitments) != len(sidecars) {
+		return fmt.Errorf("could not check data availability, expected %d commitments, obtained %d",
+			len(commitments), len(sidecars))
+	}
+	if len(commitments) == 0 {
+		return nil
+	}
+	blobs := make([]GoKZG.Blob, len(commitments))
+	proofs := make([]GoKZG.KZGProof, len(commitments))
+	cmts := make([]GoKZG.KZGCommitment, len(commitments))
+	for i, sidecar := range sidecars {
+		blobs[i] = bytesToBlob(sidecar.Blob)
+		proofs[i] = bytesToKZGProof(sidecar.KzgProof)
+		cmts[i] = bytesToCommitment(commitments[i])
+	}
+	return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs)
+}
+
+func bytesToBlob(blob []byte) (ret GoKZG.Blob) {
+	copy(ret[:], blob)
+	return
+}
+
+func bytesToCommitment(commitment []byte) (ret GoKZG.KZGCommitment) {
+	copy(ret[:], commitment)
+	return
+}
+
+func bytesToKZGProof(proof []byte) (ret GoKZG.KZGProof) {
+	copy(ret[:], proof)
+	return
+}

beacon-chain/blockchain/kzg/validation_test.go

@@ -0,0 +1,25 @@
+package kzg
+
+import (
+	"testing"
+
+	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/testing/require"
+)
+
+func TestIsDataAvailable(t *testing.T) {
+	sidecars := make([]*ethpb.BlobSidecar, 0)
+	commitments := make([][]byte, 0)
+	require.NoError(t, IsDataAvailable(commitments, sidecars))
+}
+
+func TestBytesToAny(t *testing.T) {
+	bytes := []byte{0x01, 0x02}
+	blob := GoKZG.Blob{0x01, 0x02}
+	commitment := GoKZG.KZGCommitment{0x01, 0x02}
+	proof := GoKZG.KZGProof{0x01, 0x02}
+	require.DeepEqual(t, blob, bytesToBlob(bytes))
+	require.DeepEqual(t, commitment, bytesToCommitment(bytes))
+	require.DeepEqual(t, proof, bytesToKZGProof(bytes))
+}

beacon-chain/blockchain/log.go

@@ -61,6 +61,14 @@ func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
 			txsPerSlotCount.Set(float64(len(txs)))
 		}
 	}
+	if b.Version() >= version.Deneb {
+		kzgs, err := b.Body().BlobKzgCommitments()
+		if err != nil {
+			log.WithError(err).Error("Failed to get blob KZG commitments")
+		} else if len(kzgs) > 0 {
+			log = log.WithField("blobCommitmentCount", len(kzgs))
+		}
+	}
 	log.Info("Finished applying state transition")
 	return nil
 }
@@ -73,7 +81,7 @@ func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte
 	level := log.Logger.GetLevel()
 	if level >= logrus.DebugLevel {
 		parentRoot := block.ParentRoot()
-		log.WithFields(logrus.Fields{
+		lf := logrus.Fields{
 			"slot":                      block.Slot(),
 			"slotInEpoch":               block.Slot() % params.BeaconConfig().SlotsPerEpoch,
 			"block":                     fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
@@ -87,7 +95,8 @@ func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte
 			"sinceSlotStartTime":        prysmTime.Now().Sub(startTime),
 			"chainServiceProcessedTime": prysmTime.Now().Sub(receivedTime),
 			"deposits":                  len(block.Body().Deposits()),
-		}).Debug("Synced new block")
+		}
+		log.WithFields(lf).Debug("Synced new block")
 	} else {
 		log.WithFields(logrus.Fields{
 			"slot":           block.Slot(),
@@ -120,7 +129,7 @@ func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
 	fields := logrus.Fields{
 		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
 		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash())),
-		"blockNumber": payload.BlockNumber,
+		"blockNumber": payload.BlockNumber(),
 		"gasUtilized": fmt.Sprintf("%.2f", gasUtilized),
 	}
 	if block.Version() >= version.Capella {

beacon-chain/blockchain/metrics.go

@@ -172,11 +172,15 @@ var (
 	})
 	onBlockProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
 		Name: "on_block_processing_milliseconds",
-		Help: "Total time in milliseconds to complete a call to onBlock()",
+		Help: "Total time in milliseconds to complete a call to postBlockProcess()",
 	})
 	stateTransitionProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
 		Name: "state_transition_processing_milliseconds",
-		Help: "Total time to call a state transition in onBlock()",
+		Help: "Total time to call a state transition in validateStateTransition()",
+	})
+	chainServiceProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
+		Name: "chain_service_processing_milliseconds",
+		Help: "Total time to call a chain service in ReceiveBlock()",
 	})
 	processAttsElapsedTime = promauto.NewHistogram(
 		prometheus.HistogramOpts{
@@ -246,40 +250,45 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	slashingBalance := uint64(0)
 	slashingEffectiveBalance := uint64(0)
 
-	for i, validator := range postState.Validators() {
+	for i := 0; i < postState.NumValidators(); i++ {
+		validator, err := postState.ValidatorAtIndexReadOnly(primitives.ValidatorIndex(i))
+		if err != nil {
+			log.WithError(err).Error("Could not load validator")
+			continue
+		}
 		bal, err := postState.BalanceAtIndex(primitives.ValidatorIndex(i))
 		if err != nil {
 			log.WithError(err).Error("Could not load validator balance")
 			continue
 		}
-		if validator.Slashed {
-			if currentEpoch < validator.ExitEpoch {
+		if validator.Slashed() {
+			if currentEpoch < validator.ExitEpoch() {
 				slashingInstances++
 				slashingBalance += bal
-				slashingEffectiveBalance += validator.EffectiveBalance
+				slashingEffectiveBalance += validator.EffectiveBalance()
 			} else {
 				slashedInstances++
 			}
 			continue
 		}
-		if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
-			if currentEpoch < validator.ExitEpoch {
+		if validator.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
+			if currentEpoch < validator.ExitEpoch() {
 				exitingInstances++
 				exitingBalance += bal
-				exitingEffectiveBalance += validator.EffectiveBalance
+				exitingEffectiveBalance += validator.EffectiveBalance()
 			} else {
 				exitedInstances++
 			}
 			continue
 		}
-		if currentEpoch < validator.ActivationEpoch {
+		if currentEpoch < validator.ActivationEpoch() {
 			pendingInstances++
 			pendingBalance += bal
 			continue
 		}
 		activeInstances++
 		activeBalance += bal
-		activeEffectiveBalance += validator.EffectiveBalance
+		activeEffectiveBalance += validator.EffectiveBalance()
 	}
 	activeInstances += exitingInstances + slashingInstances
 	activeBalance += exitingBalance + slashingBalance

beacon-chain/blockchain/options.go

@@ -3,7 +3,6 @@ package blockchain
 import (
 	"github.com/prysmaticlabs/prysm/v4/async/event"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache/depositcache"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/execution"
@@ -62,7 +61,7 @@ func WithExecutionEngineCaller(c execution.EngineCaller) Option {
 }
 
 // WithDepositCache for deposit lifecycle after chain inclusion.
-func WithDepositCache(c *depositcache.DepositCache) Option {
+func WithDepositCache(c cache.DepositCache) Option {
 	return func(s *Service) error {
 		s.cfg.DepositCache = c
 		return nil
@@ -172,3 +171,10 @@ func WithClockSynchronizer(gs *startup.ClockSynchronizer) Option {
 		return nil
 	}
 }
+
+func WithSyncComplete(c chan struct{}) Option {
+	return func(s *Service) error {
+		s.syncComplete = c
+		return nil
+	}
+}

beacon-chain/blockchain/process_block.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
@@ -15,6 +16,7 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v4/config/features"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
@@ -22,7 +24,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/monitoring/tracing"
-	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
@@ -40,59 +41,11 @@ const depositDeadline = 20 * time.Second
 // This defines size of the upper bound for initial sync block cache.
 var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 
-// onBlock is called when a gossip block is received. It runs regular state transition on the block.
-// The block's signing root should be computed before calling this method to avoid redundant
-// computation in this method and methods it calls into.
-//
-// Spec pseudocode definition:
-//
-//	def on_block(store: Store, signed_block: ReadOnlySignedBeaconBlock) -> None:
-//	 block = signed_block.message
-//	 # Parent block must be known
-//	 assert block.parent_root in store.block_states
-//	 # Make a copy of the state to avoid mutability issues
-//	 pre_state = copy(store.block_states[block.parent_root])
-//	 # Blocks cannot be in the future. If they are, their consideration must be delayed until the are in the past.
-//	 assert get_current_slot(store) >= block.slot
-//
-//	 # Check that block is later than the finalized epoch slot (optimization to reduce calls to get_ancestor)
-//	 finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
-//	 assert block.slot > finalized_slot
-//	 # Check block is a descendant of the finalized block at the checkpoint finalized slot
-//	 assert get_ancestor(store, block.parent_root, finalized_slot) == store.finalized_checkpoint.root
-//
-//	 # Check the block is valid and compute the post-state
-//	 state = pre_state.copy()
-//	 state_transition(state, signed_block, True)
-//	 # Add new block to the store
-//	 store.blocks[hash_tree_root(block)] = block
-//	 # Add new state for this block to the store
-//	 store.block_states[hash_tree_root(block)] = state
-//
-//	 # Update justified checkpoint
-//	 if state.current_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
-//	     if state.current_justified_checkpoint.epoch > store.best_justified_checkpoint.epoch:
-//	         store.best_justified_checkpoint = state.current_justified_checkpoint
-//	     if should_update_justified_checkpoint(store, state.current_justified_checkpoint):
-//	         store.justified_checkpoint = state.current_justified_checkpoint
-//
-//	 # Update finalized checkpoint
-//	 if state.finalized_checkpoint.epoch > store.finalized_checkpoint.epoch:
-//	     store.finalized_checkpoint = state.finalized_checkpoint
-//
-//	     # Potentially update justified if different from store
-//	     if store.justified_checkpoint != state.current_justified_checkpoint:
-//	         # Update justified if new justified is later than store justified
-//	         if state.current_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
-//	             store.justified_checkpoint = state.current_justified_checkpoint
-//	             return
-//
-//	         # Update justified if store justified is not in chain with finalized checkpoint
-//	         finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
-//	         ancestor_at_finalized_slot = get_ancestor(store, store.justified_checkpoint.root, finalized_slot)
-//	         if ancestor_at_finalized_slot != store.finalized_checkpoint.root:
-//	             store.justified_checkpoint = state.current_justified_checkpoint
-func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) error {
+// postBlockProcess is called when a gossip block is received. This function performs
+// several duties most importantly informing the engine if head was updated,
+// saving the new head information to the blockchain package and
+// handling attestations, slashings and similar included in the block.
+func (s *Service) postBlockProcess(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, postState state.BeaconState, isValidPayload bool) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlock")
 	defer span.End()
 	if err := consensusblocks.BeaconBlockIsNil(signed); err != nil {
@@ -101,52 +54,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	startTime := time.Now()
 	b := signed.Block()
 
-	preState, err := s.getBlockPreState(ctx, b)
-	if err != nil {
-		return err
-	}
-
-	// Verify that the parent block is in forkchoice
-	if !s.cfg.ForkChoiceStore.HasNode(b.ParentRoot()) {
-		return ErrNotDescendantOfFinalized
-	}
-
-	// Save current justified and finalized epochs for future use.
-	currStoreJustifiedEpoch := s.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch
-	currStoreFinalizedEpoch := s.cfg.ForkChoiceStore.FinalizedCheckpoint().Epoch
-	preStateFinalizedEpoch := preState.FinalizedCheckpoint().Epoch
-	preStateJustifiedEpoch := preState.CurrentJustifiedCheckpoint().Epoch
-
-	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
-	if err != nil {
-		return err
-	}
-	stateTransitionStartTime := time.Now()
-	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
-	if err != nil {
-		return invalidBlock{error: err}
-	}
-	stateTransitionProcessingTime.Observe(float64(time.Since(stateTransitionStartTime).Milliseconds()))
-
-	postStateVersion, postStateHeader, err := getStateVersionAndPayload(postState)
-	if err != nil {
-		return err
-	}
-	isValidPayload, err := s.notifyNewPayload(ctx, postStateVersion, postStateHeader, signed)
-	if err != nil {
-		return errors.Wrap(err, "could not validate new payload")
-	}
-	if isValidPayload {
-		if err := s.validateMergeTransitionBlock(ctx, preStateVersion, preStateHeader, signed); err != nil {
-			return err
-		}
-	}
-
-	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState); err != nil {
-		return err
-	}
-
-	if err := s.insertBlockToForkchoiceStore(ctx, signed.Block(), blockRoot, postState); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, postState, blockRoot); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", signed.Block().Slot())
 	}
 	if err := s.handleBlockAttestations(ctx, signed.Block(), postState); err != nil {
@@ -160,34 +68,6 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 		}
 	}
 
-	// If slasher is configured, forward the attestations in the block via
-	// an event feed for processing.
-	if features.Get().EnableSlasher {
-		// Feed the indexed attestation to slasher if enabled. This action
-		// is done in the background to avoid adding more load to this critical code path.
-		go func() {
-			// Using a different context to prevent timeouts as this operation can be expensive
-			// and we want to avoid affecting the 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)
-				if err != nil {
-					log.WithError(err).Error("Could not get attestation committee")
-					tracing.AnnotateError(span, err)
-					return
-				}
-				indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
-				if err != nil {
-					log.WithError(err).Error("Could not convert to indexed attestation")
-					tracing.AnnotateError(span, err)
-					return
-				}
-				s.cfg.SlasherAttestationsFeed.Send(indexedAtt)
-			}
-		}()
-	}
-
-	justified := s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	start := time.Now()
 	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx)
 	if err != nil {
@@ -208,18 +88,6 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 			"headRoot":       fmt.Sprintf("%#x", headRoot),
 			"headWeight":     headWeight,
 		}).Debug("Head block is not the received block")
-	} else {
-		// Updating next slot state cache can happen in the background. It shouldn't block rest of the process.
-		go func() {
-			// Use a custom deadline here, since this method runs asynchronously.
-			// We ignore the parent method's context and instead create a new one
-			// with a custom deadline, therefore using the background context instead.
-			slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
-			defer cancel()
-			if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
-				log.WithError(err).Debug("could not update next slot state cache")
-			}
-		}()
 	}
 	newBlockHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
 
@@ -229,6 +97,12 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 		return err
 	}
 
+	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(blockRoot)
+	if err != nil {
+		log.WithError(err).Debug("Could not check if block is optimistic")
+		optimistic = true
+	}
+
 	// Send notification of the processed block to the state feed.
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
@@ -237,56 +111,34 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 			BlockRoot:   blockRoot,
 			SignedBlock: signed,
 			Verified:    true,
+			Optimistic:  optimistic,
 		},
 	})
 
-	// Save justified check point to db.
-	postStateJustifiedEpoch := postState.CurrentJustifiedCheckpoint().Epoch
-	if justified.Epoch > currStoreJustifiedEpoch || (justified.Epoch == postStateJustifiedEpoch && justified.Epoch > preStateJustifiedEpoch) {
-		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{
-			Epoch: justified.Epoch, Root: justified.Root[:],
-		}); err != nil {
-			return err
-		}
-	}
-
-	// Save finalized check point to db and more.
-	postStateFinalizedEpoch := postState.FinalizedCheckpoint().Epoch
-	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
-	if finalized.Epoch > currStoreFinalizedEpoch || (finalized.Epoch == postStateFinalizedEpoch && finalized.Epoch > preStateFinalizedEpoch) {
-		if err := s.updateFinalized(ctx, &ethpb.Checkpoint{Epoch: finalized.Epoch, Root: finalized.Root[:]}); err != nil {
-			return err
-		}
-		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(finalized.Root)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
-		}
-		go func() {
-			// 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{
-					Epoch:               postState.FinalizedCheckpoint().Epoch,
-					Block:               postState.FinalizedCheckpoint().Root,
-					State:               stateRoot[:],
-					ExecutionOptimistic: isOptimistic,
-				},
-			})
-
-			// Use a custom deadline here, since this method runs asynchronously.
-			// We ignore the parent method's context and instead create a new one
-			// with a custom deadline, therefore using the background context instead.
-			depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
-			defer cancel()
-			if err := s.insertFinalizedDeposits(depCtx, finalized.Root); err != nil {
-				log.WithError(err).Error("Could not insert finalized deposits.")
-			}
-		}()
-	}
 	defer reportAttestationInclusion(b)
-	if err := s.handleEpochBoundary(ctx, postState); err != nil {
-		return err
+	if headRoot == blockRoot {
+		// Updating next slot state cache can happen in the background
+		// except in the epoch boundary in which case we lock to handle
+		// the shuffling and proposer caches updates.
+		// We handle these caches only on canonical
+		// blocks, otherwise this will be handled by lateBlockTasks
+		slot := postState.Slot()
+		if slots.IsEpochEnd(slot) {
+			if err := transition.UpdateNextSlotCache(ctx, blockRoot[:], postState); err != nil {
+				return errors.Wrap(err, "could not update next slot state cache")
+			}
+			if err := s.handleEpochBoundary(ctx, slot, postState, blockRoot[:]); err != nil {
+				return errors.Wrap(err, "could not handle epoch boundary")
+			}
+		} else {
+			go func() {
+				slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+				defer cancel()
+				if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
+					log.WithError(err).Error("could not update next slot state cache")
+				}
+			}()
+		}
 	}
 	onBlockProcessingTime.Observe(float64(time.Since(startTime).Milliseconds()))
 	return nil
@@ -310,19 +162,14 @@ func getStateVersionAndPayload(st state.BeaconState) (int, interfaces.ExecutionD
 	return preStateVersion, preStateHeader, nil
 }
 
-func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySignedBeaconBlock,
-	blockRoots [][32]byte) error {
+func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlock) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()
 
-	if len(blks) == 0 || len(blockRoots) == 0 {
+	if len(blks) == 0 {
 		return errors.New("no blocks provided")
 	}
 
-	if len(blks) != len(blockRoots) {
-		return errWrongBlockCount
-	}
-
 	if err := consensusblocks.BeaconBlockIsNil(blks[0]); err != nil {
 		return invalidBlock{error: err}
 	}
@@ -372,7 +219,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 		}
 		// Save potential boundary states.
 		if slots.IsEpochStart(preState.Slot()) {
-			boundaries[blockRoots[i]] = preState.Copy()
+			boundaries[b.Root()] = preState.Copy()
 		}
 		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
 		fCheckpoints[i] = preState.FinalizedCheckpoint()
@@ -405,11 +252,12 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, len(blks))
 	var isValidPayload bool
 	for i, b := range blks {
+		root := b.Root()
 		isValidPayload, err = s.notifyNewPayload(ctx,
 			postVersionAndHeaders[i].version,
 			postVersionAndHeaders[i].header, b)
 		if err != nil {
-			return err
+			return s.handleInvalidExecutionError(ctx, err, root, b.Block().ParentRoot())
 		}
 		if isValidPayload {
 			if err := s.validateMergeTransitionBlock(ctx, preVersionAndHeaders[i].version,
@@ -417,17 +265,20 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 				return err
 			}
 		}
+		if err := s.databaseDACheck(ctx, b); err != nil {
+			return errors.Wrap(err, "could not validate blob data availability")
+		}
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
 		pendingNodes[len(blks)-i-1] = args
-		if err := s.saveInitSyncBlock(ctx, blockRoots[i], b); err != nil {
+		if err := s.saveInitSyncBlock(ctx, root, b); err != nil {
 			tracing.AnnotateError(span, err)
 			return err
 		}
 		if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
 			Slot: b.Block().Slot(),
-			Root: blockRoots[i][:],
+			Root: root[:],
 		}); err != nil {
 			tracing.AnnotateError(span, err)
 			return err
@@ -451,8 +302,9 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 			return err
 		}
 	}
+	lastB := blks[len(blks)-1]
+	lastBR := lastB.Root()
 	// Also saves the last post state which to be used as pre state for the next batch.
-	lastBR := blockRoots[len(blks)-1]
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
 		return err
 	}
@@ -470,7 +322,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
-	lastB := blks[len(blks)-1]
 	arg := &notifyForkchoiceUpdateArg{
 		headState: preState,
 		headRoot:  lastBR,
@@ -479,70 +330,78 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 	if _, err := s.notifyForkchoiceUpdate(ctx, arg); err != nil {
 		return err
 	}
-	return s.saveHeadNoDB(ctx, lastB, lastBR, preState)
+	return s.saveHeadNoDB(ctx, lastB, lastBR, preState, !isValidPayload)
 }
 
-// Epoch boundary bookkeeping such as logging epoch summaries.
-func (s *Service) handleEpochBoundary(ctx context.Context, postState state.BeaconState) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.handleEpochBoundary")
-	defer span.End()
-
-	var err error
-	if postState.Slot()+1 == s.nextEpochBoundarySlot {
-		copied := postState.Copy()
-		copied, err := transition.ProcessSlots(ctx, copied, copied.Slot()+1)
-		if err != nil {
-			return err
-		}
-		// Update caches for the next epoch at epoch boundary slot - 1.
-		if err := helpers.UpdateCommitteeCache(ctx, copied, coreTime.CurrentEpoch(copied)); err != nil {
-			return err
-		}
-		if err := helpers.UpdateProposerIndicesInCache(ctx, copied); err != nil {
-			return err
-		}
-	} else if postState.Slot() >= s.nextEpochBoundarySlot {
-		s.nextEpochBoundarySlot, err = slots.EpochStart(coreTime.NextEpoch(postState))
-		if err != nil {
-			return err
-		}
-
-		// Update caches at epoch boundary slot.
-		// The following updates have shortcut to return nil cheaply if fulfilled during boundary slot - 1.
-		if err := helpers.UpdateCommitteeCache(ctx, postState, coreTime.CurrentEpoch(postState)); err != nil {
-			return err
-		}
-		if err := helpers.UpdateProposerIndicesInCache(ctx, postState); err != nil {
-			return err
-		}
-
-		headSt, err := s.HeadState(ctx)
-		if err != nil {
-			return err
-		}
-		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
-			return err
-		}
+func commitmentsToCheck(b consensusblocks.ROBlock, current primitives.Slot) [][]byte {
+	if b.Version() < version.Deneb {
+		return nil
 	}
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
+	if !params.WithinDAPeriod(slots.ToEpoch(b.Block().Slot()), slots.ToEpoch(current)) {
+		return nil
+	}
+	kzgCommitments, err := b.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return nil
+	}
+	return kzgCommitments
+}
 
+func (s *Service) databaseDACheck(ctx context.Context, b consensusblocks.ROBlock) error {
+	commitments := commitmentsToCheck(b, s.CurrentSlot())
+	if len(commitments) == 0 {
+		return nil
+	}
+	sidecars, err := s.cfg.BeaconDB.BlobSidecarsByRoot(ctx, b.Root())
+	if err != nil {
+		return errors.Wrap(err, "could not get blob sidecars")
+	}
+	return kzg.IsDataAvailable(commitments, sidecars)
+}
+
+func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.BeaconState) error {
+	e := coreTime.CurrentEpoch(st)
+	if err := helpers.UpdateCommitteeCache(ctx, st, e); err != nil {
+		return errors.Wrap(err, "could not update committee cache")
+	}
+	if err := helpers.UpdateProposerIndicesInCache(ctx, st, e); err != nil {
+		return errors.Wrap(err, "could not update proposer index cache")
+	}
+	go func() {
+		// Use a custom deadline here, since this method runs asynchronously.
+		// We ignore the parent method's context and instead create a new one
+		// with a custom deadline, therefore using the background context instead.
+		slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+		defer cancel()
+		if err := helpers.UpdateCommitteeCache(slotCtx, st, e+1); err != nil {
+			log.WithError(err).Warn("Could not update committee cache")
+		}
+		if err := helpers.UpdateProposerIndicesInCache(slotCtx, st, e+1); err != nil {
+			log.WithError(err).Warn("Failed to cache next epoch proposers")
+		}
+	}()
 	return nil
 }
 
-// This feeds in the block to fork choice store. It's allows fork choice store
-// to gain information on the most current chain.
-func (s *Service) insertBlockToForkchoiceStore(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock, root [32]byte, st state.BeaconState) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.insertBlockToForkchoiceStore")
+// Epoch boundary tasks: it copies the headState and updates the epoch boundary
+// caches.
+func (s *Service) handleEpochBoundary(ctx context.Context, slot primitives.Slot, headState state.BeaconState, blockRoot []byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.handleEpochBoundary")
 	defer span.End()
-
-	if !s.cfg.ForkChoiceStore.HasNode(blk.ParentRoot()) {
-		fCheckpoint := st.FinalizedCheckpoint()
-		jCheckpoint := st.CurrentJustifiedCheckpoint()
-		if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
-			return err
-		}
+	// return early if we are advancing to a past epoch
+	if slot < headState.Slot() {
+		return nil
 	}
-
-	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
+	if !slots.IsEpochEnd(slot) {
+		return nil
+	}
+	copied := headState.Copy()
+	copied, err := transition.ProcessSlotsUsingNextSlotCache(ctx, copied, blockRoot, slot+1)
+	if err != nil {
+		return err
+	}
+	return s.updateEpochBoundaryCaches(ctx, copied)
 }
 
 // This feeds in the attestations included in the block to fork choice store. It's allows fork choice store
@@ -652,18 +511,17 @@ func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion
 // This routine checks if there is a cached proposer payload ID available for the next slot proposer.
 // If there is not, it will call forkchoice updated with the correct payload attribute then cache the payload ID.
 func (s *Service) runLateBlockTasks() {
-	_, err := s.clockWaiter.WaitForClock(s.ctx)
-	if err != nil {
-		log.WithError(err).Error("runLateBlockTasks encountered an error waiting for initialization")
+	if err := s.waitForSync(); err != nil {
+		log.WithError(err).Error("failed to wait for initial sync")
 		return
 	}
+
 	attThreshold := params.BeaconConfig().SecondsPerSlot / 3
 	ticker := slots.NewSlotTickerWithOffset(s.genesisTime, time.Duration(attThreshold)*time.Second, params.BeaconConfig().SecondsPerSlot)
 	for {
 		select {
 		case <-ticker.C():
 			s.lateBlockTasks(s.ctx)
-
 		case <-s.ctx.Done():
 			log.Debug("Context closed, exiting routine")
 			return
@@ -671,11 +529,85 @@ func (s *Service) runLateBlockTasks() {
 	}
 }
 
+func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
+	if signed.Version() < version.Deneb {
+		return nil
+	}
+	block := signed.Block()
+	if block == nil {
+		return errors.New("invalid nil beacon block")
+	}
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
+	if !params.WithinDAPeriod(slots.ToEpoch(block.Slot()), slots.ToEpoch(s.CurrentSlot())) {
+		return nil
+	}
+
+	body := block.Body()
+	if body == nil {
+		return errors.New("invalid nil beacon block body")
+	}
+	kzgCommitments, err := body.BlobKzgCommitments()
+	if err != nil {
+		return errors.Wrap(err, "could not get KZG commitments")
+	}
+	existingBlobs := len(kzgCommitments)
+	if existingBlobs == 0 {
+		return nil
+	}
+
+	// Read first from db in case we have the blobs
+	s.blobNotifier.Lock()
+	var nc *blobNotifierChan
+	var ok bool
+	nc, ok = s.blobNotifier.chanForRoot[root]
+	sidecars, err := s.cfg.BeaconDB.BlobSidecarsByRoot(ctx, root)
+	if err == nil {
+		if len(sidecars) >= existingBlobs {
+			delete(s.blobNotifier.chanForRoot, root)
+			s.blobNotifier.Unlock()
+			return kzg.IsDataAvailable(kzgCommitments, sidecars)
+		}
+	}
+	// Create the channel if it didn't exist already the index map will be
+	// created later anyway
+	if !ok {
+		nc = &blobNotifierChan{channel: make(chan struct{}, fieldparams.MaxBlobsPerBlock)}
+		s.blobNotifier.chanForRoot[root] = nc
+	}
+	// We have more commitments in the block than blobs in database
+	// We sync the channel indices with the sidecars
+	nc.indices = make(map[uint64]struct{})
+	for _, sidecar := range sidecars {
+		nc.indices[sidecar.Index] = struct{}{}
+	}
+	s.blobNotifier.Unlock()
+	channelWrites := len(sidecars)
+	for {
+		select {
+		case <-nc.channel:
+			channelWrites++
+			if channelWrites == existingBlobs {
+				s.blobNotifier.Lock()
+				delete(s.blobNotifier.chanForRoot, root)
+				s.blobNotifier.Unlock()
+				sidecars, err := s.cfg.BeaconDB.BlobSidecarsByRoot(ctx, root)
+				if err != nil {
+					return errors.Wrap(err, "could not get blob sidecars")
+				}
+				return kzg.IsDataAvailable(kzgCommitments, sidecars)
+			}
+		case <-ctx.Done():
+			return errors.Wrap(ctx.Err(), "context deadline waiting for blob sidecars")
+		}
+	}
+}
+
 // lateBlockTasks  is called 4 seconds into the slot and performs tasks
 // related to late blocks. It emits a MissedSlot state feed event.
 // It calls FCU and sets the right attributes if we are proposing next slot
-// it also updates the next slot cache to deal with skipped slots.
+// it also updates the next slot cache and the proposer index cache to deal with skipped slots.
 func (s *Service) lateBlockTasks(ctx context.Context) {
+	currentSlot := s.CurrentSlot()
 	if s.CurrentSlot() == s.HeadSlot() {
 		return
 	}
@@ -683,8 +615,10 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 		Type: statefeed.MissedSlot,
 	})
 
+	s.headLock.RLock()
 	headRoot := s.headRoot()
 	headState := s.headState(ctx)
+	s.headLock.RUnlock()
 	lastRoot, lastState := transition.LastCachedState()
 	if lastState == nil {
 		lastRoot, lastState = headRoot[:], headState
@@ -695,7 +629,9 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
 		log.WithError(err).Debug("could not update next slot state cache")
 	}
-
+	if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
+		log.WithError(err).Error("lateBlockTasks: could not update epoch boundary caches")
+	}
 	// Head root should be empty when retrieving proposer index for the next slot.
 	_, id, has := s.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(s.CurrentSlot()+1, [32]byte{} /* head root */)
 	// There exists proposer for next slot, but we haven't called fcu w/ payload attribute yet.
@@ -720,3 +656,20 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 		log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")
 	}
 }
+
+// waitForSync blocks until the node is synced to the head.
+func (s *Service) waitForSync() error {
+	select {
+	case <-s.syncComplete:
+		return nil
+	case <-s.ctx.Done():
+		return errors.New("context closed, exiting goroutine")
+	}
+}
+
+func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot [32]byte, parentRoot [32]byte) error {
+	if IsInvalidBlock(err) && InvalidBlockLVH(err) != [32]byte{} {
+		return s.pruneInvalidBlock(ctx, blockRoot, parentRoot, InvalidBlockLVH(err))
+	}
+	return err
+}

beacon-chain/blockchain/process_block_helpers.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
@@ -14,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v4/math"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/time"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"go.opencensus.io/trace"
 )
@@ -209,35 +211,45 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 	return s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes)
 }
 
-// inserts finalized deposits into our finalized deposit trie.
-func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) error {
+// inserts finalized deposits into our finalized deposit trie, needs to be
+// called in the background
+func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.insertFinalizedDeposits")
 	defer span.End()
+	startTime := time.Now()
 
 	// Update deposit cache.
 	finalizedState, err := s.cfg.StateGen.StateByRoot(ctx, fRoot)
 	if err != nil {
-		return errors.Wrap(err, "could not fetch finalized state")
+		log.WithError(err).Error("could not fetch finalized state")
+		return
 	}
 	// We update the cache up to the last deposit index in the finalized block's state.
 	// We can be confident that these deposits will be included in some block
 	// because the Eth1 follow distance makes such long-range reorgs extremely unlikely.
 	eth1DepositIndex, err := mathutil.Int(finalizedState.Eth1DepositIndex())
 	if err != nil {
-		return errors.Wrap(err, "could not cast eth1 deposit index")
+		log.WithError(err).Error("could not cast eth1 deposit index")
+		return
 	}
 	// The deposit index in the state is always the index of the next deposit
 	// to be included(rather than the last one to be processed). This was most likely
 	// done as the state cannot represent signed integers.
-	eth1DepositIndex -= 1
-	if err = s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(eth1DepositIndex)); err != nil {
-		return err
+	finalizedEth1DepIdx := eth1DepositIndex - 1
+	if err = s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(finalizedEth1DepIdx), common.Hash(finalizedState.Eth1Data().BlockHash),
+		0 /* Setting a zero value as we have no access to block height */); err != nil {
+		log.WithError(err).Error("could not insert finalized deposits")
+		return
 	}
 	// Deposit proofs are only used during state transition and can be safely removed to save space.
-	if err = s.cfg.DepositCache.PruneProofs(ctx, int64(eth1DepositIndex)); err != nil {
-		return errors.Wrap(err, "could not prune deposit proofs")
+	if err = s.cfg.DepositCache.PruneProofs(ctx, int64(finalizedEth1DepIdx)); err != nil {
+		log.WithError(err).Error("could not prune deposit proofs")
 	}
-	return nil
+	// Prune deposits which have already been finalized, the below method prunes all pending deposits (non-inclusive) up
+	// to the provided eth1 deposit index.
+	s.cfg.DepositCache.PrunePendingDeposits(ctx, int64(eth1DepositIndex)) // lint:ignore uintcast -- Deposit index should not exceed int64 in your lifetime.
+
+	log.WithField("duration", time.Since(startTime).String()).Debugf("Finalized deposit insertion completed at index %d", finalizedEth1DepIdx)
 }
 
 // This ensures that the input root defaults to using genesis root instead of zero hashes. This is needed for handling

beacon-chain/blockchain/process_block_test.go

@@ -41,103 +41,6 @@ import (
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
-func TestStore_OnBlock(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx, beaconDB, fcs := tr.ctx, tr.db, tr.fcs
-
-	var genesisStateRoot [32]byte
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	util.SaveBlock(t, ctx, beaconDB, genesis)
-	validGenesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	ojc := &ethpb.Checkpoint{}
-	stfcs, root, err := prepareForkchoiceState(ctx, 0, validGenesisRoot, [32]byte{}, [32]byte{}, ojc, ojc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, stfcs, root))
-	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
-	require.NoError(t, err)
-	random := util.NewBeaconBlock()
-	random.Block.Slot = 1
-	random.Block.ParentRoot = validGenesisRoot[:]
-	util.SaveBlock(t, ctx, beaconDB, random)
-	randomParentRoot, err := random.Block.HashTreeRoot()
-	assert.NoError(t, err)
-
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), randomParentRoot))
-	randomParentRoot2 := roots[1]
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), bytesutil.ToBytes32(randomParentRoot2)))
-	stfcs, root, err = prepareForkchoiceState(ctx, 2, bytesutil.ToBytes32(randomParentRoot2),
-		validGenesisRoot, [32]byte{'r'}, ojc, ojc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, stfcs, root))
-
-	tests := []struct {
-		name          string
-		blk           *ethpb.SignedBeaconBlock
-		s             state.BeaconState
-		time          uint64
-		wantErrString string
-	}{
-		{
-			name:          "parent block root does not have a state",
-			blk:           util.NewBeaconBlock(),
-			s:             st.Copy(),
-			wantErrString: "could not reconstruct parent state",
-		},
-		{
-			name: "block is from the future",
-			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.ParentRoot = randomParentRoot2
-				b.Block.Slot = params.BeaconConfig().FarFutureSlot
-				return b
-			}(),
-			s:             st.Copy(),
-			wantErrString: "is in the far distant future",
-		},
-		{
-			name: "could not get finalized block",
-			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.ParentRoot = randomParentRoot[:]
-				b.Block.Slot = 2
-				return b
-			}(),
-			s:             st.Copy(),
-			wantErrString: "not descendant of finalized checkpoint",
-		},
-		{
-			name: "same slot as finalized block",
-			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.Slot = 0
-				b.Block.ParentRoot = randomParentRoot2
-				return b
-			}(),
-			s:             st.Copy(),
-			wantErrString: "block is equal or earlier than finalized block, slot 0 < slot 0",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			fRoot := bytesutil.ToBytes32(roots[0])
-			require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: fRoot}))
-			root, err := tt.blk.Block.HashTreeRoot()
-			assert.NoError(t, err)
-			wsb, err := consensusblocks.NewSignedBeaconBlock(tt.blk)
-			require.NoError(t, err)
-			err = service.onBlock(ctx, wsb, root)
-			assert.ErrorContains(t, tt.wantErrString, err)
-		})
-	}
-}
-
 func TestStore_OnBlockBatch(t *testing.T) {
 	service, tr := minimalTestService(t)
 	ctx := tr.ctx
@@ -146,8 +49,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	require.NoError(t, service.saveGenesisData(ctx, st))
 	bState := st.Copy()
 
-	var blks []interfaces.ReadOnlySignedBeaconBlock
-	var blkRoots [][32]byte
+	var blks []consensusblocks.ROBlock
 	for i := 0; i < 97; i++ {
 		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
 		require.NoError(t, err)
@@ -160,16 +62,15 @@ func TestStore_OnBlockBatch(t *testing.T) {
 		require.NoError(t, service.saveInitSyncBlock(ctx, root, wsb))
 		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
-		blks = append(blks, wsb)
-		blkRoots = append(blkRoots, root)
+		rwsb, err := consensusblocks.NewROBlock(wsb)
+		require.NoError(t, err)
+		blks = append(blks, rwsb)
 	}
-	err := service.onBlockBatch(ctx, blks, blkRoots[1:])
-	require.ErrorIs(t, errWrongBlockCount, err)
-	err = service.onBlockBatch(ctx, blks, blkRoots)
+	err := service.onBlockBatch(ctx, blks)
 	require.NoError(t, err)
 	jcp := service.CurrentJustifiedCheckpt()
 	jroot := bytesutil.ToBytes32(jcp.Root)
-	require.Equal(t, blkRoots[63], jroot)
+	require.Equal(t, blks[63].Root(), jroot)
 	require.Equal(t, primitives.Epoch(2), service.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch)
 }
 
@@ -181,8 +82,7 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 	require.NoError(t, service.saveGenesisData(ctx, st))
 	bState := st.Copy()
 
-	var blks []interfaces.ReadOnlySignedBeaconBlock
-	var blkRoots [][32]byte
+	var blks []consensusblocks.ROBlock
 	blkCount := 4
 	for i := 0; i <= blkCount; i++ {
 		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
@@ -191,13 +91,12 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 		require.NoError(t, err)
 		bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
 		require.NoError(t, err)
-		root, err := b.Block.HashTreeRoot()
+		rwsb, err := consensusblocks.NewROBlock(wsb)
 		require.NoError(t, err)
-		require.NoError(t, service.saveInitSyncBlock(ctx, root, wsb))
-		blks = append(blks, wsb)
-		blkRoots = append(blkRoots, root)
+		require.NoError(t, service.saveInitSyncBlock(ctx, rwsb.Root(), wsb))
+		blks = append(blks, rwsb)
 	}
-	require.NoError(t, service.onBlockBatch(ctx, blks, blkRoots))
+	require.NoError(t, service.onBlockBatch(ctx, blks))
 }
 
 func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
@@ -636,8 +535,7 @@ func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 1024)
 	service.head = &head{state: s}
 	require.NoError(t, s.SetSlot(2*params.BeaconConfig().SlotsPerEpoch))
-	require.NoError(t, service.handleEpochBoundary(ctx, s))
-	require.Equal(t, 3*params.BeaconConfig().SlotsPerEpoch, service.nextEpochBoundarySlot)
+	require.NoError(t, service.handleEpochBoundary(ctx, s.Slot(), s, []byte{}))
 }
 
 func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
@@ -657,7 +555,20 @@ func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
 		wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
 		require.NoError(t, err)
 		require.NoError(t, fcs.NewSlot(ctx, i))
-		require.NoError(t, service.onBlock(ctx, wsb, r))
+		// Save current justified and finalized epochs for future use.
+		currStoreJustifiedEpoch := service.CurrentJustifiedCheckpt().Epoch
+		currStoreFinalizedEpoch := service.FinalizedCheckpt().Epoch
+
+		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, r, wsb, postState))
+		require.NoError(t, service.postBlockProcess(ctx, wsb, r, postState, true))
+		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
+		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
+		require.NoError(t, err)
+
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -692,7 +603,20 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		require.NoError(t, err)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, r))
+		// Save current justified and finalized epochs for future use.
+		currStoreJustifiedEpoch := service.CurrentJustifiedCheckpt().Epoch
+		currStoreFinalizedEpoch := service.FinalizedCheckpt().Epoch
+
+		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, r, wsb, postState))
+		require.NoError(t, service.postBlockProcess(ctx, wsb, r, postState, true))
+		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
+		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
+		require.NoError(t, err)
+
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -714,8 +638,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 
 func TestOnBlock_NilBlock(t *testing.T) {
 	service, tr := minimalTestService(t)
-
-	err := service.onBlock(tr.ctx, nil, [32]byte{})
+	err := service.postBlockProcess(tr.ctx, nil, [32]byte{}, nil, true)
 	require.Equal(t, true, IsInvalidBlock(err))
 }
 
@@ -729,11 +652,11 @@ func TestOnBlock_InvalidSignature(t *testing.T) {
 	blk, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 1)
 	require.NoError(t, err)
 	blk.Signature = []byte{'a'} // Mutate the signature.
-	r, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
 	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, r)
+	preState, err := service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	_, err = service.validateStateTransition(ctx, preState, wsb)
 	require.Equal(t, true, IsInvalidBlock(err))
 }
 
@@ -757,7 +680,13 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		require.NoError(t, err)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, r))
+
+		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, r, wsb, postState))
+		require.NoError(t, service.postBlockProcess(ctx, wsb, r, postState, false))
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -770,7 +699,7 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 	gs, _ := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
 	gs = gs.Copy()
-	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10}))
+	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10, BlockHash: make([]byte, 32)}))
 	assert.NoError(t, gs.SetEth1DepositIndex(8))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
 	var zeroSig [96]byte
@@ -783,15 +712,56 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 			Signature:             zeroSig[:],
 		}, Proof: [][]byte{root}}, 100+i, int64(i), bytesutil.ToBytes32(root)))
 	}
-	assert.NoError(t, service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k'}))
-	fDeposits := depositCache.FinalizedDeposits(ctx)
-	assert.Equal(t, 7, int(fDeposits.MerkleTrieIndex), "Finalized deposits not inserted correctly")
+	service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k'})
+	fDeposits, err := depositCache.FinalizedDeposits(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, 7, int(fDeposits.MerkleTrieIndex()), "Finalized deposits not inserted correctly")
 	deps := depositCache.AllDeposits(ctx, big.NewInt(107))
 	for _, d := range deps {
 		assert.DeepEqual(t, [][]byte(nil), d.Proof, "Proofs are not empty")
 	}
 }
 
+func TestInsertFinalizedDeposits_PrunePendingDeposits(t *testing.T) {
+	service, tr := minimalTestService(t)
+	ctx, depositCache := tr.ctx, tr.dc
+
+	gs, _ := util.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	gs = gs.Copy()
+	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10, BlockHash: make([]byte, 32)}))
+	assert.NoError(t, gs.SetEth1DepositIndex(8))
+	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
+	var zeroSig [96]byte
+	for i := uint64(0); i < uint64(4*params.BeaconConfig().SlotsPerEpoch); i++ {
+		root := []byte(strconv.Itoa(int(i)))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, &ethpb.Deposit{Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.FromBytes48([fieldparams.BLSPubkeyLength]byte{}),
+			WithdrawalCredentials: params.BeaconConfig().ZeroHash[:],
+			Amount:                0,
+			Signature:             zeroSig[:],
+		}, Proof: [][]byte{root}}, 100+i, int64(i), bytesutil.ToBytes32(root)))
+		depositCache.InsertPendingDeposit(ctx, &ethpb.Deposit{Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.FromBytes48([fieldparams.BLSPubkeyLength]byte{}),
+			WithdrawalCredentials: params.BeaconConfig().ZeroHash[:],
+			Amount:                0,
+			Signature:             zeroSig[:],
+		}, Proof: [][]byte{root}}, 100+i, int64(i), bytesutil.ToBytes32(root))
+	}
+	service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k'})
+	fDeposits, err := depositCache.FinalizedDeposits(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, 7, int(fDeposits.MerkleTrieIndex()), "Finalized deposits not inserted correctly")
+	deps := depositCache.AllDeposits(ctx, big.NewInt(107))
+	for _, d := range deps {
+		assert.DeepEqual(t, [][]byte(nil), d.Proof, "Proofs are not empty")
+	}
+	pendingDeps := depositCache.PendingContainers(ctx, nil)
+	for _, d := range pendingDeps {
+		assert.DeepEqual(t, true, d.Index >= 8, "Pending deposits were not pruned")
+	}
+}
+
 func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 	service, tr := minimalTestService(t)
 	ctx, depositCache := tr.ctx, tr.dc
@@ -799,11 +769,11 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 	gs, _ := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
 	gs = gs.Copy()
-	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 7}))
+	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 7, BlockHash: make([]byte, 32)}))
 	assert.NoError(t, gs.SetEth1DepositIndex(6))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
 	gs2 := gs.Copy()
-	assert.NoError(t, gs2.SetEth1Data(&ethpb.Eth1Data{DepositCount: 15}))
+	assert.NoError(t, gs2.SetEth1Data(&ethpb.Eth1Data{DepositCount: 15, BlockHash: make([]byte, 32)}))
 	assert.NoError(t, gs2.SetEth1DepositIndex(13))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k', '2'}, gs2))
 	var zeroSig [96]byte
@@ -817,11 +787,11 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 		}, Proof: [][]byte{root}}, 100+i, int64(i), bytesutil.ToBytes32(root)))
 	}
 	// Insert 3 deposits before hand.
-	require.NoError(t, depositCache.InsertFinalizedDeposits(ctx, 2))
-
-	assert.NoError(t, service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k'}))
-	fDeposits := depositCache.FinalizedDeposits(ctx)
-	assert.Equal(t, 5, int(fDeposits.MerkleTrieIndex), "Finalized deposits not inserted correctly")
+	require.NoError(t, depositCache.InsertFinalizedDeposits(ctx, 2, [32]byte{}, 0))
+	service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k'})
+	fDeposits, err := depositCache.FinalizedDeposits(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, 5, int(fDeposits.MerkleTrieIndex()), "Finalized deposits not inserted correctly")
 
 	deps := depositCache.AllDeposits(ctx, big.NewInt(105))
 	for _, d := range deps {
@@ -829,9 +799,10 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 	}
 
 	// Insert New Finalized State with higher deposit count.
-	assert.NoError(t, service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k', '2'}))
-	fDeposits = depositCache.FinalizedDeposits(ctx)
-	assert.Equal(t, 12, int(fDeposits.MerkleTrieIndex), "Finalized deposits not inserted correctly")
+	service.insertFinalizedDeposits(ctx, [32]byte{'m', 'o', 'c', 'k', '2'})
+	fDeposits, err = depositCache.FinalizedDeposits(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, 12, int(fDeposits.MerkleTrieIndex()), "Finalized deposits not inserted correctly")
 	deps = depositCache.AllDeposits(ctx, big.NewInt(112))
 	for _, d := range deps {
 		assert.DeepEqual(t, [][]byte(nil), d.Proof, "Proofs are not empty")
@@ -1131,19 +1102,35 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 		var wg sync.WaitGroup
 		wg.Add(4)
 		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb1, r1))
+			preState, err := service.getBlockPreState(ctx, wsb1.Block())
+			require.NoError(t, err)
+			postState, err := service.validateStateTransition(ctx, preState, wsb1)
+			require.NoError(t, err)
+			require.NoError(t, service.postBlockProcess(ctx, wsb1, r1, postState, true))
 			wg.Done()
 		}()
 		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb2, r2))
+			preState, err := service.getBlockPreState(ctx, wsb2.Block())
+			require.NoError(t, err)
+			postState, err := service.validateStateTransition(ctx, preState, wsb2)
+			require.NoError(t, err)
+			require.NoError(t, service.postBlockProcess(ctx, wsb2, r2, postState, true))
 			wg.Done()
 		}()
 		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb3, r3))
+			preState, err := service.getBlockPreState(ctx, wsb3.Block())
+			require.NoError(t, err)
+			postState, err := service.validateStateTransition(ctx, preState, wsb3)
+			require.NoError(t, err)
+			require.NoError(t, service.postBlockProcess(ctx, wsb3, r3, postState, true))
 			wg.Done()
 		}()
 		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb4, r4))
+			preState, err := service.getBlockPreState(ctx, wsb4.Block())
+			require.NoError(t, err)
+			postState, err := service.validateStateTransition(ctx, preState, wsb4)
+			require.NoError(t, err)
+			require.NoError(t, service.postBlockProcess(ctx, wsb4, r4, postState, true))
 			wg.Done()
 		}()
 		wg.Wait()
@@ -1211,7 +1198,13 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, root))
+
+		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(ctx, wsb, root, postState, false))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1224,7 +1217,12 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, false)
 		require.NoError(t, err)
 	}
 
@@ -1238,7 +1236,12 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, false)
 		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
@@ -1255,7 +1258,12 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	require.NoError(t, err)
 	firstInvalidRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, firstInvalidRoot)
+	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, firstInvalidRoot, wsb, postState))
+	err = service.postBlockProcess(ctx, wsb, firstInvalidRoot, postState, false)
 	require.NoError(t, err)
 	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
@@ -1278,7 +1286,12 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	require.NoError(t, err)
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+	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))
+	err = service.postBlockProcess(ctx, wsb, root, postState, false)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 	// Check that forkchoice's head is the last invalid block imported. The
 	// store's headroot is the previous head (since the invalid block did
@@ -1301,7 +1314,13 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	require.NoError(t, err)
 	root, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+
+	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))
+	err = service.postBlockProcess(ctx, wsb, root, postState, true)
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
@@ -1358,7 +1377,12 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, root))
+		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(ctx, wsb, root, postState, false))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1371,7 +1395,12 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, false)
 		require.NoError(t, err)
 	}
 
@@ -1385,7 +1414,13 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, false)
 		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
@@ -1402,7 +1437,12 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, err)
 	firstInvalidRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, firstInvalidRoot)
+	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, firstInvalidRoot, wsb, postState))
+	err = service.postBlockProcess(ctx, wsb, firstInvalidRoot, postState, false)
 	require.NoError(t, err)
 	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
@@ -1425,7 +1465,12 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, err)
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+
+	preState, err = service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	require.NoError(t, err)
+	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, wsb, root)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 	// Check that forkchoice's head and store's headroot are the previous head (since the invalid block did
 	// not finish importing and it was never imported to forkchoice). Check
@@ -1448,7 +1493,12 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, err)
 	root, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+	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))
+	err = service.postBlockProcess(ctx, wsb, root, postState, true)
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
@@ -1506,7 +1556,13 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, root))
+
+		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(ctx, wsb, root, postState, false))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1519,7 +1575,13 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, false)
 		require.NoError(t, err)
 	}
 
@@ -1533,7 +1595,12 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	lastValidRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, lastValidRoot)
+	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, lastValidRoot, wsb, postState))
+	err = service.postBlockProcess(ctx, wsb, lastValidRoot, postState, false)
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1555,7 +1622,12 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, err)
 		invalidRoots[i-13], err = b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, invalidRoots[i-13])
+		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, invalidRoots[i-13], wsb, postState))
+		err = service.postBlockProcess(ctx, wsb, invalidRoots[i-13], postState, false)
 		require.NoError(t, err)
 	}
 	// Check that we have justified the second epoch
@@ -1576,7 +1648,12 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+
+	preState, err = service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	require.NoError(t, err)
+	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, wsb, root)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 
 	// Check that forkchoice's head and store's headroot are the previous head (since the invalid block did
@@ -1610,7 +1687,12 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	root, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.onBlock(ctx, wsb, root))
+	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(ctx, wsb, root, postState, true))
 	// Check that the head is still INVALID and the node is still optimistic
 	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	optimistic, err = service.IsOptimistic(ctx)
@@ -1628,7 +1710,12 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, true)
 		require.NoError(t, err)
 		st, err = service.cfg.StateGen.StateByRoot(ctx, root)
 		require.NoError(t, err)
@@ -1648,7 +1735,13 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	root, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+
+	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))
+	err = service.postBlockProcess(ctx, wsb, root, postState, true)
 	require.NoError(t, err)
 	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
@@ -1699,7 +1792,12 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, root))
+		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(ctx, wsb, root, postState, false))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1712,7 +1810,12 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		err = service.onBlock(ctx, wsb, root)
+		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))
+		err = service.postBlockProcess(ctx, wsb, root, postState, false)
 		require.NoError(t, err)
 	}
 
@@ -1726,7 +1829,12 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, err)
 	lastValidRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, lastValidRoot)
+	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, lastValidRoot, wsb, postState))
+	err = service.postBlockProcess(ctx, wsb, lastValidRoot, postState, false)
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1747,7 +1855,18 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, err)
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, root))
+		// Save current justified and finalized epochs for future use.
+		currStoreJustifiedEpoch := service.CurrentJustifiedCheckpt().Epoch
+		currStoreFinalizedEpoch := service.FinalizedCheckpt().Epoch
+		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(ctx, wsb, root, postState, false))
+		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
+		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
+		require.NoError(t, err)
 	}
 	// Check that we have justified the second epoch
 	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
@@ -1766,7 +1885,11 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, err)
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = service.onBlock(ctx, wsb, root)
+	preState, err = service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
+	require.NoError(t, err)
+	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, wsb, root)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 
 	// Check that the headroot/state are not in DB and restart the node
@@ -1808,8 +1931,10 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, err)
 	root, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
+	rwsb, err := consensusblocks.NewROBlock(wsb)
+	require.NoError(t, err)
 	// We use onBlockBatch here because the valid chain is missing in forkchoice
-	require.NoError(t, service.onBlockBatch(ctx, []interfaces.ReadOnlySignedBeaconBlock{wsb}, [][32]byte{root}))
+	require.NoError(t, service.onBlockBatch(ctx, []consensusblocks.ROBlock{rwsb}))
 	// Check that the head is now VALID and the node is not optimistic
 	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.cfg.ForkChoiceStore.CachedHeadRoot()))
 	headRoot, err = service.HeadRoot(ctx)
@@ -1848,7 +1973,12 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 	require.NoError(t, err)
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.onBlock(ctx, wsb, root))
+	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(ctx, wsb, root, postState, false))
 
 	st, err = service.HeadState(ctx)
 	require.NoError(t, err)

beacon-chain/blockchain/receive_attestation.go

@@ -62,7 +62,7 @@ func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a *ethpb.Attestat
 		return err
 	}
 	if !bytes.Equal(a.Data.Target.Root, r) {
-		return errors.New("FFG and LMD votes are not consistent")
+		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)
 	}
 	return nil
 }
@@ -86,23 +86,30 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 			}
 			log.Warn("Genesis time received, now available to process attestations")
 		}
+		// Wait for node to be synced before running the routine.
+		if err := s.waitForSync(); err != nil {
+			log.WithError(err).Error("Could not wait to sync")
+			return
+		}
 
-		st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
-		pat := slots.NewSlotTickerWithOffset(s.genesisTime, -reorgLateBlockCountAttestations, params.BeaconConfig().SecondsPerSlot)
+		reorgInterval := time.Second*time.Duration(params.BeaconConfig().SecondsPerSlot) - reorgLateBlockCountAttestations
+		ticker := slots.NewSlotTickerWithIntervals(s.genesisTime, []time.Duration{0, reorgInterval})
 		for {
 			select {
 			case <-s.ctx.Done():
 				return
-			case <-pat.C():
-				s.UpdateHead(s.ctx, s.CurrentSlot()+1)
-			case <-st.C():
-				s.cfg.ForkChoiceStore.Lock()
-				if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, s.CurrentSlot()); err != nil {
-					log.WithError(err).Error("could not process new slot")
-				}
-				s.cfg.ForkChoiceStore.Unlock()
+			case slotInterval := <-ticker.C():
+				if slotInterval.Interval > 0 {
+					s.UpdateHead(s.ctx, slotInterval.Slot+1)
+				} else {
+					s.cfg.ForkChoiceStore.Lock()
+					if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, slotInterval.Slot); err != nil {
+						log.WithError(err).Error("could not process new slot")
+					}
+					s.cfg.ForkChoiceStore.Unlock()
 
-				s.UpdateHead(s.ctx, s.CurrentSlot())
+					s.UpdateHead(s.ctx, slotInterval.Slot)
+				}
 			}
 		}
 	}()

beacon-chain/blockchain/receive_attestation_test.go

@@ -128,7 +128,13 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := blocks.NewSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	require.NoError(t, service.onBlock(ctx, wsb, tRoot))
+
+	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, tRoot, wsb, postState))
+	require.NoError(t, service.postBlockProcess(ctx, wsb, tRoot, postState, false))
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
 	require.NoError(t, err)
 	require.Equal(t, 2, fcs.NodeCount())
@@ -178,7 +184,13 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := blocks.NewSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	require.NoError(t, service.onBlock(ctx, wsb, tRoot))
+
+	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, tRoot, wsb, postState))
+	require.NoError(t, service.postBlockProcess(ctx, wsb, tRoot, postState, false))
 	require.Equal(t, 2, fcs.NodeCount())
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	require.Equal(t, tRoot, service.head.root)

beacon-chain/blockchain/receive_blob.go

@@ -0,0 +1,22 @@
+package blockchain
+
+import fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
+
+// SendNewBlobEvent sends a message to the BlobNotifier channel that the blob
+// for the blocroot `root` is ready in the database
+func (s *Service) SendNewBlobEvent(root [32]byte, index uint64) {
+	s.blobNotifier.Lock()
+	nc, ok := s.blobNotifier.chanForRoot[root]
+	if !ok {
+		nc = &blobNotifierChan{indices: make(map[uint64]struct{}), channel: make(chan struct{}, fieldparams.MaxBlobsPerBlock)}
+		s.blobNotifier.chanForRoot[root] = nc
+	}
+	_, ok = nc.indices[index]
+	if ok {
+		s.blobNotifier.Unlock()
+		return
+	}
+	nc.indices[index] = struct{}{}
+	s.blobNotifier.Unlock()
+	nc.channel <- struct{}{}
+}

beacon-chain/blockchain/receive_block.go

@@ -7,15 +7,24 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
+	coreTime "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v4/config/features"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/monitoring/tracing"
+	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/prysmaticlabs/prysm/v4/time"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"go.opencensus.io/trace"
+	"golang.org/x/sync/errgroup"
 )
 
 // This defines how many epochs since finality the run time will begin to save hot state on to the DB.
@@ -24,8 +33,15 @@ var epochsSinceFinalitySaveHotStateDB = primitives.Epoch(100)
 // BlockReceiver interface defines the methods of chain service for receiving and processing new blocks.
 type BlockReceiver interface {
 	ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) error
-	ReceiveBlockBatch(ctx context.Context, blocks []interfaces.ReadOnlySignedBeaconBlock, blkRoots [][32]byte) error
+	ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock) error
 	HasBlock(ctx context.Context, root [32]byte) bool
+	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
+}
+
+// BlobReceiver interface defines the methods of chain service for receiving new
+// blobs
+type BlobReceiver interface {
+	SendNewBlobEvent([32]byte, uint64)
 }
 
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
@@ -47,14 +63,85 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		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)
+	if err != nil {
+		return err
+	}
+	eg, _ := errgroup.WithContext(ctx)
+	var postState state.BeaconState
+	eg.Go(func() 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 {
+		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 {
+		return err
+	}
+	if err := s.isDataAvailable(ctx, blockRoot, blockCopy); err != nil {
+		return errors.Wrap(err, "could not validate blob data availability")
+	}
+	// The rest of block processing takes a lock on forkchoice.
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	// Apply state transition on the new block.
-	if err := s.onBlock(ctx, blockCopy, blockRoot); err != nil {
+	if err := s.savePostStateInfo(ctx, blockRoot, blockCopy, postState); err != nil {
+		return errors.Wrap(err, "could not save post state info")
+	}
+	if err := s.postBlockProcess(ctx, blockCopy, blockRoot, postState, isValidPayload); err != nil {
 		err := errors.Wrap(err, "could not process block")
 		tracing.AnnotateError(span, err)
 		return err
 	}
+	if coreTime.CurrentEpoch(postState) > currentEpoch {
+		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, 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)
+	}
 
 	// Handle post block operations such as pruning exits and bls messages if incoming block is the head
 	if err := s.prunePostBlockOperationPools(ctx, blockCopy, blockRoot); err != nil {
@@ -86,13 +173,15 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		log.WithError(err).Error("Unable to log state transition data")
 	}
 
+	chainServiceProcessingTime.Observe(float64(time.Since(receivedTime).Milliseconds()))
+
 	return nil
 }
 
 // ReceiveBlockBatch processes the whole block batch at once, assuming the block batch is linear ,transitioning
 // the state, performing batch verification of all collected signatures and then performing the appropriate
 // actions for a block post-transition.
-func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.ReadOnlySignedBeaconBlock, blkRoots [][32]byte) error {
+func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockBatch")
 	defer span.End()
 
@@ -100,13 +189,21 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Rea
 	defer s.cfg.ForkChoiceStore.Unlock()
 
 	// Apply state transition on the incoming newly received block batches, one by one.
-	if err := s.onBlockBatch(ctx, blocks, blkRoots); err != nil {
+	if err := s.onBlockBatch(ctx, blocks); err != nil {
 		err := errors.Wrap(err, "could not process block in batch")
 		tracing.AnnotateError(span, err)
 		return err
 	}
 
-	for i, b := range blocks {
+	lastBR := blocks[len(blocks)-1].Root()
+	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(lastBR)
+	if err != nil {
+		lastSlot := blocks[len(blocks)-1].Block().Slot()
+		log.WithError(err).Errorf("Could not check if block is optimistic, Root: %#x, Slot: %d", lastBR, lastSlot)
+		optimistic = true
+	}
+
+	for _, b := range blocks {
 		blockCopy, err := b.Copy()
 		if err != nil {
 			return err
@@ -116,9 +213,10 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Rea
 			Type: statefeed.BlockProcessed,
 			Data: &statefeed.BlockProcessedData{
 				Slot:        blockCopy.Block().Slot(),
-				BlockRoot:   blkRoots[i],
+				BlockRoot:   b.Root(),
 				SignedBlock: blockCopy,
 				Verified:    true,
+				Optimistic:  optimistic,
 			},
 		})
 
@@ -150,6 +248,11 @@ func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
 	return s.hasBlockInInitSyncOrDB(ctx, root)
 }
 
+// RecentBlockSlot returns block slot form fork choice store
+func (s *Service) RecentBlockSlot(root [32]byte) (primitives.Slot, error) {
+	return s.cfg.ForkChoiceStore.Slot(root)
+}
+
 // ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
 func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) {
 	s.cfg.ForkChoiceStore.Lock()
@@ -226,3 +329,109 @@ func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
 
 	return s.cfg.StateGen.DisableSaveHotStateToDB(ctx)
 }
+
+// This performs the state transition function and returns the poststate or an
+// error if the block fails to verify the consensus rules
+func (s *Service) validateStateTransition(ctx context.Context, preState state.BeaconState, signed interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
+	b := signed.Block()
+	// Verify that the parent block is in forkchoice
+	parentRoot := b.ParentRoot()
+	if !s.InForkchoice(parentRoot) {
+		return nil, ErrNotDescendantOfFinalized
+	}
+	stateTransitionStartTime := time.Now()
+	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
+	if err != nil {
+		return nil, invalidBlock{error: err}
+	}
+	stateTransitionProcessingTime.Observe(float64(time.Since(stateTransitionStartTime).Milliseconds()))
+	return postState, nil
+}
+
+// updateJustificationOnBlock updates the justified checkpoint on DB if the
+// incoming block has updated it on forkchoice.
+func (s *Service) updateJustificationOnBlock(ctx context.Context, preState, postState state.BeaconState, preJustifiedEpoch primitives.Epoch) error {
+	justified := s.cfg.ForkChoiceStore.JustifiedCheckpoint()
+	preStateJustifiedEpoch := preState.CurrentJustifiedCheckpoint().Epoch
+	postStateJustifiedEpoch := postState.CurrentJustifiedCheckpoint().Epoch
+	if justified.Epoch > preJustifiedEpoch || (justified.Epoch == postStateJustifiedEpoch && justified.Epoch > preStateJustifiedEpoch) {
+		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{
+			Epoch: justified.Epoch, Root: justified.Root[:],
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// updateFinalizationOnBlock performs some duties when the incoming block
+// changes the finalized checkpoint. It returns true when this has happened.
+func (s *Service) updateFinalizationOnBlock(ctx context.Context, preState, postState state.BeaconState, preFinalizedEpoch primitives.Epoch) (bool, error) {
+	preStateFinalizedEpoch := preState.FinalizedCheckpoint().Epoch
+	postStateFinalizedEpoch := postState.FinalizedCheckpoint().Epoch
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
+	if finalized.Epoch > preFinalizedEpoch || (finalized.Epoch == postStateFinalizedEpoch && finalized.Epoch > preStateFinalizedEpoch) {
+		if err := s.updateFinalized(ctx, &ethpb.Checkpoint{Epoch: finalized.Epoch, Root: finalized.Root[:]}); err != nil {
+			return true, err
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+// 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) {
+	isValidPayload := false
+	s.headLock.RLock()
+	if s.head != nil {
+		isValidPayload = s.head.optimistic
+	}
+	s.headLock.RUnlock()
+
+	// 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{
+			Epoch:               postState.FinalizedCheckpoint().Epoch,
+			Block:               postState.FinalizedCheckpoint().Root,
+			State:               stateRoot[:],
+			ExecutionOptimistic: isValidPayload,
+		},
+	})
+}
+
+// sendBlockAttestationsToSlasher sends the incoming block's attestation to the slasher
+func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySignedBeaconBlock, preState state.BeaconState) {
+	// Feed the indexed attestation to slasher if enabled. This action
+	// 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)
+		if err != nil {
+			log.WithError(err).Error("Could not get attestation committee")
+			return
+		}
+		indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
+		if err != nil {
+			log.WithError(err).Error("Could not convert to indexed attestation")
+			return
+		}
+		s.cfg.SlasherAttestationsFeed.Send(indexedAtt)
+	}
+}
+
+// validateExecutionOnBlock notifies the engine of the incoming block execution payload and returns true if the payload is valid
+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())
+	}
+	if signed.Version() < version.Capella && isValidPayload {
+		if err := s.validateMergeTransitionBlock(ctx, ver, header, signed); err != nil {
+			return isValidPayload, err
+		}
+	}
+	return isValidPayload, nil
+}

beacon-chain/blockchain/receive_block_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
@@ -228,13 +227,11 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			s, _ := minimalTestService(t, WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}))
 			err := s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
-			root, err := tt.args.block.Block.HashTreeRoot()
-			require.NoError(t, err)
 			wsb, err := blocks.NewSignedBeaconBlock(tt.args.block)
 			require.NoError(t, err)
-			blks := []interfaces.ReadOnlySignedBeaconBlock{wsb}
-			roots := [][32]byte{root}
-			err = s.ReceiveBlockBatch(ctx, blks, roots)
+			rwsb, err := blocks.NewROBlock(wsb)
+			require.NoError(t, err)
+			err = s.ReceiveBlockBatch(ctx, []blocks.ROBlock{rwsb})
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {

beacon-chain/blockchain/service.go

@@ -12,11 +12,12 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/async/event"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache/depositcache"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
+	coreTime "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/execution"
@@ -34,7 +35,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v4/time"
@@ -45,21 +45,22 @@ import (
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                   *config
-	ctx                   context.Context
-	cancel                context.CancelFunc
-	genesisTime           time.Time
-	head                  *head
-	headLock              sync.RWMutex
-	originBlockRoot       [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	nextEpochBoundarySlot primitives.Slot
-	boundaryRoots         [][32]byte
-	checkpointStateCache  *cache.CheckpointStateCache
-	initSyncBlocks        map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
-	initSyncBlocksLock    sync.RWMutex
-	wsVerifier            *WeakSubjectivityVerifier
-	clockSetter           startup.ClockSetter
-	clockWaiter           startup.ClockWaiter
+	cfg                  *config
+	ctx                  context.Context
+	cancel               context.CancelFunc
+	genesisTime          time.Time
+	head                 *head
+	headLock             sync.RWMutex
+	originBlockRoot      [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	boundaryRoots        [][32]byte
+	checkpointStateCache *cache.CheckpointStateCache
+	initSyncBlocks       map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
+	initSyncBlocksLock   sync.RWMutex
+	wsVerifier           *WeakSubjectivityVerifier
+	clockSetter          startup.ClockSetter
+	clockWaiter          startup.ClockWaiter
+	syncComplete         chan struct{}
+	blobNotifier         *blobNotifier
 }
 
 // config options for the service.
@@ -67,7 +68,7 @@ type config struct {
 	BeaconBlockBuf          int
 	ChainStartFetcher       execution.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
-	DepositCache            *depositcache.DepositCache
+	DepositCache            cache.DepositCache
 	ProposerSlotIndexCache  *cache.ProposerPayloadIDsCache
 	AttPool                 attestations.Pool
 	ExitPool                voluntaryexits.PoolManager
@@ -88,16 +89,37 @@ type config struct {
 
 var ErrMissingClockSetter = errors.New("blockchain Service initialized without a startup.ClockSetter")
 
+type blobNotifierChan struct {
+	indices map[uint64]struct{}
+	channel chan struct{}
+}
+
+type blobNotifier struct {
+	sync.RWMutex
+	chanForRoot map[[32]byte]*blobNotifierChan
+}
+
 // NewService instantiates a new block service instance that will
 // be registered into a running beacon node.
 func NewService(ctx context.Context, opts ...Option) (*Service, error) {
+	var err error
+	if params.DenebEnabled() {
+		err = kzg.Start()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not initialize go-kzg context")
+		}
+	}
 	ctx, cancel := context.WithCancel(ctx)
+	bn := &blobNotifier{
+		chanForRoot: make(map[[32]byte]*blobNotifierChan),
+	}
 	srv := &Service{
 		ctx:                  ctx,
 		cancel:               cancel,
 		boundaryRoots:        [][32]byte{},
 		checkpointStateCache: cache.NewCheckpointStateCache(),
 		initSyncBlocks:       make(map[[32]byte]interfaces.ReadOnlySignedBeaconBlock),
+		blobNotifier:         bn,
 		cfg:                  &config{ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache()},
 	}
 	for _, opt := range opts {
@@ -108,7 +130,6 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	if srv.clockSetter == nil {
 		return nil, ErrMissingClockSetter
 	}
-	var err error
 	srv.wsVerifier, err = NewWeakSubjectivityVerifier(srv.cfg.WeakSubjectivityCheckpt, srv.cfg.BeaconDB)
 	if err != nil {
 		return nil, err
@@ -307,7 +328,13 @@ func (s *Service) initializeHeadFromDB(ctx context.Context) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block")
 	}
-	if err := s.setHead(finalizedRoot, finalizedBlock, finalizedState); err != nil {
+	if err := s.setHead(&head{
+		finalizedRoot,
+		finalizedBlock,
+		finalizedState,
+		finalizedBlock.Block().Slot(),
+		false,
+	}); err != nil {
 		return errors.Wrap(err, "could not set head")
 	}
 
@@ -401,7 +428,7 @@ func (s *Service) initializeBeaconChain(
 	if err := helpers.UpdateCommitteeCache(ctx, genesisState, 0); err != nil {
 		return nil, err
 	}
-	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState); err != nil {
+	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState, coreTime.CurrentEpoch(genesisState)); err != nil {
 		return nil, err
 	}
 
@@ -439,7 +466,13 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	}
 	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
 
-	if err := s.setHead(genesisBlkRoot, genesisBlk, genesisState); err != nil {
+	if err := s.setHead(&head{
+		genesisBlkRoot,
+		genesisBlk,
+		genesisState,
+		genesisBlk.Block().Slot(),
+		false,
+	}); err != nil {
 		log.WithError(err).Fatal("Could not set head")
 	}
 	return nil

beacon-chain/blockchain/service_test.go

@@ -357,7 +357,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
 	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState))
+	require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState, false))
 
 	newB, err := s.cfg.BeaconDB.HeadBlock(ctx)
 	require.NoError(t, err)
@@ -377,9 +377,7 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, s.insertBlockToForkchoiceStore(ctx, wsb.Block(), r, beaconState))
+	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")
@@ -453,9 +451,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := state_native.InitializeFromProtoPhase0(bs)
 	require.NoError(b, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	require.NoError(b, s.insertBlockToForkchoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/blockchain/setup_test.go

@@ -52,6 +52,11 @@ func (mb *mockBroadcaster) BroadcastSyncCommitteeMessage(_ context.Context, _ ui
 	return nil
 }
 
+func (mb *mockBroadcaster) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.SignedBlobSidecar) error {
+	mb.broadcastCalled = true
+	return nil
+}
+
 func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.SignedBLSToExecutionChange) {
 }
 

beacon-chain/blockchain/testing/BUILD.bazel

@@ -23,6 +23,7 @@ go_library(
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -22,6 +22,7 @@ import (
 	state_native "github.com/prysmaticlabs/prysm/v4/beacon-chain/state/state-native"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
@@ -69,6 +70,7 @@ type ChainService struct {
 	OptimisticCheckRootReceived [32]byte
 	FinalizedRoots              map[[32]byte]bool
 	OptimisticRoots             map[[32]byte]bool
+	BlockSlot                   primitives.Slot
 }
 
 func (s *ChainService) Ancestor(ctx context.Context, root []byte, slot primitives.Slot) ([]byte, error) {
@@ -203,7 +205,7 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interf
 }
 
 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySignedBeaconBlock, _ [][32]byte) error {
+func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []blocks.ROBlock) error {
 	if s.State == nil {
 		return ErrNilState
 	}
@@ -389,6 +391,11 @@ func (s *ChainService) HasBlock(ctx context.Context, rt [32]byte) bool {
 	return s.InitSyncBlockRoots[rt]
 }
 
+// RecentBlockSlot mocks the same method in the chain service.
+func (s *ChainService) RecentBlockSlot([32]byte) (primitives.Slot, error) {
+	return s.BlockSlot, nil
+}
+
 // HeadGenesisValidatorsRoot mocks HeadGenesisValidatorsRoot method in chain service.
 func (_ *ChainService) HeadGenesisValidatorsRoot() [32]byte {
 	return [32]byte{}
@@ -533,7 +540,7 @@ func (s *ChainService) GetProposerHead() [32]byte {
 	return [32]byte{}
 }
 
-// SetForkchoiceGenesisTime mocks the same method in the chain service
+// SetForkChoiceGenesisTime mocks the same method in the chain service
 func (s *ChainService) SetForkChoiceGenesisTime(timestamp uint64) {
 	if s.ForkChoiceStore != nil {
 		s.ForkChoiceStore.SetGenesisTime(timestamp)
@@ -597,3 +604,6 @@ func (s *ChainService) FinalizedBlockHash() [32]byte {
 func (s *ChainService) UnrealizedJustifiedPayloadBlockHash() [32]byte {
 	return [32]byte{}
 }
+
+// SendNewBlobEvent mocks the same method in the chain service
+func (s *ChainService) SendNewBlobEvent(_ [32]byte, _ uint64) {}

beacon-chain/builder/BUILD.bazel

@@ -15,10 +15,12 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",

beacon-chain/builder/service.go

@@ -2,6 +2,7 @@ package builder
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 	"time"
 
@@ -10,10 +11,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/monitoring/tracing"
+	v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -24,7 +27,7 @@ var ErrNoBuilder = errors.New("builder endpoint not configured")
 
 // BlockBuilder defines the interface for interacting with the block builder
 type BlockBuilder interface {
-	SubmitBlindedBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, error)
+	SubmitBlindedBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blobs []*ethpb.SignedBlindedBlobSidecar) (interfaces.ExecutionData, *v1.BlobsBundle, error)
 	GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubKey [48]byte) (builder.SignedBid, error)
 	RegisterValidator(ctx context.Context, reg []*ethpb.SignedValidatorRegistrationV1) error
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
@@ -87,7 +90,7 @@ func (s *Service) Stop() error {
 }
 
 // SubmitBlindedBlock submits a blinded block to the builder relay network.
-func (s *Service) SubmitBlindedBlock(ctx context.Context, b interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, error) {
+func (s *Service) SubmitBlindedBlock(ctx context.Context, b interfaces.ReadOnlySignedBeaconBlock, blobs []*ethpb.SignedBlindedBlobSidecar) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
 	ctx, span := trace.StartSpan(ctx, "builder.SubmitBlindedBlock")
 	defer span.End()
 	start := time.Now()
@@ -95,10 +98,13 @@ func (s *Service) SubmitBlindedBlock(ctx context.Context, b interfaces.ReadOnlyS
 		submitBlindedBlockLatency.Observe(float64(time.Since(start).Milliseconds()))
 	}()
 	if s.c == nil {
-		return nil, ErrNoBuilder
+		return nil, nil, ErrNoBuilder
+	}
+	if uint64(len(blobs)) > fieldparams.MaxBlobsPerBlock {
+		return nil, nil, fmt.Errorf("blob count %d beyond max limit of %d", len(blobs), fieldparams.MaxBlobsPerBlock)
 	}
 
-	return s.c.SubmitBlindedBlock(ctx, b)
+	return s.c.SubmitBlindedBlock(ctx, b, blobs)
 }
 
 // GetHeader retrieves the header for a given slot and parent hash from the builder relay network.

beacon-chain/builder/service_test.go

@@ -62,7 +62,7 @@ func Test_BuilderMethodsWithouClient(t *testing.T) {
 	_, err = s.GetHeader(context.Background(), 0, [32]byte{}, [48]byte{})
 	assert.ErrorContains(t, ErrNoBuilder.Error(), err)
 
-	_, err = s.SubmitBlindedBlock(context.Background(), nil)
+	_, _, err = s.SubmitBlindedBlock(context.Background(), nil, nil)
 	assert.ErrorContains(t, ErrNoBuilder.Error(), err)
 
 	err = s.RegisterValidator(context.Background(), nil)

beacon-chain/builder/testing/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

beacon-chain/builder/testing/mock.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 )
 
@@ -26,9 +27,12 @@ type MockBuilderService struct {
 	HasConfigured         bool
 	Payload               *v1.ExecutionPayload
 	PayloadCapella        *v1.ExecutionPayloadCapella
+	PayloadDeneb          *v1.ExecutionPayloadDeneb
+	BlobBundle            *v1.BlobsBundle
 	ErrSubmitBlindedBlock error
 	Bid                   *ethpb.SignedBuilderBid
 	BidCapella            *ethpb.SignedBuilderBidCapella
+	BidDeneb              *ethpb.SignedBuilderBidDeneb
 	RegistrationCache     *cache.RegistrationCache
 	ErrGetHeader          error
 	ErrRegisterValidator  error
@@ -41,23 +45,36 @@ func (s *MockBuilderService) Configured() bool {
 }
 
 // SubmitBlindedBlock for mocking.
-func (s *MockBuilderService) SubmitBlindedBlock(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, error) {
-	if s.Payload != nil {
+func (s *MockBuilderService) SubmitBlindedBlock(_ context.Context, b interfaces.ReadOnlySignedBeaconBlock, _ []*ethpb.SignedBlindedBlobSidecar) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
+	switch b.Version() {
+	case version.Bellatrix:
 		w, err := blocks.WrappedExecutionPayload(s.Payload)
 		if err != nil {
-			return nil, errors.Wrap(err, "could not wrap payload")
+			return nil, nil, errors.Wrap(err, "could not wrap payload")
 		}
-		return w, s.ErrSubmitBlindedBlock
+		return w, nil, s.ErrSubmitBlindedBlock
+	case version.Capella:
+		w, err := blocks.WrappedExecutionPayloadCapella(s.PayloadCapella, 0)
+		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, 0)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "could not wrap deneb payload")
+		}
+		return w, s.BlobBundle, s.ErrSubmitBlindedBlock
+	default:
+		return nil, nil, errors.New("unknown block version for mocking")
 	}
-	w, err := blocks.WrappedExecutionPayloadCapella(s.PayloadCapella, 0)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not wrap capella payload")
-	}
-	return w, s.ErrSubmitBlindedBlock
 }
 
 // GetHeader for mocking.
 func (s *MockBuilderService) GetHeader(_ context.Context, slot primitives.Slot, _ [32]byte, _ [48]byte) (builder.SignedBid, error) {
+	if slots.ToEpoch(slot) >= params.BeaconConfig().DenebForkEpoch || s.BidDeneb != nil {
+		return builder.WrappedSignedBuilderBidDeneb(s.BidDeneb)
+	}
 	if slots.ToEpoch(slot) >= params.BeaconConfig().CapellaForkEpoch || s.BidCapella != nil {
 		return builder.WrappedSignedBuilderBidCapella(s.BidCapella)
 	}

beacon-chain/cache/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
         "common.go",
         "doc.go",
         "error.go",
+        "interfaces.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep
@@ -44,6 +45,7 @@ go_library(
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/cache/depositcache/BUILD.bazel

@@ -13,12 +13,14 @@ go_library(
         "//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",
@@ -35,6 +37,7 @@ go_test(
     ],
     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",

beacon-chain/cache/depositcache/deposits_cache.go

@@ -11,9 +11,11 @@ import (
 	"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/v4/beacon-chain/cache"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/container/trie"
@@ -30,20 +32,11 @@ var (
 	})
 )
 
-// DepositFetcher defines a struct which can retrieve deposit information from a store.
-type DepositFetcher interface {
-	AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
-	DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int)
-	DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte)
-	FinalizedDeposits(ctx context.Context) *FinalizedDeposits
-	NonFinalizedDeposits(ctx context.Context, lastFinalizedIndex int64, untilBlk *big.Int) []*ethpb.Deposit
-}
-
 // 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
+	deposits        *trie.SparseMerkleTrie
+	merkleTrieIndex int64
 }
 
 // DepositCache stores all in-memory deposit objects. This
@@ -52,7 +45,7 @@ type DepositCache struct {
 	// Beacon chain deposits in memory.
 	pendingDeposits   []*ethpb.DepositContainer
 	deposits          []*ethpb.DepositContainer
-	finalizedDeposits *FinalizedDeposits
+	finalizedDeposits FinalizedDeposits
 	depositsByKey     map[[fieldparams.BLSPubkeyLength]byte][]*ethpb.DepositContainer
 	depositsLock      sync.RWMutex
 }
@@ -64,13 +57,13 @@ func New() (*DepositCache, error) {
 		return nil, err
 	}
 
-	// finalizedDeposits.MerkleTrieIndex is initialized to -1 because it represents the index of the last trie item.
+	// 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},
+		finalizedDeposits: FinalizedDeposits{deposits: finalizedDepositsTrie, merkleTrieIndex: -1},
 	}, nil
 }
 
@@ -129,14 +122,15 @@ func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*eth
 }
 
 // InsertFinalizedDeposits inserts deposits up to eth1DepositIndex (inclusive) into the finalized deposits cache.
-func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64) error {
+func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context,
+	eth1DepositIndex int64, _ common.Hash, _ uint64) error {
 	ctx, 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)
+	depositTrie := dc.finalizedDeposits.Deposits()
+	insertIndex := int(dc.finalizedDeposits.merkleTrieIndex + 1)
 
 	// Don't insert into finalized trie if there is no deposit to
 	// insert.
@@ -154,7 +148,7 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 		return nil
 	}
 	for _, d := range dc.deposits {
-		if d.Index <= dc.finalizedDeposits.MerkleTrieIndex {
+		if d.Index <= dc.finalizedDeposits.merkleTrieIndex {
 			continue
 		}
 		if d.Index > eth1DepositIndex {
@@ -169,10 +163,13 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 		}
 		insertIndex++
 	}
-
-	dc.finalizedDeposits = &FinalizedDeposits{
-		Deposits:        depositTrie,
-		MerkleTrieIndex: eth1DepositIndex,
+	tree, ok := depositTrie.(*trie.SparseMerkleTrie)
+	if !ok {
+		return errors.New("not a sparse merkle tree")
+	}
+	dc.finalizedDeposits = FinalizedDeposits{
+		deposits:        tree,
+		merkleTrieIndex: eth1DepositIndex,
 	}
 	return nil
 }
@@ -204,8 +201,6 @@ func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*ethpb.Depos
 // 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 {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDeposits")
-	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
 
@@ -261,16 +256,16 @@ func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*et
 }
 
 // FinalizedDeposits returns the finalized deposits trie.
-func (dc *DepositCache) FinalizedDeposits(ctx context.Context) *FinalizedDeposits {
+func (dc *DepositCache) FinalizedDeposits(ctx context.Context) (cache.FinalizedDeposits, error) {
 	ctx, 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,
-	}
+		deposits:        dc.finalizedDeposits.deposits.Copy(),
+		merkleTrieIndex: dc.finalizedDeposits.merkleTrieIndex,
+	}, nil
 }
 
 // NonFinalizedDeposits returns the list of non-finalized deposits until the given block number (inclusive).
@@ -281,7 +276,7 @@ func (dc *DepositCache) NonFinalizedDeposits(ctx context.Context, lastFinalizedI
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
 
-	if dc.finalizedDeposits == nil {
+	if dc.finalizedDeposits.Deposits() == nil {
 		return dc.allDeposits(untilBlk)
 	}
 
@@ -307,9 +302,6 @@ func (dc *DepositCache) PruneProofs(ctx context.Context, untilDepositIndex int64
 	}
 
 	for i := untilDepositIndex; i >= 0; i-- {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
 		// Finding a nil proof means that all proofs up to this deposit have been already pruned.
 		if dc.deposits[i].Deposit.Proof == nil {
 			break
@@ -319,3 +311,14 @@ func (dc *DepositCache) PruneProofs(ctx context.Context, untilDepositIndex int64
 
 	return nil
 }
+
+// Deposits returns the cached internal deposit tree.
+func (fd *FinalizedDeposits) Deposits() cache.MerkleTree {
+	return fd.deposits
+}
+
+// MerkleTrieIndex represents the last finalized index in
+// the finalized deposit container.
+func (fd *FinalizedDeposits) MerkleTrieIndex() int64 {
+	return fd.merkleTrieIndex
+}

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -7,6 +7,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/container/trie"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
@@ -18,7 +19,7 @@ import (
 
 const nilDepositErr = "Ignoring nil deposit insertion"
 
-var _ DepositFetcher = (*DepositCache)(nil)
+var _ cache.DepositFetcher = (*DepositCache)(nil)
 
 func TestInsertDeposit_LogsOnNilDepositInsertion(t *testing.T) {
 	hook := logTest.NewGlobal()
@@ -416,11 +417,12 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 		Index: 3,
 	})
 
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0))
 
-	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
-	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex)
+	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex())
 
 	var deps [][]byte
 	for _, d := range finalizedDeposits {
@@ -432,7 +434,7 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 	require.NoError(t, err, "Could not generate deposit trie")
 	rootA, err := generatedTrie.HashTreeRoot()
 	require.NoError(t, err)
-	rootB, err := cachedDeposits.Deposits.HashTreeRoot()
+	rootB, err := cachedDeposits.Deposits().HashTreeRoot()
 	require.NoError(t, err)
 	assert.Equal(t, rootA, rootB)
 }
@@ -474,15 +476,16 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 		Index: 2,
 	}
 	dc.deposits = oldFinalizedDeposits
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 1))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0))
 
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0))
 
 	dc.deposits = append(dc.deposits, []*ethpb.DepositContainer{newFinalizedDeposit}...)
 
-	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
-	assert.Equal(t, int64(1), cachedDeposits.MerkleTrieIndex)
+	assert.Equal(t, int64(1), cachedDeposits.MerkleTrieIndex())
 
 	var deps [][]byte
 	for _, d := range oldFinalizedDeposits {
@@ -494,7 +497,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 	require.NoError(t, err, "Could not generate deposit trie")
 	rootA, err := generatedTrie.HashTreeRoot()
 	require.NoError(t, err)
-	rootB, err := cachedDeposits.Deposits.HashTreeRoot()
+	rootB, err := cachedDeposits.Deposits().HashTreeRoot()
 	require.NoError(t, err)
 	assert.Equal(t, rootA, rootB)
 }
@@ -503,11 +506,12 @@ func TestFinalizedDeposits_HandleZeroDeposits(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0))
 
-	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
-	assert.Equal(t, int64(-1), cachedDeposits.MerkleTrieIndex)
+	assert.Equal(t, int64(-1), cachedDeposits.MerkleTrieIndex())
 }
 
 func TestFinalizedDeposits_HandleSmallerThanExpectedDeposits(t *testing.T) {
@@ -548,11 +552,12 @@ func TestFinalizedDeposits_HandleSmallerThanExpectedDeposits(t *testing.T) {
 	}
 	dc.deposits = finalizedDeposits
 
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 5))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 5, [32]byte{}, 0))
 
-	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
-	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex)
+	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex())
 }
 
 func TestFinalizedDeposits_HandleLowerEth1DepositIndex(t *testing.T) {
@@ -623,14 +628,15 @@ func TestFinalizedDeposits_HandleLowerEth1DepositIndex(t *testing.T) {
 	}
 	dc.deposits = finalizedDeposits
 
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 5))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 5, [32]byte{}, 0))
 
 	// Reinsert finalized deposits with a lower index.
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0))
 
-	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
-	assert.Equal(t, int64(5), cachedDeposits.MerkleTrieIndex)
+	assert.Equal(t, int64(5), cachedDeposits.MerkleTrieIndex())
 }
 
 func TestFinalizedDeposits_InitializedCorrectly(t *testing.T) {
@@ -640,7 +646,7 @@ func TestFinalizedDeposits_InitializedCorrectly(t *testing.T) {
 	finalizedDeposits := dc.finalizedDeposits
 	assert.NotNil(t, finalizedDeposits)
 	assert.NotNil(t, finalizedDeposits.Deposits)
-	assert.Equal(t, int64(-1), finalizedDeposits.MerkleTrieIndex)
+	assert.Equal(t, int64(-1), finalizedDeposits.merkleTrieIndex)
 }
 
 func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
@@ -694,7 +700,7 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			},
 			Index: 3,
 		})
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 1))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0))
 
 	deps := dc.NonFinalizedDeposits(context.Background(), 1, nil)
 	assert.Equal(t, 2, len(deps))
@@ -751,7 +757,7 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			},
 			Index: 3,
 		})
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 1))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0))
 
 	deps := dc.NonFinalizedDeposits(context.Background(), 1, big.NewInt(10))
 	assert.Equal(t, 1, len(deps))
@@ -799,41 +805,43 @@ func TestFinalizedDeposits_ReturnsTrieCorrectly(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Perform this in a non-sensical ordering
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 10))
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2))
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 3))
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 4))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 10, [32]byte{}, 0))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 3, [32]byte{}, 0))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 4, [32]byte{}, 0))
 
 	// Mimic finalized deposit trie fetch.
-	fd := dc.FinalizedDeposits(context.Background())
-	deps := dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex, big.NewInt(14))
-	insertIndex := fd.MerkleTrieIndex + 1
+	fd, err := dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
+	deps := dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex(), big.NewInt(14))
+	insertIndex := fd.MerkleTrieIndex() + 1
 
 	for _, dep := range deps {
 		depHash, err := dep.Data.HashTreeRoot()
 		assert.NoError(t, err)
-		if err = fd.Deposits.Insert(depHash[:], int(insertIndex)); err != nil {
+		if err = fd.Deposits().Insert(depHash[:], int(insertIndex)); err != nil {
 			assert.NoError(t, err)
 		}
 		insertIndex++
 	}
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 15))
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 15))
-	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 14))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 15, [32]byte{}, 0))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 15, [32]byte{}, 0))
+	require.NoError(t, dc.InsertFinalizedDeposits(context.Background(), 14, [32]byte{}, 0))
 
-	fd = dc.FinalizedDeposits(context.Background())
-	deps = dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex, big.NewInt(30))
-	insertIndex = fd.MerkleTrieIndex + 1
+	fd, err = dc.FinalizedDeposits(context.Background())
+	require.NoError(t, err)
+	deps = dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex(), big.NewInt(30))
+	insertIndex = fd.MerkleTrieIndex() + 1
 
 	for _, dep := range deps {
 		depHash, err := dep.Data.HashTreeRoot()
 		assert.NoError(t, err)
-		if err = fd.Deposits.Insert(depHash[:], int(insertIndex)); err != nil {
+		if err = fd.Deposits().Insert(depHash[:], int(insertIndex)); err != nil {
 			assert.NoError(t, err)
 		}
 		insertIndex++
 	}
-	assert.Equal(t, fd.Deposits.NumOfItems(), depositTrie.NumOfItems())
+	assert.Equal(t, fd.Deposits().NumOfItems(), depositTrie.NumOfItems())
 }
 
 func TestPruneProofs_Ok(t *testing.T) {
@@ -1056,3 +1064,11 @@ func makeDepositProof() [][]byte {
 	}
 	return proof
 }
+
+func TestEmptyTree(t *testing.T) {
+	finalizedDepositsTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err)
+	v, err := finalizedDepositsTrie.HashTreeRoot()
+	require.NoError(t, err)
+	fmt.Printf("%x", v)
+}

beacon-chain/cache/depositcache/pending_deposits_test.go

@@ -17,7 +17,7 @@ func TestInsertPendingDeposit_OK(t *testing.T) {
 	dc := DepositCache{}
 	dc.InsertPendingDeposit(context.Background(), &ethpb.Deposit{}, 111, 100, [32]byte{})
 
-	assert.Equal(t, 1, len(dc.pendingDeposits), "Deposit not inserted")
+	assert.Equal(t, 1, len(dc.pendingDeposits), "deposit not inserted")
 }
 
 func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
@@ -56,7 +56,7 @@ 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")
+	assert.Equal(t, 1, len(dc.pendingDeposits), "deposit unexpectedly removed")
 }
 
 func TestPendingDeposit_RoundTrip(t *testing.T) {

beacon-chain/cache/depositsnapshot/BUILD.bazel

@@ -3,26 +3,37 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "deposit_fetcher.go",
+        "deposit_inserter.go",
         "deposit_tree.go",
         "deposit_tree_snapshot.go",
         "merkle_tree.go",
-        "zerohashes.gen.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/cache/depositsnapshot",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/cache:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//container/slice:go_default_library",
+        "//container/trie:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
-        "//proto/eth/v1: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",
+        "@com_github_wealdtech_go_bytesutil//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 
 go_test(
     name = "go_default_test",
     srcs = [
+        "deposit_cache_test.go",
         "deposit_tree_snapshot_test.go",
         "merkle_tree_test.go",
         "spec_test.go",
@@ -32,10 +43,16 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//beacon-chain/cache:go_default_library",
+        "//config/params:go_default_library",
+        "//container/trie:go_default_library",
+        "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
-        "//proto/eth/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@in_gopkg_yaml_v3//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",

beacon-chain/cache/depositsnapshot/deposit_fetcher.go

@@ -0,0 +1,304 @@
+package depositsnapshot
+
+import (
+	"context"
+	"math/big"
+	"sort"
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/sirupsen/logrus"
+	"github.com/wealdtech/go-bytesutil"
+	"go.opencensus.io/trace"
+)
+
+var (
+	pendingDepositsCount = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacondb_pending_deposits_eip4881",
+		Help: "The number of pending deposits in memory",
+	})
+)
+
+// Cache stores all in-memory deposit objects. This
+// stores all the deposit related data that is required by the beacon-node.
+type Cache struct {
+	pendingDeposits   []*ethpb.DepositContainer
+	deposits          []*ethpb.DepositContainer
+	finalizedDeposits finalizedDepositsContainer
+	depositsByKey     map[[fieldparams.BLSPubkeyLength]byte][]*ethpb.DepositContainer
+	depositsLock      sync.RWMutex
+}
+
+// finalizedDepositsContainer stores the trie of deposits that have been included
+// in the beacon state up to the latest finalized checkpoint.
+type finalizedDepositsContainer struct {
+	depositTree     *DepositTree
+	merkleTrieIndex int64
+}
+
+// New instantiates a new deposit cache
+func New() (*Cache, error) {
+	finalizedDepositsTrie := NewDepositTree()
+
+	// 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 &Cache{
+		pendingDeposits:   []*ethpb.DepositContainer{},
+		deposits:          []*ethpb.DepositContainer{},
+		depositsByKey:     map[[fieldparams.BLSPubkeyLength]byte][]*ethpb.DepositContainer{},
+		finalizedDeposits: toFinalizedDepositsContainer(finalizedDepositsTrie, -1),
+	}, nil
+}
+
+// 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 (c *Cache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
+	c.depositsLock.RLock()
+	defer c.depositsLock.RUnlock()
+
+	return c.allDeposits(untilBlk)
+}
+
+func (c *Cache) allDeposits(untilBlk *big.Int) []*ethpb.Deposit {
+	var deposits []*ethpb.Deposit
+	for _, ctnr := range c.deposits {
+		cBlk := big.NewInt(0).SetUint64(ctnr.Eth1BlockHeight)
+		if untilBlk == nil || untilBlk.Cmp(cBlk) >= 0 {
+			deposits = append(deposits, ctnr.Deposit)
+		}
+	}
+	return deposits
+}
+
+// AllDepositContainers returns all historical deposit containers.
+func (c *Cache) AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer {
+	ctx, span := trace.StartSpan(ctx, "Cache.AllDepositContainers")
+	defer span.End()
+	c.depositsLock.RLock()
+	defer c.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(c.deposits))
+	copy(deposits, c.deposits)
+	return deposits
+}
+
+// DepositByPubkey looks through historical deposits and finds one which contains
+// a certain public key within its deposit data.
+func (c *Cache) DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int) {
+	ctx, span := trace.StartSpan(ctx, "Cache.DepositByPubkey")
+	defer span.End()
+	c.depositsLock.RLock()
+	defer c.depositsLock.RUnlock()
+
+	var deposit *ethpb.Deposit
+	var blockNum *big.Int
+	deps, ok := c.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
+}
+
+// DepositsNumberAndRootAtHeight returns number of deposits made up to blockheight and the
+// root that corresponds to the latest deposit at that blockheight.
+func (c *Cache) DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte) {
+	ctx, span := trace.StartSpan(ctx, "Cache.DepositsNumberAndRootAtHeight")
+	defer span.End()
+	c.depositsLock.RLock()
+	defer c.depositsLock.RUnlock()
+	heightIdx := sort.Search(len(c.deposits), func(i int) bool {
+		dBlkHeight := big.NewInt(0).SetUint64(c.deposits[i].Eth1BlockHeight)
+		return dBlkHeight.Cmp(blockHeight) > 0
+	})
+	// 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(c.deposits[heightIdx-1].DepositRoot)
+}
+
+// FinalizedDeposits returns the finalized deposits trie.
+func (c *Cache) FinalizedDeposits(ctx context.Context) (cache.FinalizedDeposits, error) {
+	ctx, span := trace.StartSpan(ctx, "Cache.FinalizedDeposits")
+	defer span.End()
+	c.depositsLock.RLock()
+	defer c.depositsLock.RUnlock()
+
+	tree, err := c.finalizedDeposits.depositTree.Copy()
+	if err != nil {
+		return nil, err
+	}
+	return &finalizedDepositsContainer{
+		depositTree:     tree,
+		merkleTrieIndex: c.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 (c *Cache) NonFinalizedDeposits(ctx context.Context, lastFinalizedIndex int64, untilBlk *big.Int) []*ethpb.Deposit {
+	ctx, span := trace.StartSpan(ctx, "Cache.NonFinalizedDeposits")
+	defer span.End()
+	c.depositsLock.RLock()
+	defer c.depositsLock.RUnlock()
+
+	if c.finalizedDeposits.depositTree == nil {
+		return c.allDeposits(untilBlk)
+	}
+
+	var deposits []*ethpb.Deposit
+	for _, d := range c.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 (c *Cache) PruneProofs(ctx context.Context, untilDepositIndex int64) error {
+	ctx, span := trace.StartSpan(ctx, "Cache.PruneProofs")
+	defer span.End()
+	c.depositsLock.Lock()
+	defer c.depositsLock.Unlock()
+
+	if untilDepositIndex >= int64(len(c.deposits)) {
+		untilDepositIndex = int64(len(c.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 c.deposits[i].Deposit.Proof == nil {
+			break
+		}
+		c.deposits[i].Deposit.Proof = nil
+	}
+
+	return nil
+}
+
+// PrunePendingDeposits removes any deposit which is older than the given deposit merkle tree index.
+func (c *Cache) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64) {
+	ctx, span := trace.StartSpan(ctx, "Cache.PrunePendingDeposits")
+	defer span.End()
+
+	if merkleTreeIndex == 0 {
+		log.Debug("Ignoring 0 deposit removal")
+		return
+	}
+
+	c.depositsLock.Lock()
+	defer c.depositsLock.Unlock()
+
+	cleanDeposits := make([]*ethpb.DepositContainer, 0, len(c.pendingDeposits))
+	for _, dp := range c.pendingDeposits {
+		if dp.Index >= merkleTreeIndex {
+			cleanDeposits = append(cleanDeposits, dp)
+		}
+	}
+
+	c.pendingDeposits = cleanDeposits
+	pendingDepositsCount.Set(float64(len(c.pendingDeposits)))
+}
+
+// InsertPendingDeposit into the database. If deposit or block number are nil
+// then this method does nothing.
+func (c *Cache) InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) {
+	ctx, span := trace.StartSpan(ctx, "Cache.InsertPendingDeposit")
+	defer span.End()
+	if d == nil {
+		log.WithFields(logrus.Fields{
+			"block":   blockNum,
+			"deposit": d,
+		}).Debug("Ignoring nil deposit insertion")
+		return
+	}
+	c.depositsLock.Lock()
+	defer c.depositsLock.Unlock()
+	c.pendingDeposits = append(c.pendingDeposits,
+		&ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, Index: index, DepositRoot: depositRoot[:]})
+	pendingDepositsCount.Set(float64(len(c.pendingDeposits)))
+	span.AddAttributes(trace.Int64Attribute("count", int64(len(c.pendingDeposits))))
+}
+
+// Deposits returns the cached internal deposit tree.
+func (fd *finalizedDepositsContainer) Deposits() cache.MerkleTree {
+	return fd.depositTree
+}
+
+// MerkleTrieIndex represents the last finalized index in
+// the finalized deposit container.
+func (fd *finalizedDepositsContainer) MerkleTrieIndex() int64 {
+	return fd.merkleTrieIndex
+}
+
+func toFinalizedDepositsContainer(deposits *DepositTree, index int64) finalizedDepositsContainer {
+	return finalizedDepositsContainer{
+		depositTree:     deposits,
+		merkleTrieIndex: index,
+	}
+}
+
+// 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 (c *Cache) PendingDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
+	ctx, span := trace.StartSpan(ctx, "Cache.PendingDeposits")
+	defer span.End()
+
+	depositCntrs := c.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 (c *Cache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer {
+	ctx, span := trace.StartSpan(ctx, "Cache.PendingContainers")
+	defer span.End()
+	c.depositsLock.RLock()
+	defer c.depositsLock.RUnlock()
+
+	depositCntrs := make([]*ethpb.DepositContainer, 0, len(c.pendingDeposits))
+	for _, ctnr := range c.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
+}

beacon-chain/cache/depositsnapshot/deposit_inserter.go

@@ -0,0 +1,134 @@
+package depositsnapshot
+
+import (
+	"context"
+	"encoding/hex"
+	"sort"
+
+	"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/v4/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+)
+
+var (
+	historicalDepositsCount = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "beacondb_all_deposits_eip4881",
+		Help: "The number of total deposits in memory",
+	})
+	log = logrus.WithField("prefix", "cache")
+)
+
+// InsertDeposit into the database. If deposit or block number are nil
+// then this method does nothing.
+func (c *Cache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "Cache.InsertDeposit")
+	defer span.End()
+	if d == nil {
+		log.WithFields(logrus.Fields{
+			"block":        blockNum,
+			"deposit":      d,
+			"index":        index,
+			"deposit root": hex.EncodeToString(depositRoot[:]),
+		}).Warn("Ignoring nil deposit insertion")
+		return errors.New("nil deposit inserted into the cache")
+	}
+	c.depositsLock.Lock()
+	defer c.depositsLock.Unlock()
+
+	if int(index) != len(c.deposits) {
+		return errors.Errorf("wanted deposit with index %d to be inserted but received %d", len(c.deposits), index)
+	}
+	// Keep the slice sorted on insertion in order to avoid costly sorting on retrieval.
+	heightIdx := sort.Search(len(c.deposits), func(i int) bool { return c.deposits[i].Index >= index })
+	depCtr := &ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}
+	newDeposits := append(
+		[]*ethpb.DepositContainer{depCtr},
+		c.deposits[heightIdx:]...)
+	c.deposits = append(c.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)
+	c.depositsByKey[pubkey] = append(c.depositsByKey[pubkey], depCtr)
+	historicalDepositsCount.Inc()
+	return nil
+}
+
+// InsertDepositContainers inserts a set of deposit containers into our deposit cache.
+func (c *Cache) InsertDepositContainers(ctx context.Context, ctrs []*ethpb.DepositContainer) {
+	ctx, span := trace.StartSpan(ctx, "Cache.InsertDepositContainers")
+	defer span.End()
+	c.depositsLock.Lock()
+	defer c.depositsLock.Unlock()
+
+	// Initialize slice if nil object provided.
+	if ctrs == nil {
+		ctrs = make([]*ethpb.DepositContainer, 0)
+	}
+	sort.SliceStable(ctrs, func(i int, j int) bool { return ctrs[i].Index < ctrs[j].Index })
+	c.deposits = ctrs
+	for _, ctr := range ctrs {
+		// Use a new value, as the reference
+		// changes in the next iteration.
+		newPtr := ctr
+		pKey := bytesutil.ToBytes48(newPtr.Deposit.Data.PublicKey)
+		c.depositsByKey[pKey] = append(c.depositsByKey[pKey], newPtr)
+	}
+	historicalDepositsCount.Add(float64(len(ctrs)))
+}
+
+// InsertFinalizedDeposits inserts deposits up to eth1DepositIndex (inclusive) into the finalized deposits cache.
+func (c *Cache) InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64,
+	executionHash common.Hash, executionNumber uint64) error {
+	ctx, span := trace.StartSpan(ctx, "Cache.InsertFinalizedDeposits")
+	defer span.End()
+	c.depositsLock.Lock()
+	defer c.depositsLock.Unlock()
+
+	depositTrie := c.finalizedDeposits.depositTree
+	insertIndex := int(c.finalizedDeposits.MerkleTrieIndex() + 1)
+
+	// Don't insert into finalized trie if there is no deposit to
+	// insert.
+	if len(c.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(c.deposits) <= int(eth1DepositIndex) {
+		eth1DepositIndex = int64(len(c.deposits)) - 1
+	}
+	// If we finalize to some lower deposit index, we
+	// ignore it.
+	if int(eth1DepositIndex) < insertIndex {
+		return nil
+	}
+	currIdx := int64(depositTrie.depositCount) - 1
+
+	// Insert deposits into deposit trie.
+	for _, ctr := range c.deposits {
+		if ctr.Index > currIdx && ctr.Index <= eth1DepositIndex {
+			rt, err := ctr.Deposit.Data.HashTreeRoot()
+			if err != nil {
+				return err
+			}
+			if err := depositTrie.Insert(rt[:], int(ctr.Index)); err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := depositTrie.Finalize(eth1DepositIndex, executionHash, executionNumber); err != nil {
+		return err
+	}
+
+	c.finalizedDeposits = finalizedDepositsContainer{
+		depositTree:     depositTrie,
+		merkleTrieIndex: eth1DepositIndex,
+	}
+	return nil
+}

beacon-chain/cache/depositsnapshot/deposit_tree.go

@@ -4,12 +4,14 @@
 package depositsnapshot
 
 import (
-	"crypto/sha256"
+	"encoding/binary"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/math"
-	eth "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
+	protodb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
 var (
@@ -17,12 +19,10 @@ var (
 	ErrEmptyExecutionBlock = errors.New("empty execution block")
 	// ErrInvalidSnapshotRoot occurs when the snapshot root does not match the calculated root.
 	ErrInvalidSnapshotRoot = errors.New("snapshot root is invalid")
-	// ErrInvalidMixInLength occurs when the value for mix in length is 0.
-	ErrInvalidMixInLength = errors.New("mixInLength should be greater than 0")
+	// ErrInvalidDepositCount occurs when the value for mix in length is 0.
+	ErrInvalidDepositCount = errors.New("deposit count should be greater than 0")
 	// ErrInvalidIndex occurs when the index is less than the number of finalized deposits.
 	ErrInvalidIndex = errors.New("index should be greater than finalizedDeposits - 1")
-	// ErrNoDeposits occurs when the number of deposits is 0.
-	ErrNoDeposits = errors.New("number of deposits should be greater than 0")
 	// ErrTooManyDeposits occurs when the number of deposits exceeds the capacity of the tree.
 	ErrTooManyDeposits = errors.New("number of deposits should not be greater than the capacity of the tree")
 )
@@ -30,7 +30,7 @@ var (
 // DepositTree is the Merkle tree representation of deposits.
 type DepositTree struct {
 	tree                    MerkleTreeNode
-	mixInLength             uint64 // number of deposits in the tree, reference implementation calls this mix_in_length.
+	depositCount            uint64 // number of deposits in the tree, reference implementation calls this mix_in_length.
 	finalizedExecutionBlock executionBlock
 }
 
@@ -39,82 +39,67 @@ type executionBlock struct {
 	Depth uint64
 }
 
-// New creates an empty deposit tree.
-//
-//nolint:unused
-func New() *DepositTree {
+// NewDepositTree creates an empty deposit tree.
+func NewDepositTree() *DepositTree {
 	var leaves [][32]byte
 	merkle := create(leaves, DepositContractDepth)
 	return &DepositTree{
 		tree:                    merkle,
-		mixInLength:             0,
+		depositCount:            0,
 		finalizedExecutionBlock: executionBlock{},
 	}
 }
 
-// getSnapshot returns a deposit tree snapshot.
-//
-//nolint:unused
-func (d *DepositTree) getSnapshot() (DepositTreeSnapshot, error) {
-	if d.finalizedExecutionBlock == (executionBlock{}) {
-		return DepositTreeSnapshot{}, ErrEmptyExecutionBlock
-	}
+// GetSnapshot returns a deposit tree snapshot.
+func (d *DepositTree) GetSnapshot() (DepositTreeSnapshot, error) {
 	var finalized [][32]byte
 	depositCount, finalized := d.tree.GetFinalized(finalized)
 	return fromTreeParts(finalized, depositCount, d.finalizedExecutionBlock)
 }
 
 // fromSnapshot returns a deposit tree from a deposit tree snapshot.
-//
-//nolint:unused
-func fromSnapshot(snapshot DepositTreeSnapshot) (DepositTree, error) {
+func fromSnapshot(snapshot DepositTreeSnapshot) (*DepositTree, error) {
 	root, err := snapshot.CalculateRoot()
 	if err != nil {
-		return DepositTree{}, err
+		return nil, err
 	}
 	if snapshot.depositRoot != root {
-		return DepositTree{}, ErrInvalidSnapshotRoot
+		return nil, ErrInvalidSnapshotRoot
 	}
 	if snapshot.depositCount >= math.PowerOf2(uint64(DepositContractDepth)) {
-		return DepositTree{}, ErrTooManyDeposits
+		return nil, ErrTooManyDeposits
 	}
 	tree, err := fromSnapshotParts(snapshot.finalized, snapshot.depositCount, DepositContractDepth)
 	if err != nil {
-		return DepositTree{}, err
+		return nil, err
 	}
-	if snapshot.depositCount == 0 {
-		return DepositTree{}, ErrNoDeposits
-	}
-	return DepositTree{
+	return &DepositTree{
 		tree:                    tree,
-		mixInLength:             snapshot.depositCount,
+		depositCount:            snapshot.depositCount,
 		finalizedExecutionBlock: snapshot.executionBlock,
 	}, nil
 }
 
-// finalize marks a deposit as finalized.
-//
-//nolint:unused
-func (d *DepositTree) finalize(eth1data *eth.Eth1Data, executionBlockHeight uint64) error {
+// Finalize marks a deposit as finalized.
+func (d *DepositTree) Finalize(eth1DepositIndex int64, executionHash common.Hash, executionNumber uint64) error {
 	var blockHash [32]byte
-	copy(blockHash[:], eth1data.BlockHash)
+	copy(blockHash[:], executionHash[:])
 	d.finalizedExecutionBlock = executionBlock{
 		Hash:  blockHash,
-		Depth: executionBlockHeight,
+		Depth: executionNumber,
 	}
-	_, err := d.tree.Finalize(eth1data.DepositCount, DepositContractDepth)
+	depositCount := uint64(eth1DepositIndex + 1)
+	_, err := d.tree.Finalize(depositCount, DepositContractDepth)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-// getProof returns the Deposit tree proof.
-//
-//nolint:unused
+// getProof returns the deposit tree proof.
 func (d *DepositTree) getProof(index uint64) ([32]byte, [][32]byte, error) {
-	if d.mixInLength <= 0 {
-		return [32]byte{}, nil, ErrInvalidMixInLength
+	if d.depositCount <= 0 {
+		return [32]byte{}, nil, ErrInvalidDepositCount
 	}
 	finalizedDeposits, _ := d.tree.GetFinalized([][32]byte{})
 	if finalizedDeposits != 0 {
@@ -125,28 +110,81 @@ func (d *DepositTree) getProof(index uint64) ([32]byte, [][32]byte, error) {
 	}
 	leaf, proof := generateProof(d.tree, index, DepositContractDepth)
 	var mixInLength [32]byte
-	copy(mixInLength[:], bytesutil.Uint64ToBytesLittleEndian32(d.mixInLength))
+	copy(mixInLength[:], bytesutil.Uint64ToBytesLittleEndian32(d.depositCount))
 	proof = append(proof, mixInLength)
 	return leaf, proof, nil
 }
 
 // getRoot returns the root of the deposit tree.
-//
-//nolint:unused
 func (d *DepositTree) getRoot() [32]byte {
+	var enc [32]byte
+	binary.LittleEndian.PutUint64(enc[:], d.depositCount)
+
 	root := d.tree.GetRoot()
-	return sha256.Sum256(append(root[:], bytesutil.Uint64ToBytesLittleEndian32(d.mixInLength)...))
+	return hash.Hash(append(root[:], enc[:]...))
 }
 
 // pushLeaf adds a new leaf to the tree.
-//
-//nolint:unused
 func (d *DepositTree) pushLeaf(leaf [32]byte) error {
 	var err error
 	d.tree, err = d.tree.PushLeaf(leaf, DepositContractDepth)
 	if err != nil {
 		return err
 	}
-	d.mixInLength++
+	d.depositCount++
 	return nil
 }
+
+// Insert is defined as part of MerkleTree interface and adds a new leaf to the tree.
+func (d *DepositTree) Insert(item []byte, _ int) error {
+	var leaf [32]byte
+	copy(leaf[:], item[:32])
+	return d.pushLeaf(leaf)
+}
+
+// HashTreeRoot is defined as part of MerkleTree interface and calculates the hash tree root.
+func (d *DepositTree) HashTreeRoot() ([32]byte, error) {
+	root := d.getRoot()
+	if root == [32]byte{} {
+		return [32]byte{}, errors.New("could not retrieve hash tree root")
+	}
+	return root, nil
+}
+
+// NumOfItems is defined as part of MerkleTree interface and returns the number of deposits in the tree.
+func (d *DepositTree) NumOfItems() int {
+	return int(d.depositCount)
+}
+
+// MerkleProof is defined as part of MerkleTree interface and generates a merkle proof.
+func (d *DepositTree) MerkleProof(index int) ([][]byte, error) {
+	_, proof, err := d.getProof(uint64(index))
+	if err != nil {
+		return nil, err
+	}
+	byteSlices := make([][]byte, len(proof))
+	for i, p := range proof {
+		copied := p
+		byteSlices[i] = copied[:]
+	}
+	return byteSlices, nil
+}
+
+// Copy performs a deep copy of the tree.
+func (d *DepositTree) Copy() (*DepositTree, error) {
+	snapshot, err := d.GetSnapshot()
+	if err != nil {
+		return nil, err
+	}
+	return fromSnapshot(snapshot)
+}
+
+// ToProto returns a proto object of the deposit snapshot of
+// the tree.
+func (d *DepositTree) ToProto() (*protodb.DepositSnapshot, error) {
+	snapshot, err := d.GetSnapshot()
+	if err != nil {
+		return nil, err
+	}
+	return snapshot.ToProto(), nil
+}

beacon-chain/cache/depositsnapshot/deposit_tree_snapshot.go

@@ -1,21 +1,13 @@
 package depositsnapshot
 
 import (
-	"crypto/sha256"
-
-	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/container/trie"
+	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
+	protodb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
-var (
-	// ErrZeroIndex occurs when the value of index is 0.
-	ErrZeroIndex = errors.New("index should be greater than 0")
-)
-
-// DepositTreeSnapshot represents the data used to create a
-// deposit tree given a snapshot.
-//
-//nolint:unused
+// DepositTreeSnapshot represents the data used to create a deposit tree given a snapshot.
 type DepositTreeSnapshot struct {
 	finalized      [][32]byte
 	depositRoot    [32]byte
@@ -27,29 +19,27 @@ type DepositTreeSnapshot struct {
 func (ds *DepositTreeSnapshot) CalculateRoot() ([32]byte, error) {
 	size := ds.depositCount
 	index := len(ds.finalized)
-	root := Zerohashes[0]
+	root := trie.ZeroHashes[0]
 	for i := 0; i < DepositContractDepth; i++ {
 		if (size & 1) == 1 {
 			if index == 0 {
-				return [32]byte{}, ErrZeroIndex
+				break
 			}
 			index--
-			root = sha256.Sum256(append(ds.finalized[index][:], root[:]...))
+			root = hash.Hash(append(ds.finalized[index][:], root[:]...))
 		} else {
-			root = sha256.Sum256(append(root[:], Zerohashes[i][:]...))
+			root = hash.Hash(append(root[:], trie.ZeroHashes[i][:]...))
 		}
 		size >>= 1
 	}
-	return sha256.Sum256(append(root[:], bytesutil.Uint64ToBytesLittleEndian32(ds.depositCount)...)), nil
+	return hash.Hash(append(root[:], bytesutil.Uint64ToBytesLittleEndian32(ds.depositCount)...)), nil
 }
 
 // fromTreeParts constructs the deposit tree from pre-existing data.
-//
-//nolint:unused
 func fromTreeParts(finalised [][32]byte, depositCount uint64, executionBlock executionBlock) (DepositTreeSnapshot, error) {
 	snapshot := DepositTreeSnapshot{
 		finalized:      finalised,
-		depositRoot:    Zerohashes[0],
+		depositRoot:    trie.ZeroHashes[0],
 		depositCount:   depositCount,
 		executionBlock: executionBlock,
 	}
@@ -60,3 +50,36 @@ func fromTreeParts(finalised [][32]byte, depositCount uint64, executionBlock exe
 	snapshot.depositRoot = root
 	return snapshot, nil
 }
+
+// ToProto converts the underlying trie into its corresponding proto object.
+func (ds *DepositTreeSnapshot) ToProto() *protodb.DepositSnapshot {
+	tree := &protodb.DepositSnapshot{
+		Finalized:      make([][]byte, len(ds.finalized)),
+		DepositRoot:    bytesutil.SafeCopyBytes(ds.depositRoot[:]),
+		DepositCount:   ds.depositCount,
+		ExecutionHash:  bytesutil.SafeCopyBytes(ds.executionBlock.Hash[:]),
+		ExecutionDepth: ds.executionBlock.Depth,
+	}
+	for i := range ds.finalized {
+		tree.Finalized[i] = bytesutil.SafeCopyBytes(ds.finalized[i][:])
+	}
+	return tree
+}
+
+// DepositTreeFromSnapshotProto generates a deposit tree object from a provided snapshot.
+func DepositTreeFromSnapshotProto(snapshotProto *protodb.DepositSnapshot) (*DepositTree, error) {
+	finalized := make([][32]byte, len(snapshotProto.Finalized))
+	for i := range snapshotProto.Finalized {
+		finalized[i] = bytesutil.ToBytes32(snapshotProto.Finalized[i])
+	}
+	snapshot := DepositTreeSnapshot{
+		finalized:    finalized,
+		depositRoot:  bytesutil.ToBytes32(snapshotProto.DepositRoot),
+		depositCount: snapshotProto.DepositCount,
+		executionBlock: executionBlock{
+			Hash:  bytesutil.ToBytes32(snapshotProto.ExecutionHash),
+			Depth: snapshotProto.ExecutionDepth,
+		},
+	}
+	return fromSnapshot(snapshot)
+}

beacon-chain/cache/depositsnapshot/merkle_tree.go

@@ -3,6 +3,7 @@ package depositsnapshot
 import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/container/slice"
+	"github.com/prysmaticlabs/prysm/v4/container/trie"
 	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/math"
 )
@@ -58,9 +59,8 @@ func create(leaves [][32]byte, depth uint64) MerkleTreeNode {
 }
 
 // fromSnapshotParts creates a new Merkle tree from a list of finalized leaves, number of deposits and specified depth.
-//
-//nolint:unused
-func fromSnapshotParts(finalized [][32]byte, deposits uint64, level uint64) (_ MerkleTreeNode, err error) {
+func fromSnapshotParts(finalized [][32]byte, deposits uint64, level uint64) (MerkleTreeNode, error) {
+	var err error
 	if len(finalized) < 1 || deposits == 0 {
 		return &ZeroNode{
 			depth: level,
@@ -96,8 +96,6 @@ func fromSnapshotParts(finalized [][32]byte, deposits uint64, level uint64) (_ M
 }
 
 // generateProof returns a merkle proof and root
-//
-//nolint:unused
 func generateProof(tree MerkleTreeNode, index uint64, depth uint64) ([32]byte, [][32]byte) {
 	var proof [][32]byte
 	node := tree
@@ -219,7 +217,8 @@ func (n *InnerNode) IsFull() bool {
 }
 
 // Finalize marks deposits of the Merkle tree as finalized.
-func (n *InnerNode) Finalize(depositsToFinalize uint64, depth uint64) (_ MerkleTreeNode, err error) {
+func (n *InnerNode) Finalize(depositsToFinalize uint64, depth uint64) (MerkleTreeNode, error) {
+	var err error
 	deposits := math.PowerOf2(depth)
 	if deposits <= depositsToFinalize {
 		return &FinalizedNode{deposits, n.GetRoot()}, nil
@@ -286,9 +285,9 @@ type ZeroNode struct {
 // GetRoot returns the root of the Merkle tree.
 func (z *ZeroNode) GetRoot() [32]byte {
 	if z.depth == DepositContractDepth {
-		return hash.Hash(append(Zerohashes[z.depth-1][:], Zerohashes[z.depth-1][:]...))
+		return hash.Hash(append(trie.ZeroHashes[z.depth-1][:], trie.ZeroHashes[z.depth-1][:]...))
 	}
-	return Zerohashes[z.depth]
+	return trie.ZeroHashes[z.depth]
 }
 
 // IsFull returns wh   ether there is space left for deposits.
@@ -300,7 +299,7 @@ func (_ *ZeroNode) IsFull() bool {
 
 // Finalize marks deposits of the Merkle tree as finalized.
 func (_ *ZeroNode) Finalize(depositsToFinalize uint64, depth uint64) (MerkleTreeNode, error) {
-	return nil, nil
+	return &ZeroNode{}, nil
 }
 
 // GetFinalized returns a list of hashes of all the finalized nodes and the number of deposits.

beacon-chain/cache/depositsnapshot/merkle_tree_test.go

@@ -6,6 +6,8 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v4/container/trie"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
 )
@@ -60,45 +62,54 @@ func Test_fromSnapshotParts(t *testing.T) {
 	tests := []struct {
 		name      string
 		finalized [][32]byte
-		deposits  uint64
-		level     uint64
-		want      MerkleTreeNode
 	}{
 		{
-			name:      "empty",
-			finalized: nil,
-			deposits:  0,
-			level:     0,
-			want:      &ZeroNode{},
-		},
-		{
-			name:      "single finalized node",
-			finalized: [][32]byte{hexString(t, fmt.Sprintf("%064d", 0))},
-			deposits:  1,
-			level:     0,
-			want: &FinalizedNode{
-				depositCount: 1,
-				hash:         [32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-			},
-		},
-		{
-			name:      "multiple deposits and 1 Finalized",
-			finalized: [][32]byte{hexString(t, fmt.Sprintf("%064d", 0))},
-			deposits:  2,
-			level:     4,
-			want: &InnerNode{
-				left:  &InnerNode{&InnerNode{&FinalizedNode{depositCount: 2, hash: hexString(t, fmt.Sprintf("%064d", 0))}, &ZeroNode{1}}, &ZeroNode{2}},
-				right: &ZeroNode{3},
-			},
+			name:      "multiple deposits and multiple Finalized",
+			finalized: [][32]byte{hexString(t, fmt.Sprintf("%064d", 1)), hexString(t, fmt.Sprintf("%064d", 2))},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			tree, err := fromSnapshotParts(tt.finalized, tt.deposits, tt.level)
-			require.NoError(t, err)
-			if got := tree; !reflect.DeepEqual(got, tt.want) {
-				require.DeepEqual(t, tt.want, got)
+			test := NewDepositTree()
+			for _, leaf := range tt.finalized {
+				err := test.pushLeaf(leaf)
+				require.NoError(t, err)
 			}
+			got, err := test.HashTreeRoot()
+			require.NoError(t, err)
+
+			transformed := make([][]byte, len(tt.finalized))
+			for i := 0; i < len(tt.finalized); i++ {
+				transformed[i] = bytesutil.SafeCopyBytes(tt.finalized[i][:])
+			}
+			generatedTrie, err := trie.GenerateTrieFromItems(transformed, 32)
+			require.NoError(t, err)
+
+			want, err := generatedTrie.HashTreeRoot()
+			require.NoError(t, err)
+
+			require.Equal(t, want, got)
+
+			// Test finalization
+			for i := 0; i < len(tt.finalized); i++ {
+				err = test.Finalize(int64(i), tt.finalized[i], 0)
+				require.NoError(t, err)
+			}
+
+			sShot, err := test.GetSnapshot()
+			require.NoError(t, err)
+			got, err = sShot.CalculateRoot()
+			require.NoError(t, err)
+
+			require.Equal(t, 1, len(sShot.finalized))
+			require.Equal(t, want, got)
+
+			// Build from the snapshot once more
+			recovered, err := fromSnapshot(sShot)
+			require.NoError(t, err)
+			got, err = recovered.HashTreeRoot()
+			require.NoError(t, err)
+			require.Equal(t, want, got)
 		})
 	}
 }
@@ -125,7 +136,7 @@ func Test_generateProof(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			testCases, err := readTestCases()
 			require.NoError(t, err)
-			tree := New()
+			tree := NewDepositTree()
 			for _, c := range testCases[:tt.leaves] {
 				err = tree.pushLeaf(c.DepositDataRoot)
 				require.NoError(t, err)

beacon-chain/cache/depositsnapshot/spec_test.go

@@ -1,16 +1,18 @@
 package depositsnapshot
 
 import (
-	"crypto/sha256"
 	"encoding/hex"
+	"fmt"
 	"strconv"
 	"strings"
 	"testing"
 
 	"github.com/bazelbuild/rules_go/go/tools/bazel"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/container/trie"
+	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/io/file"
-	eth "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
 	"gopkg.in/yaml.v3"
 )
@@ -176,6 +178,9 @@ func readTestCases() ([]testCase, error) {
 			if err != nil {
 				return []testCase{}, err
 			}
+			if len(testCases) == 0 {
+				return nil, errors.New("no test cases found")
+			}
 			return testCases, nil
 		}
 	}
@@ -183,11 +188,8 @@ func readTestCases() ([]testCase, error) {
 }
 
 func TestRead(t *testing.T) {
-	tcs, err := readTestCases()
+	_, err := readTestCases()
 	require.NoError(t, err)
-	for _, tc := range tcs {
-		t.Log(tc)
-	}
 }
 
 func hexStringToByteArray(s string) (b [32]byte, err error) {
@@ -222,9 +224,9 @@ func merkleRootFromBranch(leaf [32]byte, branch [][32]byte, index uint64) [32]by
 	for i, l := range branch {
 		ithBit := (index >> i) & 0x1
 		if ithBit == 1 {
-			root = sha256.Sum256(append(l[:], root[:]...))
+			root = hash.Hash(append(l[:], root[:]...))
 		} else {
-			root = sha256.Sum256(append(root[:], l[:]...))
+			root = hash.Hash(append(root[:], l[:]...))
 		}
 	}
 	return root
@@ -250,11 +252,11 @@ func cloneFromSnapshot(t *testing.T, snapshot DepositTreeSnapshot, testCases []t
 		err = cp.pushLeaf(c.DepositDataRoot)
 		require.NoError(t, err)
 	}
-	return &cp
+	return cp
 }
 
 func TestDepositCases(t *testing.T) {
-	tree := New()
+	tree := NewDepositTree()
 	testCases, err := readTestCases()
 	require.NoError(t, err)
 	for _, c := range testCases {
@@ -263,8 +265,35 @@ func TestDepositCases(t *testing.T) {
 	}
 }
 
+type Test struct {
+	DepositDataRoot [32]byte
+}
+
+func TestRootEquivalence(t *testing.T) {
+	var err error
+	tree := NewDepositTree()
+	testCases, err := readTestCases()
+	require.NoError(t, err)
+
+	transformed := make([][]byte, len(testCases[:128]))
+	for i, c := range testCases[:128] {
+		err = tree.pushLeaf(c.DepositDataRoot)
+		require.NoError(t, err)
+		transformed[i] = bytesutil.SafeCopyBytes(c.DepositDataRoot[:])
+	}
+	originalRoot, err := tree.HashTreeRoot()
+	require.NoError(t, err)
+
+	generatedTrie, err := trie.GenerateTrieFromItems(transformed, 32)
+	require.NoError(t, err)
+
+	rootA, err := generatedTrie.HashTreeRoot()
+	require.NoError(t, err)
+	require.Equal(t, rootA, originalRoot)
+}
+
 func TestFinalization(t *testing.T) {
-	tree := New()
+	tree := NewDepositTree()
 	testCases, err := readTestCases()
 	require.NoError(t, err)
 	for _, c := range testCases[:128] {
@@ -273,15 +302,11 @@ func TestFinalization(t *testing.T) {
 	}
 	originalRoot := tree.getRoot()
 	require.DeepEqual(t, testCases[127].Eth1Data.DepositRoot, originalRoot)
-	err = tree.finalize(&eth.Eth1Data{
-		DepositRoot:  testCases[100].Eth1Data.DepositRoot[:],
-		DepositCount: testCases[100].Eth1Data.DepositCount,
-		BlockHash:    testCases[100].Eth1Data.BlockHash[:],
-	}, testCases[100].BlockHeight)
+	err = tree.Finalize(int64(testCases[100].Eth1Data.DepositCount-1), testCases[100].Eth1Data.BlockHash, testCases[100].BlockHeight)
 	require.NoError(t, err)
 	// ensure finalization doesn't change root
 	require.Equal(t, tree.getRoot(), originalRoot)
-	snapshotData, err := tree.getSnapshot()
+	snapshotData, err := tree.GetSnapshot()
 	require.NoError(t, err)
 	require.DeepEqual(t, testCases[100].Snapshot.DepositTreeSnapshot, snapshotData)
 	// create a copy of the tree from a snapshot by replaying
@@ -290,20 +315,16 @@ func TestFinalization(t *testing.T) {
 	// ensure original and copy have the same root
 	require.Equal(t, tree.getRoot(), cp.getRoot())
 	//	finalize original again to check double finalization
-	err = tree.finalize(&eth.Eth1Data{
-		DepositRoot:  testCases[105].Eth1Data.DepositRoot[:],
-		DepositCount: testCases[105].Eth1Data.DepositCount,
-		BlockHash:    testCases[105].Eth1Data.BlockHash[:],
-	}, testCases[105].BlockHeight)
+	err = tree.Finalize(int64(testCases[105].Eth1Data.DepositCount-1), testCases[105].Eth1Data.BlockHash, testCases[105].BlockHeight)
 	require.NoError(t, err)
 	//	root should still be the same
 	require.Equal(t, originalRoot, tree.getRoot())
 	// create a copy of the tree by taking a snapshot again
-	snapshotData, err = tree.getSnapshot()
+	snapshotData, err = tree.GetSnapshot()
 	require.NoError(t, err)
 	cp = cloneFromSnapshot(t, snapshotData, testCases[106:128])
 	// create a copy of the tree by replaying ALL deposits from nothing
-	fullTreeCopy := New()
+	fullTreeCopy := NewDepositTree()
 	for _, c := range testCases[:128] {
 		err = fullTreeCopy.pushLeaf(c.DepositDataRoot)
 		require.NoError(t, err)
@@ -315,7 +336,7 @@ func TestFinalization(t *testing.T) {
 }
 
 func TestSnapshotCases(t *testing.T) {
-	tree := New()
+	tree := NewDepositTree()
 	testCases, err := readTestCases()
 	require.NoError(t, err)
 	for _, c := range testCases {
@@ -323,33 +344,29 @@ func TestSnapshotCases(t *testing.T) {
 		require.NoError(t, err)
 	}
 	for _, c := range testCases {
-		err = tree.finalize(&eth.Eth1Data{
-			DepositRoot:  c.Eth1Data.DepositRoot[:],
-			DepositCount: c.Eth1Data.DepositCount,
-			BlockHash:    c.Eth1Data.BlockHash[:],
-		}, c.BlockHeight)
+		err = tree.Finalize(int64(c.Eth1Data.DepositCount-1), c.Eth1Data.BlockHash, c.BlockHeight)
 		require.NoError(t, err)
-		s, err := tree.getSnapshot()
+		s, err := tree.GetSnapshot()
 		require.NoError(t, err)
 		require.DeepEqual(t, c.Snapshot.DepositTreeSnapshot, s)
 	}
 }
 
-func TestEmptyTreeSnapshot(t *testing.T) {
-	_, err := New().getSnapshot()
-	require.ErrorContains(t, "empty execution block", err)
-}
-
 func TestInvalidSnapshot(t *testing.T) {
 	invalidSnapshot := DepositTreeSnapshot{
 		finalized:    nil,
-		depositRoot:  Zerohashes[0],
+		depositRoot:  trie.ZeroHashes[0],
 		depositCount: 0,
 		executionBlock: executionBlock{
-			Hash:  Zerohashes[0],
+			Hash:  trie.ZeroHashes[0],
 			Depth: 0,
 		},
 	}
 	_, err := fromSnapshot(invalidSnapshot)
 	require.ErrorContains(t, "snapshot root is invalid", err)
 }
+
+func TestEmptyTree(t *testing.T) {
+	tree := NewDepositTree()
+	require.Equal(t, fmt.Sprintf("%x", tree.getRoot()), "d70a234731285c6804c2a4f56711ddb8c82c99740f207854891028af34e27e5e")
+}

beacon-chain/cache/depositsnapshot/zerohashes.gen.go

@@ -1,69 +0,0 @@
-// Code generated by gen_zerohashes. DO NOT EDIT.
-package depositsnapshot
-
-var Zerohashes = [][32]byte{
-	// 0000000000000000000000000000000000000000000000000000000000000000
-	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-	// f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b
-	{245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169, 39, 89, 251, 75},
-	// db56114e00fdd4c1f85c892bf35ac9a89289aaecb1ebd0a96cde606a748b5d71
-	{219, 86, 17, 78, 0, 253, 212, 193, 248, 92, 137, 43, 243, 90, 201, 168, 146, 137, 170, 236, 177, 235, 208, 169, 108, 222, 96, 106, 116, 139, 93, 113},
-	// c78009fdf07fc56a11f122370658a353aaa542ed63e44c4bc15ff4cd105ab33c
-	{199, 128, 9, 253, 240, 127, 197, 106, 17, 241, 34, 55, 6, 88, 163, 83, 170, 165, 66, 237, 99, 228, 76, 75, 193, 95, 244, 205, 16, 90, 179, 60},
-	// 536d98837f2dd165a55d5eeae91485954472d56f246df256bf3cae19352a123c
-	{83, 109, 152, 131, 127, 45, 209, 101, 165, 93, 94, 234, 233, 20, 133, 149, 68, 114, 213, 111, 36, 109, 242, 86, 191, 60, 174, 25, 53, 42, 18, 60},
-	// 9efde052aa15429fae05bad4d0b1d7c64da64d03d7a1854a588c2cb8430c0d30
-	{158, 253, 224, 82, 170, 21, 66, 159, 174, 5, 186, 212, 208, 177, 215, 198, 77, 166, 77, 3, 215, 161, 133, 74, 88, 140, 44, 184, 67, 12, 13, 48},
-	// d88ddfeed400a8755596b21942c1497e114c302e6118290f91e6772976041fa1
-	{216, 141, 223, 238, 212, 0, 168, 117, 85, 150, 178, 25, 66, 193, 73, 126, 17, 76, 48, 46, 97, 24, 41, 15, 145, 230, 119, 41, 118, 4, 31, 161},
-	// 87eb0ddba57e35f6d286673802a4af5975e22506c7cf4c64bb6be5ee11527f2c
-	{135, 235, 13, 219, 165, 126, 53, 246, 210, 134, 103, 56, 2, 164, 175, 89, 117, 226, 37, 6, 199, 207, 76, 100, 187, 107, 229, 238, 17, 82, 127, 44},
-	// 26846476fd5fc54a5d43385167c95144f2643f533cc85bb9d16b782f8d7db193
-	{38, 132, 100, 118, 253, 95, 197, 74, 93, 67, 56, 81, 103, 201, 81, 68, 242, 100, 63, 83, 60, 200, 91, 185, 209, 107, 120, 47, 141, 125, 177, 147},
-	// 506d86582d252405b840018792cad2bf1259f1ef5aa5f887e13cb2f0094f51e1
-	{80, 109, 134, 88, 45, 37, 36, 5, 184, 64, 1, 135, 146, 202, 210, 191, 18, 89, 241, 239, 90, 165, 248, 135, 225, 60, 178, 240, 9, 79, 81, 225},
-	// ffff0ad7e659772f9534c195c815efc4014ef1e1daed4404c06385d11192e92b
-	{255, 255, 10, 215, 230, 89, 119, 47, 149, 52, 193, 149, 200, 21, 239, 196, 1, 78, 241, 225, 218, 237, 68, 4, 192, 99, 133, 209, 17, 146, 233, 43},
-	// 6cf04127db05441cd833107a52be852868890e4317e6a02ab47683aa75964220
-	{108, 240, 65, 39, 219, 5, 68, 28, 216, 51, 16, 122, 82, 190, 133, 40, 104, 137, 14, 67, 23, 230, 160, 42, 180, 118, 131, 170, 117, 150, 66, 32},
-	// b7d05f875f140027ef5118a2247bbb84ce8f2f0f1123623085daf7960c329f5f
-	{183, 208, 95, 135, 95, 20, 0, 39, 239, 81, 24, 162, 36, 123, 187, 132, 206, 143, 47, 15, 17, 35, 98, 48, 133, 218, 247, 150, 12, 50, 159, 95},
-	// df6af5f5bbdb6be9ef8aa618e4bf8073960867171e29676f8b284dea6a08a85e
-	{223, 106, 245, 245, 187, 219, 107, 233, 239, 138, 166, 24, 228, 191, 128, 115, 150, 8, 103, 23, 30, 41, 103, 111, 139, 40, 77, 234, 106, 8, 168, 94},
-	// b58d900f5e182e3c50ef74969ea16c7726c549757cc23523c369587da7293784
-	{181, 141, 144, 15, 94, 24, 46, 60, 80, 239, 116, 150, 158, 161, 108, 119, 38, 197, 73, 117, 124, 194, 53, 35, 195, 105, 88, 125, 167, 41, 55, 132},
-	// d49a7502ffcfb0340b1d7885688500ca308161a7f96b62df9d083b71fcc8f2bb
-	{212, 154, 117, 2, 255, 207, 176, 52, 11, 29, 120, 133, 104, 133, 0, 202, 48, 129, 97, 167, 249, 107, 98, 223, 157, 8, 59, 113, 252, 200, 242, 187},
-	// 8fe6b1689256c0d385f42f5bbe2027a22c1996e110ba97c171d3e5948de92beb
-	{143, 230, 177, 104, 146, 86, 192, 211, 133, 244, 47, 91, 190, 32, 39, 162, 44, 25, 150, 225, 16, 186, 151, 193, 113, 211, 229, 148, 141, 233, 43, 235},
-	// 8d0d63c39ebade8509e0ae3c9c3876fb5fa112be18f905ecacfecb92057603ab
-	{141, 13, 99, 195, 158, 186, 222, 133, 9, 224, 174, 60, 156, 56, 118, 251, 95, 161, 18, 190, 24, 249, 5, 236, 172, 254, 203, 146, 5, 118, 3, 171},
-	// 95eec8b2e541cad4e91de38385f2e046619f54496c2382cb6cacd5b98c26f5a4
-	{149, 238, 200, 178, 229, 65, 202, 212, 233, 29, 227, 131, 133, 242, 224, 70, 97, 159, 84, 73, 108, 35, 130, 203, 108, 172, 213, 185, 140, 38, 245, 164},
-	// f893e908917775b62bff23294dbbe3a1cd8e6cc1c35b4801887b646a6f81f17f
-	{248, 147, 233, 8, 145, 119, 117, 182, 43, 255, 35, 41, 77, 187, 227, 161, 205, 142, 108, 193, 195, 91, 72, 1, 136, 123, 100, 106, 111, 129, 241, 127},
-	// cddba7b592e3133393c16194fac7431abf2f5485ed711db282183c819e08ebaa
-	{205, 219, 167, 181, 146, 227, 19, 51, 147, 193, 97, 148, 250, 199, 67, 26, 191, 47, 84, 133, 237, 113, 29, 178, 130, 24, 60, 129, 158, 8, 235, 170},
-	// 8a8d7fe3af8caa085a7639a832001457dfb9128a8061142ad0335629ff23ff9c
-	{138, 141, 127, 227, 175, 140, 170, 8, 90, 118, 57, 168, 50, 0, 20, 87, 223, 185, 18, 138, 128, 97, 20, 42, 208, 51, 86, 41, 255, 35, 255, 156},
-	// feb3c337d7a51a6fbf00b9e34c52e1c9195c969bd4e7a0bfd51d5c5bed9c1167
-	{254, 179, 195, 55, 215, 165, 26, 111, 191, 0, 185, 227, 76, 82, 225, 201, 25, 92, 150, 155, 212, 231, 160, 191, 213, 29, 92, 91, 237, 156, 17, 103},
-	// e71f0aa83cc32edfbefa9f4d3e0174ca85182eec9f3a09f6a6c0df6377a510d7
-	{231, 31, 10, 168, 60, 195, 46, 223, 190, 250, 159, 77, 62, 1, 116, 202, 133, 24, 46, 236, 159, 58, 9, 246, 166, 192, 223, 99, 119, 165, 16, 215},
-	// 31206fa80a50bb6abe29085058f16212212a60eec8f049fecb92d8c8e0a84bc0
-	{49, 32, 111, 168, 10, 80, 187, 106, 190, 41, 8, 80, 88, 241, 98, 18, 33, 42, 96, 238, 200, 240, 73, 254, 203, 146, 216, 200, 224, 168, 75, 192},
-	// 21352bfecbeddde993839f614c3dac0a3ee37543f9b412b16199dc158e23b544
-	{33, 53, 43, 254, 203, 237, 221, 233, 147, 131, 159, 97, 76, 61, 172, 10, 62, 227, 117, 67, 249, 180, 18, 177, 97, 153, 220, 21, 142, 35, 181, 68},
-	// 619e312724bb6d7c3153ed9de791d764a366b389af13c58bf8a8d90481a46765
-	{97, 158, 49, 39, 36, 187, 109, 124, 49, 83, 237, 157, 231, 145, 215, 100, 163, 102, 179, 137, 175, 19, 197, 139, 248, 168, 217, 4, 129, 164, 103, 101},
-	// 7cdd2986268250628d0c10e385c58c6191e6fbe05191bcc04f133f2cea72c1c4
-	{124, 221, 41, 134, 38, 130, 80, 98, 141, 12, 16, 227, 133, 197, 140, 97, 145, 230, 251, 224, 81, 145, 188, 192, 79, 19, 63, 44, 234, 114, 193, 196},
-	// 848930bd7ba8cac54661072113fb278869e07bb8587f91392933374d017bcbe1
-	{132, 137, 48, 189, 123, 168, 202, 197, 70, 97, 7, 33, 19, 251, 39, 136, 105, 224, 123, 184, 88, 127, 145, 57, 41, 51, 55, 77, 1, 123, 203, 225},
-	// 8869ff2c22b28cc10510d9853292803328be4fb0e80495e8bb8d271f5b889636
-	{136, 105, 255, 44, 34, 178, 140, 193, 5, 16, 217, 133, 50, 146, 128, 51, 40, 190, 79, 176, 232, 4, 149, 232, 187, 141, 39, 31, 91, 136, 150, 54},
-	// b5fe28e79f1b850f8658246ce9b6a1e7b49fc06db7143e8fe0b4f2b0c5523a5c
-	{181, 254, 40, 231, 159, 27, 133, 15, 134, 88, 36, 108, 233, 182, 161, 231, 180, 159, 192, 109, 183, 20, 62, 143, 224, 180, 242, 176, 197, 82, 58, 92},
-	// 985e929f70af28d0bdd1a90a808f977f597c7c778c489e98d3bd8910d31ac0f7
-	{152, 94, 146, 159, 112, 175, 40, 208, 189, 209, 169, 10, 128, 143, 151, 127, 89, 124, 124, 119, 140, 72, 158, 152, 211, 189, 137, 16, 211, 26, 192, 247},
-}

beacon-chain/cache/interfaces.go

@@ -0,0 +1,57 @@
+package cache
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+)
+
+// DepositCache combines the interfaces for retrieving and inserting deposit information.
+type DepositCache interface {
+	DepositFetcher
+	DepositInserter
+}
+
+// DepositFetcher defines a struct which can retrieve deposit information from a store.
+type DepositFetcher interface {
+	AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
+	AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer
+	DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int)
+	DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte)
+	InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte)
+	PendingDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
+	PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer
+	PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64)
+	PruneProofs(ctx context.Context, untilDepositIndex int64) error
+	FinalizedFetcher
+}
+
+// DepositInserter defines a struct which can insert deposit information from a store.
+type DepositInserter interface {
+	InsertDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) error
+	InsertDepositContainers(ctx context.Context, ctrs []*ethpb.DepositContainer)
+	InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64, executionHash common.Hash, executionNumber uint64) error
+}
+
+// FinalizedFetcher is a smaller interface defined to be the bare minimum to satisfy “Service”.
+// It extends the "DepositFetcher" interface with additional methods for fetching finalized deposits.
+type FinalizedFetcher interface {
+	FinalizedDeposits(ctx context.Context) (FinalizedDeposits, error)
+	NonFinalizedDeposits(ctx context.Context, lastFinalizedIndex int64, untilBlk *big.Int) []*ethpb.Deposit
+}
+
+// FinalizedDeposits defines a method to access a merkle tree containing deposits and their indexes.
+type FinalizedDeposits interface {
+	Deposits() MerkleTree
+	MerkleTrieIndex() int64
+}
+
+// MerkleTree defines methods for constructing and manipulating a merkle tree.
+type MerkleTree interface {
+	HashTreeRoot() ([32]byte, error)
+	NumOfItems() int
+	Insert(item []byte, index int) error
+	MerkleProof(index int) ([][]byte, error)
+}

beacon-chain/core/altair/attestation.go

@@ -289,13 +289,13 @@ func AttestationParticipationFlagIndices(beaconState state.BeaconState, data *et
 	sourceFlagIndex := cfg.TimelySourceFlagIndex
 	targetFlagIndex := cfg.TimelyTargetFlagIndex
 	headFlagIndex := cfg.TimelyHeadFlagIndex
-	slotsPerEpoch := cfg.SlotsPerEpoch
 	sqtRootSlots := cfg.SqrRootSlotsPerEpoch
 	if matchedSrc && delay <= sqtRootSlots {
 		participatedFlags[sourceFlagIndex] = true
 	}
 	matchedSrcTgt := matchedSrc && matchedTgt
-	if matchedSrcTgt && delay <= slotsPerEpoch {
+	// Before Deneb no attestation should pass validation without having delay <= slotsPerEpoch.
+	if matchedSrcTgt {
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt

beacon-chain/core/altair/attestation_test.go

@@ -630,6 +630,9 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 	targetFlagIndex := cfg.TimelyTargetFlagIndex
 	headFlagIndex := cfg.TimelyHeadFlagIndex
 
+	denebState, _ := util.DeterministicGenesisStateDeneb(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	require.NoError(t, denebState.SetSlot(1))
+
 	tests := []struct {
 		name                 string
 		inputState           state.BeaconState
@@ -678,6 +681,34 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				targetFlagIndex: true,
 			},
 		},
+		{
+			name: "participated source and target with delay",
+			inputState: func() state.BeaconState {
+				return beaconState
+			}(),
+			inputData: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
+				Target: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
+			},
+			inputDelay: params.BeaconConfig().SlotsPerEpoch + 1,
+			participationIndices: map[uint8]bool{
+				targetFlagIndex: true,
+			},
+		},
+		{
+			name: "participated source and target with delay in deneb",
+			inputState: func() state.BeaconState {
+				return denebState
+			}(),
+			inputData: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
+				Target: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
+			},
+			inputDelay: params.BeaconConfig().SlotsPerEpoch + 1,
+			participationIndices: map[uint8]bool{
+				targetFlagIndex: true,
+			},
+		},
 		{
 			name: "participated source and target and head",
 			inputState: func() state.BeaconState {
@@ -696,7 +727,6 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 			},
 		},
 	}
-
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
 		require.NoError(t, err)

beacon-chain/core/altair/epoch_precompute.go

@@ -13,6 +13,15 @@ import (
 	"go.opencensus.io/trace"
 )
 
+// AttDelta contains rewards and penalties for a single attestation.
+type AttDelta struct {
+	HeadReward    uint64
+	SourceReward  uint64
+	SourcePenalty uint64
+	TargetReward  uint64
+	TargetPenalty uint64
+}
+
 // InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
 func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconState) ([]*precompute.Validator, *precompute.Balance, error) {
 	ctx, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
@@ -226,7 +235,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 		return beaconState, errors.New("validator registries not the same length as state's validator registries")
 	}
 
-	attsRewards, attsPenalties, err := AttestationsDelta(beaconState, bal, vals)
+	attDeltas, err := AttestationsDelta(beaconState, bal, vals)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attestation delta")
 	}
@@ -237,11 +246,12 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 		// Compute the post balance of the validator after accounting for the
 		// attester and proposer rewards and penalties.
-		balances[i], err = helpers.IncreaseBalanceWithVal(balances[i], attsRewards[i])
+		delta := attDeltas[i]
+		balances[i], err = helpers.IncreaseBalanceWithVal(balances[i], delta.HeadReward+delta.SourceReward+delta.TargetReward)
 		if err != nil {
 			return nil, err
 		}
-		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], attsPenalties[i])
+		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], delta.SourcePenalty+delta.TargetPenalty)
 
 		vals[i].AfterEpochTransitionBalance = balances[i]
 	}
@@ -255,10 +265,8 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 // AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
 // voting records.
-func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
-	numOfVals := beaconState.NumValidators()
-	rewards = make([]uint64, numOfVals)
-	penalties = make([]uint64, numOfVals)
+func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, vals []*precompute.Validator) ([]*AttDelta, error) {
+	attDeltas := make([]*AttDelta, len(vals))
 
 	cfg := params.BeaconConfig()
 	prevEpoch := time.PrevEpoch(beaconState)
@@ -272,29 +280,29 @@ func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, v
 	bias := cfg.InactivityScoreBias
 	inactivityPenaltyQuotient, err := beaconState.InactivityPenaltyQuotient()
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	inactivityDenominator := bias * inactivityPenaltyQuotient
 
 	for i, v := range vals {
-		rewards[i], penalties[i], err = attestationDelta(bal, v, baseRewardMultiplier, inactivityDenominator, leak)
+		attDeltas[i], err = attestationDelta(bal, v, baseRewardMultiplier, inactivityDenominator, leak)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 	}
 
-	return rewards, penalties, nil
+	return attDeltas, nil
 }
 
 func attestationDelta(
 	bal *precompute.Balance,
 	val *precompute.Validator,
 	baseRewardMultiplier, inactivityDenominator uint64,
-	inactivityLeak bool) (reward, penalty uint64, err error) {
+	inactivityLeak bool) (*AttDelta, error) {
 	eligible := val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch)
 	// Per spec `ActiveCurrentEpoch` can't be 0 to process attestation delta.
 	if !eligible || bal.ActiveCurrentEpoch == 0 {
-		return 0, 0, nil
+		return &AttDelta{}, nil
 	}
 
 	cfg := params.BeaconConfig()
@@ -307,32 +315,32 @@ func attestationDelta(
 	srcWeight := cfg.TimelySourceWeight
 	tgtWeight := cfg.TimelyTargetWeight
 	headWeight := cfg.TimelyHeadWeight
-	reward, penalty = uint64(0), uint64(0)
+	attDelta := &AttDelta{}
 	// Process source reward / penalty
 	if val.IsPrevEpochSourceAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * srcWeight * (bal.PrevEpochAttested / increment)
-			reward += n / (activeIncrement * weightDenominator)
+			attDelta.SourceReward += n / (activeIncrement * weightDenominator)
 		}
 	} else {
-		penalty += baseReward * srcWeight / weightDenominator
+		attDelta.SourcePenalty += baseReward * srcWeight / weightDenominator
 	}
 
 	// Process target reward / penalty
 	if val.IsPrevEpochTargetAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * tgtWeight * (bal.PrevEpochTargetAttested / increment)
-			reward += n / (activeIncrement * weightDenominator)
+			attDelta.TargetReward += n / (activeIncrement * weightDenominator)
 		}
 	} else {
-		penalty += baseReward * tgtWeight / weightDenominator
+		attDelta.TargetPenalty += baseReward * tgtWeight / weightDenominator
 	}
 
 	// Process head reward / penalty
 	if val.IsPrevEpochHeadAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * headWeight * (bal.PrevEpochHeadAttested / increment)
-			reward += n / (activeIncrement * weightDenominator)
+			attDelta.HeadReward += n / (activeIncrement * weightDenominator)
 		}
 	}
 
@@ -341,10 +349,10 @@ func attestationDelta(
 	if !val.IsPrevEpochTargetAttester || val.IsSlashed {
 		n, err := math.Mul64(effectiveBalance, val.InactivityScore)
 		if err != nil {
-			return 0, 0, err
+			return &AttDelta{}, err
 		}
-		penalty += n / inactivityDenominator
+		attDelta.TargetPenalty += n / inactivityDenominator
 	}
 
-	return reward, penalty, nil
+	return attDelta, nil
 }

beacon-chain/core/altair/epoch_precompute_test.go

@@ -213,9 +213,16 @@ func TestAttestationsDelta(t *testing.T) {
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	rewards, penalties, err := AttestationsDelta(s, balance, validators)
+	deltas, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
 
+	rewards := make([]uint64, len(deltas))
+	penalties := make([]uint64, len(deltas))
+	for i, d := range deltas {
+		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
+		penalties[i] = d.SourcePenalty + d.TargetPenalty
+	}
+
 	// Reward amount should increase as validator index increases due to setup.
 	for i := 1; i < len(rewards); i++ {
 		require.Equal(t, true, rewards[i] > rewards[i-1])
@@ -244,9 +251,16 @@ func TestAttestationsDeltaBellatrix(t *testing.T) {
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	rewards, penalties, err := AttestationsDelta(s, balance, validators)
+	deltas, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
 
+	rewards := make([]uint64, len(deltas))
+	penalties := make([]uint64, len(deltas))
+	for i, d := range deltas {
+		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
+		penalties[i] = d.SourcePenalty + d.TargetPenalty
+	}
+
 	// Reward amount should increase as validator index increases due to setup.
 	for i := 1; i < len(rewards); i++ {
 		require.Equal(t, true, rewards[i] > rewards[i-1])
@@ -285,8 +299,15 @@ func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 	}
 
 	wanted := make([]uint64, s.NumValidators())
-	rewards, penalties, err := AttestationsDelta(s, balance, validators)
+	deltas, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
+
+	rewards := make([]uint64, len(deltas))
+	penalties := make([]uint64, len(deltas))
+	for i, d := range deltas {
+		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
+		penalties[i] = d.SourcePenalty + d.TargetPenalty
+	}
 	for i := range rewards {
 		wanted[i] += rewards[i]
 	}

beacon-chain/core/altair/sync_committee.go

@@ -2,6 +2,7 @@ package altair
 
 import (
 	"context"
+	goErrors "errors"
 	"fmt"
 	"time"
 
@@ -22,6 +23,10 @@ import (
 
 const maxRandomByte = uint64(1<<8 - 1)
 
+var (
+	ErrTooLate = errors.New("sync message is too late")
+)
+
 // ValidateNilSyncContribution validates the following fields are not nil:
 // -the contribution and proof itself
 // -the message within contribution and proof
@@ -190,6 +195,7 @@ func IsSyncCommitteeAggregator(sig []byte) (bool, error) {
 }
 
 // ValidateSyncMessageTime validates sync message to ensure that the provided slot is valid.
+// Spec: [IGNORE] The message's slot is for the current slot (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance), i.e. sync_committee_message.slot == current_slot
 func ValidateSyncMessageTime(slot primitives.Slot, genesisTime time.Time, clockDisparity time.Duration) error {
 	if err := slots.ValidateClock(slot, uint64(genesisTime.Unix())); err != nil {
 		return err
@@ -217,15 +223,19 @@ func ValidateSyncMessageTime(slot primitives.Slot, genesisTime time.Time, clockD
 	upperBound := time.Now().Add(clockDisparity)
 	// Verify sync message slot is within the time range.
 	if messageTime.Before(lowerBound) || messageTime.After(upperBound) {
-		return fmt.Errorf(
-			"sync message time %v (slot %d) not within allowable range of %v (slot %d) to %v (slot %d)",
+		syncErr := fmt.Errorf(
+			"sync message time %v (message slot %d) not within allowable range of %v to %v (current slot %d)",
 			messageTime,
 			slot,
 			lowerBound,
-			uint64(lowerBound.Unix()-genesisTime.Unix())/params.BeaconConfig().SecondsPerSlot,
 			upperBound,
-			uint64(upperBound.Unix()-genesisTime.Unix())/params.BeaconConfig().SecondsPerSlot,
+			currentSlot,
 		)
+		// Wrap error message if sync message is too late.
+		if messageTime.Before(lowerBound) {
+			syncErr = goErrors.Join(ErrTooLate, syncErr)
+		}
+		return syncErr
 	}
 	return nil
 }

beacon-chain/core/altair/sync_committee_test.go

@@ -311,7 +311,7 @@ func Test_ValidateSyncMessageTime(t *testing.T) {
 				syncMessageSlot: 16,
 				genesisTime:     prysmTime.Now().Add(-(15 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)),
 			},
-			wantedErr: "(slot 16) not within allowable range of",
+			wantedErr: "(message slot 16) not within allowable range of",
 		},
 		{
 			name: "sync_message.slot == current_slot+CLOCK_DISPARITY",
@@ -327,7 +327,7 @@ func Test_ValidateSyncMessageTime(t *testing.T) {
 				syncMessageSlot: 100,
 				genesisTime:     prysmTime.Now().Add(-(100 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second) + params.BeaconNetworkConfig().MaximumGossipClockDisparity + 1000*time.Millisecond),
 			},
-			wantedErr: "(slot 100) not within allowable range of",
+			wantedErr: "(message slot 100) not within allowable range of",
 		},
 		{
 			name: "sync_message.slot == current_slot-CLOCK_DISPARITY",
@@ -343,7 +343,7 @@ func Test_ValidateSyncMessageTime(t *testing.T) {
 				syncMessageSlot: 101,
 				genesisTime:     prysmTime.Now().Add(-(100*time.Duration(params.BeaconConfig().SecondsPerSlot)*time.Second + params.BeaconNetworkConfig().MaximumGossipClockDisparity)),
 			},
-			wantedErr: "(slot 101) not within allowable range of",
+			wantedErr: "(message slot 101) not within allowable range of",
 		},
 		{
 			name: "sync_message.slot is well beyond current slot",

beacon-chain/core/blocks/attestation.go

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation"
+	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"go.opencensus.io/trace"
 )
 
@@ -81,7 +82,6 @@ func VerifyAttestationNoVerifySignature(
 
 	s := att.Data.Slot
 	minInclusionCheck := s+params.BeaconConfig().MinAttestationInclusionDelay <= beaconState.Slot()
-	epochInclusionCheck := beaconState.Slot() <= s+params.BeaconConfig().SlotsPerEpoch
 	if !minInclusionCheck {
 		return fmt.Errorf(
 			"attestation slot %d + inclusion delay %d > state slot %d",
@@ -90,13 +90,17 @@ func VerifyAttestationNoVerifySignature(
 			beaconState.Slot(),
 		)
 	}
-	if !epochInclusionCheck {
-		return fmt.Errorf(
-			"state slot %d > attestation slot %d + SLOTS_PER_EPOCH %d",
-			beaconState.Slot(),
-			s,
-			params.BeaconConfig().SlotsPerEpoch,
-		)
+
+	if beaconState.Version() < version.Deneb {
+		epochInclusionCheck := beaconState.Slot() <= s+params.BeaconConfig().SlotsPerEpoch
+		if !epochInclusionCheck {
+			return fmt.Errorf(
+				"state slot %d > attestation slot %d + SLOTS_PER_EPOCH %d",
+				beaconState.Slot(),
+				s,
+				params.BeaconConfig().SlotsPerEpoch,
+			)
+		}
 	}
 	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, beaconState, att.Data.Target.Epoch)
 	if err != nil {

beacon-chain/core/blocks/attestation_test.go

@@ -127,6 +127,44 @@ func TestProcessAttestationsNoVerify_OK(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestProcessAttestationsNoVerify_OlderThanSlotsPerEpoch(t *testing.T) {
+	aggBits := bitfield.NewBitlist(3)
+	aggBits.SetBitAt(1, true)
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+		},
+		AggregationBits: aggBits,
+	}
+	ctx := context.Background()
+
+	t.Run("attestation older than slots per epoch", func(t *testing.T) {
+		beaconState, _ := util.DeterministicGenesisState(t, 100)
+
+		err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch + 1)
+		require.NoError(t, err)
+		ckp := beaconState.CurrentJustifiedCheckpoint()
+		copy(ckp.Root, "hello-world")
+		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
+		require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
+
+		require.ErrorContains(t, "state slot 33 > attestation slot 0 + SLOTS_PER_EPOCH 32", blocks.VerifyAttestationNoVerifySignature(ctx, beaconState, att))
+	})
+
+	t.Run("attestation older than slots per epoch in deneb", func(t *testing.T) {
+		beaconState, _ := util.DeterministicGenesisStateDeneb(t, 100)
+
+		err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch + 1)
+		require.NoError(t, err)
+		ckp := beaconState.CurrentJustifiedCheckpoint()
+		copy(ckp.Root, "hello-world")
+		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
+
+		require.NoError(t, blocks.VerifyAttestationNoVerifySignature(ctx, beaconState, att))
+	})
+}
+
 func TestVerifyAttestationNoVerifySignature_OK(t *testing.T) {
 	// Attestation with an empty signature
 

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -413,7 +413,7 @@ func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 	}
 }
 
-func TestFuzzVerifyExit_10000(_ *testing.T) {
+func TestFuzzVerifyExit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	ve := &ethpb.SignedVoluntaryExit{}
 	rawVal := &ethpb.Validator{}
@@ -425,9 +425,18 @@ func TestFuzzVerifyExit_10000(_ *testing.T) {
 		fuzzer.Fuzz(rawVal)
 		fuzzer.Fuzz(fork)
 		fuzzer.Fuzz(&slot)
+
+		state := &ethpb.BeaconState{
+			Slot:                  slot,
+			Fork:                  fork,
+			GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:],
+		}
+		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
+		require.NoError(t, err)
+
 		val, err := state_native.NewValidator(&ethpb.Validator{})
 		_ = err
-		err = VerifyExitAndSignature(val, slot, fork, ve, params.BeaconConfig().ZeroHash[:])
+		err = VerifyExitAndSignature(val, s, ve)
 		_ = err
 	}
 }

beacon-chain/core/blocks/exit.go

@@ -12,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 )
 
@@ -50,6 +51,8 @@ func ProcessVoluntaryExits(
 	beaconState state.BeaconState,
 	exits []*ethpb.SignedVoluntaryExit,
 ) (state.BeaconState, error) {
+	maxExitEpoch, churn := v.ValidatorsMaxExitEpochAndChurn(beaconState)
+	var exitEpoch primitives.Epoch
 	for idx, exit := range exits {
 		if exit == nil || exit.Exit == nil {
 			return nil, errors.New("nil voluntary exit in block body")
@@ -58,11 +61,18 @@ func ProcessVoluntaryExits(
 		if err != nil {
 			return nil, err
 		}
-		if err := VerifyExitAndSignature(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorsRoot()); err != nil {
+		if err := VerifyExitAndSignature(val, beaconState, exit); err != nil {
 			return nil, errors.Wrapf(err, "could not verify exit %d", idx)
 		}
-		beaconState, err = v.InitiateValidatorExit(ctx, beaconState, exit.Exit.ValidatorIndex)
-		if err != nil {
+		beaconState, exitEpoch, err = v.InitiateValidatorExit(ctx, beaconState, exit.Exit.ValidatorIndex, maxExitEpoch, churn)
+		if err == nil {
+			if exitEpoch > maxExitEpoch {
+				maxExitEpoch = exitEpoch
+				churn = 1
+			} else if exitEpoch == maxExitEpoch {
+				churn++
+			}
+		} else if !errors.Is(err, v.ValidatorAlreadyExitedErr) {
 			return nil, err
 		}
 	}
@@ -92,15 +102,27 @@ func ProcessVoluntaryExits(
 //	 initiate_validator_exit(state, voluntary_exit.validator_index)
 func VerifyExitAndSignature(
 	validator state.ReadOnlyValidator,
-	currentSlot primitives.Slot,
-	fork *ethpb.Fork,
+	state state.ReadOnlyBeaconState,
 	signed *ethpb.SignedVoluntaryExit,
-	genesisRoot []byte,
 ) error {
 	if signed == nil || signed.Exit == nil {
 		return errors.New("nil exit")
 	}
 
+	currentSlot := state.Slot()
+	fork := state.Fork()
+	genesisRoot := state.GenesisValidatorsRoot()
+
+	// EIP-7044: Beginning in Deneb, fix the fork version to Capella.
+	// This allows for signed validator exits to be valid forever.
+	if state.Version() >= version.Deneb {
+		fork = &ethpb.Fork{
+			PreviousVersion: params.BeaconConfig().CapellaForkVersion,
+			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
+			Epoch:           params.BeaconConfig().CapellaForkEpoch,
+		}
+	}
+
 	exit := signed.Exit
 	if err := verifyExitConditions(validator, currentSlot, exit); err != nil {
 		return err

beacon-chain/core/blocks/exit_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v4/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
@@ -133,38 +134,38 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 }
 
 func TestVerifyExitAndSignature(t *testing.T) {
-	type args struct {
-		currentSlot primitives.Slot
-	}
-
 	tests := []struct {
 		name    string
-		args    args
-		setup   func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error)
+		setup   func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error)
 		wantErr string
 	}{
 		{
 			name: "Empty Exit",
-			args: args{
-				currentSlot: 0,
-			},
-			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error) {
+			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error) {
 				fork := &ethpb.Fork{
 					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 					CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 					Epoch:           0,
 				}
 				genesisRoot := [32]byte{'a'}
-				return &ethpb.Validator{}, &ethpb.SignedVoluntaryExit{}, fork, genesisRoot[:], nil
+
+				st := &ethpb.BeaconState{
+					Slot:                  0,
+					Fork:                  fork,
+					GenesisValidatorsRoot: genesisRoot[:],
+				}
+
+				s, err := state_native.InitializeFromProtoUnsafePhase0(st)
+				if err != nil {
+					return nil, nil, nil, err
+				}
+				return &ethpb.Validator{}, &ethpb.SignedVoluntaryExit{}, s, nil
 			},
 			wantErr: "nil exit",
 		},
 		{
 			name: "Happy Path",
-			args: args{
-				currentSlot: (params.BeaconConfig().SlotsPerEpoch * 2) + 1,
-			},
-			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error) {
+			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error) {
 				fork := &ethpb.Fork{
 					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 					CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
@@ -186,15 +187,18 @@ func TestVerifyExitAndSignature(t *testing.T) {
 				sig, err := bls.SignatureFromBytes(sb)
 				require.NoError(t, err)
 				signedExit.Signature = sig.Marshal()
-				return validator, signedExit, fork, bs.GenesisValidatorsRoot(), nil
+				if err := bs.SetFork(fork); err != nil {
+					return nil, nil, nil, err
+				}
+				if err := bs.SetSlot((params.BeaconConfig().SlotsPerEpoch * 2) + 1); err != nil {
+					return nil, nil, nil, err
+				}
+				return validator, signedExit, bs, nil
 			},
 		},
 		{
 			name: "bad signature",
-			args: args{
-				currentSlot: (params.BeaconConfig().SlotsPerEpoch * 2) + 1,
-			},
-			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error) {
+			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error) {
 				fork := &ethpb.Fork{
 					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 					CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
@@ -215,27 +219,72 @@ func TestVerifyExitAndSignature(t *testing.T) {
 				sig, err := bls.SignatureFromBytes(sb)
 				require.NoError(t, err)
 				signedExit.Signature = sig.Marshal()
-				genesisRoot := [32]byte{'a'}
+				if err := bs.SetFork(fork); err != nil {
+					return nil, nil, nil, err
+				}
+				if err := bs.SetSlot((params.BeaconConfig().SlotsPerEpoch * 2) + 1); err != nil {
+					return nil, nil, nil, err
+				}
+
 				// use wrong genesis root and don't update validator
-				return validator, signedExit, fork, genesisRoot[:], nil
+				genesisRoot := [32]byte{'a'}
+				if err := bs.SetGenesisValidatorsRoot(genesisRoot[:]); err != nil {
+					return nil, nil, nil, err
+				}
+				return validator, signedExit, bs, nil
 			},
 			wantErr: "signature did not verify",
 		},
+		{
+			name: "EIP-7044: deneb exits should verify with capella fork information",
+			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error) {
+				fork := &ethpb.Fork{
+					PreviousVersion: params.BeaconConfig().CapellaForkVersion,
+					CurrentVersion:  params.BeaconConfig().DenebForkVersion,
+					Epoch:           primitives.Epoch(2),
+				}
+				signedExit := &ethpb.SignedVoluntaryExit{
+					Exit: &ethpb.VoluntaryExit{
+						Epoch:          2,
+						ValidatorIndex: 0,
+					},
+				}
+				bs, keys := util.DeterministicGenesisState(t, 1)
+				bs, err := state_native.InitializeFromProtoUnsafeDeneb(&ethpb.BeaconStateDeneb{
+					GenesisValidatorsRoot: bs.GenesisValidatorsRoot(),
+					Fork:                  fork,
+					Slot:                  (params.BeaconConfig().SlotsPerEpoch * 2) + 1,
+					Validators:            bs.Validators(),
+				})
+				if err != nil {
+					return nil, nil, nil, err
+				}
+				validator := bs.Validators()[0]
+				validator.ActivationEpoch = 1
+				err = bs.UpdateValidatorAtIndex(0, validator)
+				require.NoError(t, err)
+				sb, err := signing.ComputeDomainAndSign(bs, signedExit.Exit.Epoch, signedExit.Exit, params.BeaconConfig().DomainVoluntaryExit, keys[0])
+				require.NoError(t, err)
+				sig, err := bls.SignatureFromBytes(sb)
+				require.NoError(t, err)
+				signedExit.Signature = sig.Marshal()
+
+				return validator, signedExit, bs, nil
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			c := params.BeaconConfig().ShardCommitteePeriod
 			params.BeaconConfig().ShardCommitteePeriod = 0
-			validator, signedExit, fork, genesisRoot, err := tt.setup()
+			validator, signedExit, st, err := tt.setup()
 			require.NoError(t, err)
 			rvalidator, err := state_native.NewValidator(validator)
 			require.NoError(t, err)
 			err = blocks.VerifyExitAndSignature(
 				rvalidator,
-				tt.args.currentSlot,
-				fork,
+				st,
 				signedExit,
-				genesisRoot,
 			)
 			if tt.wantErr == "" {
 				require.NoError(t, err)

beacon-chain/core/blocks/genesis.go

@@ -145,6 +145,40 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
+	case *ethpb.BeaconStateDeneb:
+		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockDeneb{
+			Block: &ethpb.BeaconBlockDeneb{
+				ParentRoot: params.BeaconConfig().ZeroHash[:],
+				StateRoot:  root[:],
+				Body: &ethpb.BeaconBlockBodyDeneb{
+					RandaoReveal: make([]byte, 96),
+					Eth1Data: &ethpb.Eth1Data{
+						DepositRoot: make([]byte, 32),
+						BlockHash:   make([]byte, 32),
+					},
+					Graffiti: make([]byte, 32),
+					SyncAggregate: &ethpb.SyncAggregate{
+						SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
+						SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+					},
+					ExecutionPayload: &enginev1.ExecutionPayloadDeneb{ // Deneb difference.
+						ParentHash:    make([]byte, 32),
+						FeeRecipient:  make([]byte, 20),
+						StateRoot:     make([]byte, 32),
+						ReceiptsRoot:  make([]byte, 32),
+						LogsBloom:     make([]byte, 256),
+						PrevRandao:    make([]byte, 32),
+						BaseFeePerGas: make([]byte, 32),
+						BlockHash:     make([]byte, 32),
+						Transactions:  make([][]byte, 0),
+						Withdrawals:   make([]*enginev1.Withdrawal, 0),
+					},
+					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
+					BlobKzgCommitments:    make([][]byte, 0),
+				},
+			},
+			Signature: params.BeaconConfig().EmptySignature[:],
+		})
 	default:
 		return nil, ErrUnrecognizedState
 	}

beacon-chain/core/deneb/BUILD.bazel

@@ -0,0 +1,30 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["upgrade.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/deneb",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//config/params:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["upgrade_test.go"],
+    deps = [
+        ":go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//config/params:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+    ],
+)

beacon-chain/core/deneb/upgrade.go

@@ -0,0 +1,115 @@
+package deneb
+
+import (
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v4/beacon-chain/state/state-native"
+	"github.com/prysmaticlabs/prysm/v4/config/params"
+	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+)
+
+// UpgradeToDeneb updates inputs a generic state to return the version Deneb state.
+func UpgradeToDeneb(state state.BeaconState) (state.BeaconState, error) {
+	epoch := time.CurrentEpoch(state)
+
+	currentSyncCommittee, err := state.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := state.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := state.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := state.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := state.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	payloadHeader, err := state.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := payloadHeader.TransactionsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wdRoot, err := payloadHeader.WithdrawalsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := state.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := state.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := state.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+
+	s := &ethpb.BeaconStateDeneb{
+		GenesisTime:           state.GenesisTime(),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
+		Slot:                  state.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: state.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().DenebForkVersion,
+			Epoch:           epoch,
+		},
+		LatestBlockHeader:           state.LatestBlockHeader(),
+		BlockRoots:                  state.BlockRoots(),
+		StateRoots:                  state.StateRoots(),
+		HistoricalRoots:             [][]byte{},
+		Eth1Data:                    state.Eth1Data(),
+		Eth1DataVotes:               state.Eth1DataVotes(),
+		Eth1DepositIndex:            state.Eth1DepositIndex(),
+		Validators:                  state.Validators(),
+		Balances:                    state.Balances(),
+		RandaoMixes:                 state.RandaoMixes(),
+		Slashings:                   state.Slashings(),
+		PreviousEpochParticipation:  prevEpochParticipation,
+		CurrentEpochParticipation:   currentEpochParticipation,
+		JustificationBits:           state.JustificationBits(),
+		PreviousJustifiedCheckpoint: state.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:  state.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:         state.FinalizedCheckpoint(),
+		InactivityScores:            inactivityScores,
+		CurrentSyncCommittee:        currentSyncCommittee,
+		NextSyncCommittee:           nextSyncCommittee,
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
+			ParentHash:       payloadHeader.ParentHash(),
+			FeeRecipient:     payloadHeader.FeeRecipient(),
+			StateRoot:        payloadHeader.StateRoot(),
+			ReceiptsRoot:     payloadHeader.ReceiptsRoot(),
+			LogsBloom:        payloadHeader.LogsBloom(),
+			PrevRandao:       payloadHeader.PrevRandao(),
+			BlockNumber:      payloadHeader.BlockNumber(),
+			GasLimit:         payloadHeader.GasLimit(),
+			GasUsed:          payloadHeader.GasUsed(),
+			Timestamp:        payloadHeader.Timestamp(),
+			ExtraData:        payloadHeader.ExtraData(),
+			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
+			BlockHash:        payloadHeader.BlockHash(),
+			ExcessBlobGas:    0,
+			BlobGasUsed:      0,
+			TransactionsRoot: txRoot,
+			WithdrawalsRoot:  wdRoot,
+		},
+		NextWithdrawalIndex:          wi,
+		NextWithdrawalValidatorIndex: vi,
+		HistoricalSummaries:          summaries,
+	}
+
+	return state_native.InitializeFromProtoUnsafeDeneb(s)
+}

beacon-chain/core/deneb/upgrade_test.go

@@ -0,0 +1,94 @@
+package deneb_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/deneb"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v4/config/params"
+	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/testing/require"
+	"github.com/prysmaticlabs/prysm/v4/testing/util"
+)
+
+func TestUpgradeToDeneb(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateCapella(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	preForkState := st.Copy()
+	mSt, err := deneb.UpgradeToDeneb(st)
+	require.NoError(t, err)
+
+	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
+	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
+	require.Equal(t, preForkState.Slot(), mSt.Slot())
+	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
+	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
+	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
+	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
+	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
+	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())
+	require.DeepSSZEqual(t, preForkState.Validators(), mSt.Validators())
+	require.DeepSSZEqual(t, preForkState.Balances(), mSt.Balances())
+	require.DeepSSZEqual(t, preForkState.RandaoMixes(), mSt.RandaoMixes())
+	require.DeepSSZEqual(t, preForkState.Slashings(), mSt.Slashings())
+	require.DeepSSZEqual(t, preForkState.JustificationBits(), mSt.JustificationBits())
+	require.DeepSSZEqual(t, preForkState.PreviousJustifiedCheckpoint(), mSt.PreviousJustifiedCheckpoint())
+	require.DeepSSZEqual(t, preForkState.CurrentJustifiedCheckpoint(), mSt.CurrentJustifiedCheckpoint())
+	require.DeepSSZEqual(t, preForkState.FinalizedCheckpoint(), mSt.FinalizedCheckpoint())
+	numValidators := mSt.NumValidators()
+	p, err := mSt.PreviousEpochParticipation()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, make([]byte, numValidators), p)
+	p, err = mSt.CurrentEpochParticipation()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, make([]byte, numValidators), p)
+	s, err := mSt.InactivityScores()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
+
+	f := mSt.Fork()
+	require.DeepSSZEqual(t, &ethpb.Fork{
+		PreviousVersion: st.Fork().CurrentVersion,
+		CurrentVersion:  params.BeaconConfig().DenebForkVersion,
+		Epoch:           time.CurrentEpoch(st),
+	}, f)
+	csc, err := mSt.CurrentSyncCommittee()
+	require.NoError(t, err)
+	psc, err := preForkState.CurrentSyncCommittee()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, psc, csc)
+	nsc, err := mSt.NextSyncCommittee()
+	require.NoError(t, err)
+	psc, err = preForkState.NextSyncCommittee()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, psc, nsc)
+
+	header, err := mSt.LatestExecutionPayloadHeader()
+	require.NoError(t, err)
+	protoHeader, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
+	require.Equal(t, true, ok)
+	prevHeader, err := preForkState.LatestExecutionPayloadHeader()
+	require.NoError(t, err)
+	txRoot, err := prevHeader.TransactionsRoot()
+	require.NoError(t, err)
+
+	wdRoot, err := prevHeader.WithdrawalsRoot()
+	require.NoError(t, err)
+	wanted := &enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       prevHeader.ParentHash(),
+		FeeRecipient:     prevHeader.FeeRecipient(),
+		StateRoot:        prevHeader.StateRoot(),
+		ReceiptsRoot:     prevHeader.ReceiptsRoot(),
+		LogsBloom:        prevHeader.LogsBloom(),
+		PrevRandao:       prevHeader.PrevRandao(),
+		BlockNumber:      prevHeader.BlockNumber(),
+		GasLimit:         prevHeader.GasLimit(),
+		GasUsed:          prevHeader.GasUsed(),
+		Timestamp:        prevHeader.Timestamp(),
+		BaseFeePerGas:    prevHeader.BaseFeePerGas(),
+		BlockHash:        prevHeader.BlockHash(),
+		TransactionsRoot: txRoot,
+		WithdrawalsRoot:  wdRoot,
+	}
+	require.DeepEqual(t, wanted, protoHeader)
+}

beacon-chain/core/epoch/epoch_processing.go

@@ -110,8 +110,11 @@ func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state
 		isActive := helpers.IsActiveValidator(validator, currentEpoch)
 		belowEjectionBalance := validator.EffectiveBalance <= ejectionBal
 		if isActive && belowEjectionBalance {
-			state, err = validators.InitiateValidatorExit(ctx, state, primitives.ValidatorIndex(idx))
-			if err != nil {
+			// Here is fine to do a quadratic loop since this should
+			// barely happen
+			maxExitEpoch, churn := validators.ValidatorsMaxExitEpochAndChurn(state)
+			state, _, err = validators.InitiateValidatorExit(ctx, state, primitives.ValidatorIndex(idx), maxExitEpoch, churn)
+			if err != nil && !errors.Is(err, validators.ValidatorAlreadyExitedErr) {
 				return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
 			}
 		}

beacon-chain/core/feed/state/events.go

@@ -39,6 +39,8 @@ type BlockProcessedData struct {
 	SignedBlock interfaces.ReadOnlySignedBeaconBlock
 	// Verified is true if the block's BLS contents have been verified.
 	Verified bool
+	// Optimistic is true if the block is optimistic.
+	Optimistic bool
 }
 
 // ChainStartedData is the data sent with ChainStarted events.

beacon-chain/core/helpers/BUILD.bazel

@@ -38,6 +38,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/core/helpers/attestation.go

@@ -12,6 +12,11 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v4/time"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	ErrTooLate = errors.New("attestation is too late")
 )
 
 // ValidateNilAttestation checks if any composite field of input attestation is nil.
@@ -162,14 +167,39 @@ func ValidateAttestationTime(attSlot primitives.Slot, genesisTime time.Time, clo
 		lowerBoundsSlot,
 		currentSlot,
 	)
-	if attTime.Before(lowerBounds) {
-		attReceivedTooLateCount.Inc()
-		return attError
-	}
 	if attTime.After(upperBounds) {
 		attReceivedTooEarlyCount.Inc()
 		return attError
 	}
+
+	attEpoch := slots.ToEpoch(attSlot)
+	if attEpoch < params.BeaconConfig().DenebForkEpoch {
+		if attTime.Before(lowerBounds) {
+			attReceivedTooLateCount.Inc()
+			return errors.Join(ErrTooLate, attError)
+		}
+		return nil
+	}
+
+	// EIP-7045: Starting in Deneb, allow any attestations from the current or previous epoch.
+
+	currentEpoch := slots.ToEpoch(currentSlot)
+	prevEpoch, err := currentEpoch.SafeSub(1)
+	if err != nil {
+		log.WithError(err).Debug("Ignoring underflow for a deneb attestation inclusion check in epoch 0")
+		prevEpoch = 0
+	}
+	attSlotEpoch := slots.ToEpoch(attSlot)
+	if attSlotEpoch != currentEpoch && attSlotEpoch != prevEpoch {
+		attError = fmt.Errorf(
+			"attestation epoch %d not within current epoch %d or previous epoch %d",
+			attSlot/params.BeaconConfig().SlotsPerEpoch,
+			currentEpoch,
+			prevEpoch,
+		)
+		return errors.Join(ErrTooLate, attError)
+	}
+
 	return nil
 }
 

beacon-chain/core/helpers/attestation_test.go

@@ -85,6 +85,11 @@ func TestAttestation_ComputeSubnetForAttestation(t *testing.T) {
 }
 
 func Test_ValidateAttestationTime(t *testing.T) {
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 5
+	params.OverrideBeaconConfig(cfg)
+	params.SetupTestConfigCleanup(t)
+
 	if params.BeaconNetworkConfig().MaximumGossipClockDisparity < 200*time.Millisecond {
 		t.Fatal("This test expects the maximum clock disparity to be at least 200ms")
 	}
@@ -155,6 +160,39 @@ func Test_ValidateAttestationTime(t *testing.T) {
 				).Add(200 * time.Millisecond),
 			},
 		},
+		{
+			name: "attestation.slot < current_slot-ATTESTATION_PROPAGATION_SLOT_RANGE in deneb",
+			args: args{
+				attSlot:     300 - params.BeaconNetworkConfig().AttestationPropagationSlotRange - 1,
+				genesisTime: prysmTime.Now().Add(-300 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
+			},
+		},
+		{
+			name: "attestation.slot = current_slot-ATTESTATION_PROPAGATION_SLOT_RANGE in deneb",
+			args: args{
+				attSlot:     300 - params.BeaconNetworkConfig().AttestationPropagationSlotRange,
+				genesisTime: prysmTime.Now().Add(-300 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
+			},
+		},
+		{
+			name: "attestation.slot = current_slot-ATTESTATION_PROPAGATION_SLOT_RANGE, received 200ms late in deneb",
+			args: args{
+				attSlot: 300 - params.BeaconNetworkConfig().AttestationPropagationSlotRange,
+				genesisTime: prysmTime.Now().Add(
+					-300 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second,
+				).Add(200 * time.Millisecond),
+			},
+		},
+		{
+			name: "attestation.slot != current epoch or previous epoch in deneb",
+			args: args{
+				attSlot: 300 - params.BeaconNetworkConfig().AttestationPropagationSlotRange,
+				genesisTime: prysmTime.Now().Add(
+					-500 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second,
+				).Add(200 * time.Millisecond),
+			},
+			wantedErr: "attestation epoch 8 not within current epoch 15 or previous epoch 14",
+		},
 		{
 			name: "attestation.slot is well beyond current slot",
 			args: args{

beacon-chain/core/helpers/beacon_committee.go

@@ -295,61 +295,58 @@ func ShuffledIndices(s state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]pri
 }
 
 // UpdateCommitteeCache gets called at the beginning of every epoch to cache the committee shuffled indices
-// list with committee index and epoch number. It caches the shuffled indices for current epoch and next epoch.
-func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch primitives.Epoch) error {
-	for _, e := range []primitives.Epoch{epoch, epoch + 1} {
-		seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconAttester)
-		if err != nil {
-			return err
-		}
-		if committeeCache.HasEntry(string(seed[:])) {
-			return nil
-		}
-
-		shuffledIndices, err := ShuffledIndices(state, e)
-		if err != nil {
-			return err
-		}
-
-		count := SlotCommitteeCount(uint64(len(shuffledIndices)))
-
-		// Store the sorted indices as well as shuffled indices. In current spec,
-		// sorted indices is required to retrieve proposer index. This is also
-		// used for failing verify signature fallback.
-		sortedIndices := make([]primitives.ValidatorIndex, len(shuffledIndices))
-		copy(sortedIndices, shuffledIndices)
-		sort.Slice(sortedIndices, func(i, j int) bool {
-			return sortedIndices[i] < sortedIndices[j]
-		})
-
-		if err := committeeCache.AddCommitteeShuffledList(ctx, &cache.Committees{
-			ShuffledIndices: shuffledIndices,
-			CommitteeCount:  uint64(params.BeaconConfig().SlotsPerEpoch.Mul(count)),
-			Seed:            seed,
-			SortedIndices:   sortedIndices,
-		}); err != nil {
-			return err
-		}
+// list with committee index and epoch number. It caches the shuffled indices for the input epoch.
+func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState, e primitives.Epoch) error {
+	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return err
+	}
+	if committeeCache.HasEntry(string(seed[:])) {
+		return nil
+	}
+	shuffledIndices, err := ShuffledIndices(state, e)
+	if err != nil {
+		return err
 	}
 
+	count := SlotCommitteeCount(uint64(len(shuffledIndices)))
+
+	// Store the sorted indices as well as shuffled indices. In current spec,
+	// sorted indices is required to retrieve proposer index. This is also
+	// used for failing verify signature fallback.
+	sortedIndices := make([]primitives.ValidatorIndex, len(shuffledIndices))
+	copy(sortedIndices, shuffledIndices)
+	sort.Slice(sortedIndices, func(i, j int) bool {
+		return sortedIndices[i] < sortedIndices[j]
+	})
+
+	if err := committeeCache.AddCommitteeShuffledList(ctx, &cache.Committees{
+		ShuffledIndices: shuffledIndices,
+		CommitteeCount:  uint64(params.BeaconConfig().SlotsPerEpoch.Mul(count)),
+		Seed:            seed,
+		SortedIndices:   sortedIndices,
+	}); err != nil {
+		return err
+	}
 	return nil
 }
 
 // UpdateProposerIndicesInCache updates proposer indices entry of the committee cache.
-func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState) error {
+// Input state is used to retrieve active validator indices.
+// Input epoch is the epoch to retrieve proposer indices for.
+func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch primitives.Epoch) error {
 	// The cache uses the state root at the (current epoch - 1)'s slot as key. (e.g. for epoch 2, the key is root at slot 63)
 	// Which is the reason why we skip genesis epoch.
-	if time.CurrentEpoch(state) <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
+	if epoch <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
 		return nil
 	}
 
 	// Use state root from (current_epoch - 1))
-	wantedEpoch := time.PrevEpoch(state)
-	s, err := slots.EpochEnd(wantedEpoch)
+	s, err := slots.EpochEnd(epoch - 1)
 	if err != nil {
 		return err
 	}
-	r, err := StateRootAtSlot(state, s)
+	r, err := state.StateRootAtIndex(uint64(s % params.BeaconConfig().SlotsPerHistoricalRoot))
 	if err != nil {
 		return err
 	}
@@ -366,11 +363,11 @@ func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaco
 		return nil
 	}
 
-	indices, err := ActiveValidatorIndices(ctx, state, time.CurrentEpoch(state))
+	indices, err := ActiveValidatorIndices(ctx, state, epoch)
 	if err != nil {
 		return err
 	}
-	proposerIndices, err := precomputeProposerIndices(state, indices)
+	proposerIndices, err := precomputeProposerIndices(state, indices, epoch)
 	if err != nil {
 		return err
 	}
@@ -432,11 +429,10 @@ func computeCommittee(
 
 // This computes proposer indices of the current epoch and returns a list of proposer indices,
 // the index of the list represents the slot number.
-func precomputeProposerIndices(state state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex) ([]primitives.ValidatorIndex, error) {
+func precomputeProposerIndices(state state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, e primitives.Epoch) ([]primitives.ValidatorIndex, error) {
 	hashFunc := hash.CustomSHA256Hasher()
 	proposerIndices := make([]primitives.ValidatorIndex, params.BeaconConfig().SlotsPerEpoch)
 
-	e := time.CurrentEpoch(state)
 	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconProposer)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not generate seed")

beacon-chain/core/helpers/beacon_committee_test.go

@@ -413,7 +413,7 @@ func TestUpdateCommitteeCache_CanUpdate(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, UpdateCommitteeCache(context.Background(), state, time.CurrentEpoch(state)))
 
-	epoch := primitives.Epoch(1)
+	epoch := primitives.Epoch(0)
 	idx := primitives.CommitteeIndex(1)
 	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
@@ -423,6 +423,40 @@ func TestUpdateCommitteeCache_CanUpdate(t *testing.T) {
 	assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(indices)), "Did not save correct indices lengths")
 }
 
+func TestUpdateCommitteeCache_CanUpdateAcrossEpochs(t *testing.T) {
+	ClearCache()
+	defer ClearCache()
+	validatorCount := params.BeaconConfig().MinGenesisActiveValidatorCount
+	validators := make([]*ethpb.Validator, validatorCount)
+	indices := make([]primitives.ValidatorIndex, validatorCount)
+	for i := primitives.ValidatorIndex(0); uint64(i) < validatorCount; i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance: 1,
+		}
+		indices[i] = i
+	}
+	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+	e := time.CurrentEpoch(state)
+	require.NoError(t, UpdateCommitteeCache(context.Background(), state, e))
+
+	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconAttester)
+	require.NoError(t, err)
+	require.Equal(t, true, committeeCache.HasEntry(string(seed[:])))
+
+	nextSeed, err := Seed(state, e+1, params.BeaconConfig().DomainBeaconAttester)
+	require.NoError(t, err)
+	require.Equal(t, false, committeeCache.HasEntry(string(nextSeed[:])))
+
+	require.NoError(t, UpdateCommitteeCache(context.Background(), state, e+1))
+
+	require.Equal(t, true, committeeCache.HasEntry(string(nextSeed[:])))
+}
+
 func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
 	validators := make([]*ethpb.Validator, 300000)
 	for i := 0; i < len(validators); i++ {
@@ -639,7 +673,7 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	indices, err := ActiveValidatorIndices(context.Background(), state, 0)
 	require.NoError(t, err)
 
-	proposerIndices, err := precomputeProposerIndices(state, indices)
+	proposerIndices, err := precomputeProposerIndices(state, indices, time.CurrentEpoch(state))
 	require.NoError(t, err)
 
 	var wantedProposerIndices []primitives.ValidatorIndex

beacon-chain/core/helpers/shuffle.go

@@ -184,7 +184,7 @@ func innerShuffleList(input []primitives.ValidatorIndex, seed [32]byte, shuffle
 	for {
 		buf[seedSize] = r
 		ph := hashfunc(buf[:pivotViewSize])
-		pivot := bytesutil.FromBytes8(ph[:8]) % listSize
+		pivot := binary.LittleEndian.Uint64(ph[:8]) % listSize
 		mirror := (pivot + 1) >> 1
 		binary.LittleEndian.PutUint32(buf[pivotViewSize:], uint32(pivot>>8))
 		source := hashfunc(buf)

beacon-chain/core/helpers/validators.go

@@ -17,6 +17,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 var CommitteeCacheInProgressHit = promauto.NewCounter(prometheus.CounterOpts{
@@ -261,7 +262,7 @@ func BeaconProposerIndex(ctx context.Context, state state.ReadOnlyBeaconState) (
 				}
 				return proposerIndices[state.Slot()%params.BeaconConfig().SlotsPerEpoch], nil
 			}
-			if err := UpdateProposerIndicesInCache(ctx, state); err != nil {
+			if err := UpdateProposerIndicesInCache(ctx, state, time.CurrentEpoch(state)); err != nil {
 				return 0, errors.Wrap(err, "could not update committee cache")
 			}
 		}
@@ -396,3 +397,22 @@ func isEligibleForActivation(activationEligibilityEpoch, activationEpoch, finali
 	return activationEligibilityEpoch <= finalizedEpoch &&
 		activationEpoch == params.BeaconConfig().FarFutureEpoch
 }
+
+// LastActivatedValidatorIndex provides the last activated validator given a state
+func LastActivatedValidatorIndex(ctx context.Context, st state.ReadOnlyBeaconState) (primitives.ValidatorIndex, error) {
+	_, span := trace.StartSpan(ctx, "helpers.LastActivatedValidatorIndex")
+	defer span.End()
+	var lastActivatedvalidatorIndex primitives.ValidatorIndex
+	// linear search because status are not sorted
+	for j := st.NumValidators() - 1; j >= 0; j-- {
+		val, err := st.ValidatorAtIndexReadOnly(primitives.ValidatorIndex(j))
+		if err != nil {
+			return 0, err
+		}
+		if IsActiveValidatorUsingTrie(val, time.CurrentEpoch(st)) {
+			lastActivatedvalidatorIndex = primitives.ValidatorIndex(j)
+			break
+		}
+	}
+	return lastActivatedvalidatorIndex, nil
+}

beacon-chain/core/helpers/validators_test.go

@@ -727,3 +727,26 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd
 		}
 	}
 }
+
+func TestLastActivatedValidatorIndex_OK(t *testing.T) {
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{})
+	require.NoError(t, err)
+
+	validators := make([]*ethpb.Validator, 4)
+	balances := make([]uint64, len(validators))
+	for i := uint64(0); i < 4; i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, params.BeaconConfig().BLSPubkeyLength),
+			WithdrawalCredentials: make([]byte, 32),
+			EffectiveBalance:      32 * 1e9,
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+		balances[i] = validators[i].EffectiveBalance
+	}
+	require.NoError(t, beaconState.SetValidators(validators))
+	require.NoError(t, beaconState.SetBalances(balances))
+
+	index, err := LastActivatedValidatorIndex(context.Background(), beaconState)
+	require.NoError(t, err)
+	require.Equal(t, index, primitives.ValidatorIndex(3))
+}

beacon-chain/core/signing/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
     ],