Revert Fallback Sync

Fix Attester Slashing Validation In Electra
Move blockRoot == badHoleskyRoot earlier
2026-01-10 05:47:59 -05:00 · 2025-02-27 12:11:12 +08:00 · 2025-02-26 15:09:59 +08:00 · 2025-02-25 13:53:24 -08:00 · 2025-02-25 12:46:40 -08:00 · 2025-02-25 14:44:18 -06:00
252 changed files with 5152 additions and 7600 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,141 @@ All notable changes to this project will be documented in this file.

 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

+## [v5.3.0](https://github.com/prysmaticlabs/prysm/compare/v5.2.0...v5.3.0) - 2025-02-12
+
+This release includes support for Pectra activation in the [Holesky](https://github.com/eth-clients/holesky) and [Sepolia](https://github.com/eth-clients/sepolia) testnets! The release contains many fixes for Electra that have been found in rigorous testing through devnets in the last few months.
+
+For mainnet, we have a few nice features for you to try:
+
+- [PR #14023](https://github.com/prysmaticlabs/prysm/pull/14023) introduces a new file layout structure for storing blobs. Rather than storing all blob root directories in one parent directory, blob root directories are organized in subdirectories by epoch. This should vastly decrease the blob cache warmup time when Prysm is starting. Try this feature with `--blob-storage-layout=by-epoch`.
+
+Updating to this release is **required** for Holesky and Sepolia operators and it is **recommended** for mainnet users as there are a few bug fixes that apply to deneb logic.
+
+### Added
+
+- Added an error field to log `Finished building block`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14696)
+- Implemented a new `EmptyExecutionPayloadHeader` function. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14713)
+- Added proper gas limit check for header from the builder. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14707)
+- `Finished building block`: Display error only if not nil. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14722)
+- Added light client feature flag check to RPC handlers. [PR](https://github.com/prysmaticlabs/prysm/pull/14736). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14782)
+- Added support to update target and max blob count to different values per hard fork config. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14678)
+- Log before blob filesystem cache warm-up. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14735)
+- New design for the attestation pool. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14324)
+- Add field param placeholder for Electra blob target and max to pass spec tests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14733)
+- Light client: Add better error handling. [PR](https://github.com/prysmaticlabs/prysm/pull/14749). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14782)
+- Add EIP-7691: Blob throughput increase. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14750)
+- Trace IDONTWANT Messages in Pubsub. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14778)
+- Add Fulu fork boilerplate. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14771)
+- DB optimization for saving light client bootstraps (save unique sync committees only). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14782)
+- Separate type for unaggregated network attestations. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14659)
+- Remote signer electra fork support. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14477)
+- Add Electra test case to rewards API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14816)
+- Update `proto_test.go` to Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14817)
+- Update slasher service to Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14812)
+- Builder API endpoint to support Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14344)
+- Added protoc toolchains with a version of v25.3. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14818)
+- Add test cases for the eth_lightclient_bootstrap API SSZ support. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14824)
+- Handle `AttesterSlashingElectra` everywhere in the codebase. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14823)
+- Add Beacon DB pruning service to prune historical data older than MIN_EPOCHS_FOR_BLOCK_REQUESTS (roughly equivalent to the weak subjectivity period). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14687)
+- Nil consolidation request check for core processing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14851)
+- Updated blob sidecar api endpoint for Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14852)
+- Slashing pool service to convert slashings from Phase0 to Electra at the fork. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14844)
+- check to stop eth1 voting after electra and eth1 deposits stop. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14835)
+- WARN log message on node startup advising of the upcoming deprecation of the --enable-historical-state-representation feature flag. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14856)
+- Beacon API event support for `SingleAttestation` and `SignedAggregateAttestationAndProofElectra`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14855)
+- Added Electra tests for `TestLightClient_NewLightClientOptimisticUpdateFromBeaconState` and `TestLightClient_NewLightClientFinalityUpdateFromBeaconState`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14783)
+- New option to select an alternate blob storage layout. Rather than a flat directory with a subdir for each block root, a multi-level scheme is used to organize blobs by epoch/slot/root, enabling leaner syscalls, indexing and pruning. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14023)
+- Send pending att queue's attestations through the notification feed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14862)
+- Prune all pending deposits and proofs in post-Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14829)
+- Add Pectra testnet dates. (Sepolia and Holesky). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14884)
+
+### Changed
+
+- Process light client finality updates only for new finalized epochs instead of doing it for every block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14713)
+- Refactor subnets subscriptions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14711)
+- Refactor RPC handlers subscriptions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14732)
+- Go deps upgrade, from `ioutil` to `io`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14737)
+- Move successfully registered validator(s) on builder log to debug. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14735)
+- Update some test files to use `crypto/rand` instead of `math/rand`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14747)
+- Re-organize the content of the `*.proto` files (No functional change). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14755)
+- SSZ files generation: Remove the `// Hash: ...` header.[[PR]](https://github.com/prysmaticlabs/prysm/pull/14760)
+- Updated Electra spec definition for `process_epoch`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14768)
+- Update our `go-libp2p-pubsub` dependency. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14770)
+- Re-organize the content of files to ease the creation of a new fork boilerplate. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14761)
+- Updated spec definition electra `process_registry_updates`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14767)
+- Fixed Metadata errors for peers connected via QUIC. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14776)
+- Updated spec definitions for `process_slashings` in godocs. Simplified `ProcessSlashings` API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14766)
+- Update spec tests to v1.5.0-beta.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14788)
+- Process light client finality updates only for new finalized epochs instead of doing it for every block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14718)
+- Update blobs by rpc topics from V2 to V1. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14785)
+- Updated geth to 1.14~. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14351)
+- E2e tests start from bellatrix. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14351)
+- Version pinning unclog after making some ux improvements. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14802)
+- Remove helpers to check for execution/compounding withdrawal credentials and expose them as methods. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14808)
+- Refactor `2006-01-02 15:04:05` to `time.DateTime`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14792)
+- Updated Prysm to Go v1.23.5. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14818)
+- Updated Bazel version to v7.4.1. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14818)
+- Updated rules_go to v0.46.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14818)
+- Updated golang.org/x/tools to be compatible with v1.23.5. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14818)
+- CI now requires proto files to be properly formatted with clang-format. [[PR](https://github.com/prysmaticlabs/prysm/pull/14831)]. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14831)
+- Improved test coverage of beacon-chain/core/electra/churn.go. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14837)
+- Update electra spec test to beta1. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14841)
+- Move deposit request nil check to apply all. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14849)
+- Do not mark blocks as invalid on context deadlines during state transition. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14838)
+- Update electra core processing to not mark block bad if execution request error. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14826)
+- Dependency: Updated go-ethereum to v1.14.13. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14872)
+- improving readability on proposer settings loader. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14868)
+- Removes existing validator.processSlot span and adds validator.processSlot span to slotCtx. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14874)
+- DownloadFinalizedData has moved from the api/client package to beacon-chain/sync/checkpoint. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14871)
+- Updated Blob-Batch-Limit to increase to 192 for electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14883)
+- Updated Blob-Batch-Limit-Burst-Factor to increase to 3. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14883)
+- Changed the derived batch limit when serving blobs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14883)
+- Updated go-libp2p-pubsub to v0.13.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14890)
+- Rename light client flag from `enable-lightclient` to `enable-light-client`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14887)
+- Update electra spec test to beta2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14901)
+
+### Removed
+
+- Cleanup ProcessSlashings method to remove unnecessary argument. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14762)
+- Remove `/proto/eth/v2` directory. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14765)
+- Remove `/memsize/` pprof endpoint as it will no longer be supported in go 1.23. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14351)
+- Clean `TestCanUpgrade*` tests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14791)
+- Remove `Copy()` from the `ReadOnlyBeaconBlock` interface. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14811)
+- Removed a tracing span on signature requests. These requests usually took less than 5 nanoseconds and are generally not worth tracing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14864)
+
+### Fixed
+
+- Added check to prevent nil pointer deference or out of bounds array access when validating the BLSToExecutionChange on an impossibly nil validator. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14705)
+- EIP-7691: Ensure new blobs subnets are subscribed on epoch in advance. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14759)
+- Fix kzg commitment inclusion proof depth minimal value. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14787)
+- Replace exampleIP to `96.7.129.13`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14795)
+- Fixed a p2p test to reliably return a static IP through DNS resolution. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14800)
+- `ToBlinded`: Use Fulu struct for Fulu (instead of Electra). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14797)
+- fix panic with type cast on pbgenericblock(). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14801)
+- Prysmctl generate genesis state: fix truncation of ExtraData to 32 bytes to satisfy SSZ marshaling. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14803)
+- added conditional evaluators to fix scenario e2e tests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14798)
+- Use `SingleAttestation` for Fulu in p2p attestation map. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14809)
+- `UpgradeToFulu`: Respect the specification. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14821)
+- `nodeFilter`: Implement `filterPeerForBlobSubnet` to avoid error logs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14822)
+- Fixed deposit packing for post-Electra: early return if EIP-6110 is applied. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14697)
+- Fix batch process new pending deposits by getting validators from state. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14827)
+- Fix handling unfound block at slot. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14852)
+- Fixed incorrect attester slashing length check. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14833)
+- Fix monitor service for Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14853)
+- add more nil checks on ToConsensus functions for added safety. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14867)
+- Fix electra state to safe share references on pending fields when append. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14895)
+- Add missing config values from the spec. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14903)
+- We remove the unused `rebuildTrie` assignments for fields which do not use them. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14906)
+- fix block api endpoint to handle blocks with the same structure but on different forks (i.e. fulu and electra). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14897)
+- We change how we track blob indexes during their reconstruction from the EL to prevent. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14909)
+- We now use the correct maximum value when serving blobs for electra blocks. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14910)
+
+### Security
+
+- go version upgrade to 1.22.10 for CVE CVE-2024-34156. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14729)
+- Update golang.org/x/crypto to v0.31.0 to address CVE-2024-45337. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14777)
+- Update golang.org/x/net to v0.33.0 to address CVE-2024-45338. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14780)
+
 ## [v5.2.0](https://github.com/prysmaticlabs/prysm/compare/v5.1.2...v5.2.0)

 Updating to this release is highly recommended, especially for users running v5.1.1 or v5.1.2.
@@ -2987,4 +3122,4 @@ There are no security updates in this release.

 # Older than v2.0.0

-For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases
+For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases
--- a/DEPENDENCIES.md
+++ b/DEPENDENCIES.md
@@ -55,7 +55,7 @@ bazel build //beacon-chain --config=release
 ## Adding / updating dependencies

 1. Add your dependency as you would with go modules. I.e. `go get ...`
-1. Run `bazel run //:gazelle -- update-repos -from_file=go.mod` to update the bazel managed dependencies.
+1. Run `bazel run //:gazelle -- update-repos -from_file=go.mod -to_macro=deps.bzl%prysm_deps -prune=true` to update the bazel managed dependencies.

 Example:

--- a/api/client/builder/BUILD.bazel
+++ b/api/client/builder/BUILD.bazel
@@ -33,6 +33,7 @@ go_library(
        "@com_github_pkg_errors//:go_default_library",
        "@com_github_prysmaticlabs_fastssz//:go_default_library",
        "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opentelemetry_go_contrib_instrumentation_net_http_otelhttp//:go_default_library",
        "@org_golang_google_protobuf//proto:go_default_library",
    ],
 )
@@ -46,6 +47,7 @@ go_test(
    data = glob(["testdata/**"]),
    embed = [":go_default_library"],
    deps = [
+        "//api:go_default_library",
        "//api/server/structs:go_default_library",
        "//config/fieldparams:go_default_library",
        "//config/params:go_default_library",
--- a/api/client/builder/client.go
+++ b/api/client/builder/client.go
@@ -25,6 +25,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	log "github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 )

 const (
@@ -108,7 +109,7 @@ func NewClient(host string, opts ...ClientOpt) (*Client, error) {
 		return nil, err
 	}
 	c := &Client{
-		hc:      &http.Client{},
+		hc:      &http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)},
 		baseURL: u,
 	}
 	for _, o := range opts {
@@ -154,6 +155,10 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 	if err != nil {
 		return
 	}
+	if method == http.MethodPost {
+		req.Header.Set("Content-Type", api.JsonMediaType)
+	}
+	req.Header.Set("Accept", api.JsonMediaType)
 	req.Header.Add("User-Agent", version.BuildData())
 	for _, o := range opts {
 		o(req)
--- a/api/client/builder/client_test.go
+++ b/api/client/builder/client_test.go
@@ -12,6 +12,7 @@ import (
 	"testing"

 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -89,6 +90,8 @@ func TestClient_RegisterValidator(t *testing.T) {
 	expectedPath := "/eth/v1/builder/validators"
 	hc := &http.Client{
 		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
+			require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 			body, err := io.ReadAll(r.Body)
 			defer func() {
 				require.NoError(t, r.Body.Close())
@@ -364,8 +367,8 @@ func TestSubmitBlindedBlock(t *testing.T) {
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
-				require.Equal(t, "application/json", r.Header.Get("Content-Type"))
-				require.Equal(t, "application/json", r.Header.Get("Accept"))
+				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
+				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				return &http.Response{
 					StatusCode: http.StatusOK,
 					Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayload)),
@@ -392,8 +395,8 @@ func TestSubmitBlindedBlock(t *testing.T) {
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "capella", r.Header.Get("Eth-Consensus-Version"))
-				require.Equal(t, "application/json", r.Header.Get("Content-Type"))
-				require.Equal(t, "application/json", r.Header.Get("Accept"))
+				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
+				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				return &http.Response{
 					StatusCode: http.StatusOK,
 					Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayloadCapella)),
@@ -423,8 +426,8 @@ func TestSubmitBlindedBlock(t *testing.T) {
 			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"))
-				require.Equal(t, "application/json", r.Header.Get("Content-Type"))
-				require.Equal(t, "application/json", r.Header.Get("Accept"))
+				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
+				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				var req structs.SignedBlindedBeaconBlockDeneb
 				err := json.NewDecoder(r.Body).Decode(&req)
 				require.NoError(t, err)
--- a/api/server/structs/BUILD.bazel
+++ b/api/server/structs/BUILD.bazel
@@ -4,9 +4,11 @@ go_library(
    name = "go_default_library",
    srcs = [
        "block.go",
+        "block_execution.go",
        "conversions.go",
        "conversions_blob.go",
        "conversions_block.go",
+        "conversions_block_execution.go",
        "conversions_lightclient.go",
        "conversions_state.go",
        "endpoints_beacon.go",
@@ -47,10 +49,16 @@ go_library(

 go_test(
    name = "go_default_test",
-    srcs = ["conversions_test.go"],
+    srcs = [
+        "conversions_block_execution_test.go",
+        "conversions_test.go",
+    ],
    embed = [":go_default_library"],
    deps = [
+        "//proto/engine/v1:go_default_library",
        "//proto/prysm/v1alpha1:go_default_library",
        "//testing/require:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
    ],
 )
--- a/api/server/structs/block.go
+++ b/api/server/structs/block.go
@@ -186,40 +186,6 @@ type BlindedBeaconBlockBodyBellatrix struct {
 	ExecutionPayloadHeader *ExecutionPayloadHeader `json:"execution_payload_header"`
 }

-type ExecutionPayload struct {
-	ParentHash    string   `json:"parent_hash"`
-	FeeRecipient  string   `json:"fee_recipient"`
-	StateRoot     string   `json:"state_root"`
-	ReceiptsRoot  string   `json:"receipts_root"`
-	LogsBloom     string   `json:"logs_bloom"`
-	PrevRandao    string   `json:"prev_randao"`
-	BlockNumber   string   `json:"block_number"`
-	GasLimit      string   `json:"gas_limit"`
-	GasUsed       string   `json:"gas_used"`
-	Timestamp     string   `json:"timestamp"`
-	ExtraData     string   `json:"extra_data"`
-	BaseFeePerGas string   `json:"base_fee_per_gas"`
-	BlockHash     string   `json:"block_hash"`
-	Transactions  []string `json:"transactions"`
-}
-
-type ExecutionPayloadHeader struct {
-	ParentHash       string `json:"parent_hash"`
-	FeeRecipient     string `json:"fee_recipient"`
-	StateRoot        string `json:"state_root"`
-	ReceiptsRoot     string `json:"receipts_root"`
-	LogsBloom        string `json:"logs_bloom"`
-	PrevRandao       string `json:"prev_randao"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	Timestamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data"`
-	BaseFeePerGas    string `json:"base_fee_per_gas"`
-	BlockHash        string `json:"block_hash"`
-	TransactionsRoot string `json:"transactions_root"`
-}
-
 // ----------------------------------------------------------------------------
 // Capella
 // ----------------------------------------------------------------------------
@@ -298,42 +264,6 @@ type BlindedBeaconBlockBodyCapella struct {
 	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
 }

-type ExecutionPayloadCapella struct {
-	ParentHash    string        `json:"parent_hash"`
-	FeeRecipient  string        `json:"fee_recipient"`
-	StateRoot     string        `json:"state_root"`
-	ReceiptsRoot  string        `json:"receipts_root"`
-	LogsBloom     string        `json:"logs_bloom"`
-	PrevRandao    string        `json:"prev_randao"`
-	BlockNumber   string        `json:"block_number"`
-	GasLimit      string        `json:"gas_limit"`
-	GasUsed       string        `json:"gas_used"`
-	Timestamp     string        `json:"timestamp"`
-	ExtraData     string        `json:"extra_data"`
-	BaseFeePerGas string        `json:"base_fee_per_gas"`
-	BlockHash     string        `json:"block_hash"`
-	Transactions  []string      `json:"transactions"`
-	Withdrawals   []*Withdrawal `json:"withdrawals"`
-}
-
-type ExecutionPayloadHeaderCapella struct {
-	ParentHash       string `json:"parent_hash"`
-	FeeRecipient     string `json:"fee_recipient"`
-	StateRoot        string `json:"state_root"`
-	ReceiptsRoot     string `json:"receipts_root"`
-	LogsBloom        string `json:"logs_bloom"`
-	PrevRandao       string `json:"prev_randao"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	Timestamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data"`
-	BaseFeePerGas    string `json:"base_fee_per_gas"`
-	BlockHash        string `json:"block_hash"`
-	TransactionsRoot string `json:"transactions_root"`
-	WithdrawalsRoot  string `json:"withdrawals_root"`
-}
-
 // ----------------------------------------------------------------------------
 // Deneb
 // ----------------------------------------------------------------------------
@@ -426,46 +356,6 @@ type BlindedBeaconBlockBodyDeneb struct {
 	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
 }

-type ExecutionPayloadDeneb struct {
-	ParentHash    string        `json:"parent_hash"`
-	FeeRecipient  string        `json:"fee_recipient"`
-	StateRoot     string        `json:"state_root"`
-	ReceiptsRoot  string        `json:"receipts_root"`
-	LogsBloom     string        `json:"logs_bloom"`
-	PrevRandao    string        `json:"prev_randao"`
-	BlockNumber   string        `json:"block_number"`
-	GasLimit      string        `json:"gas_limit"`
-	GasUsed       string        `json:"gas_used"`
-	Timestamp     string        `json:"timestamp"`
-	ExtraData     string        `json:"extra_data"`
-	BaseFeePerGas string        `json:"base_fee_per_gas"`
-	BlockHash     string        `json:"block_hash"`
-	Transactions  []string      `json:"transactions"`
-	Withdrawals   []*Withdrawal `json:"withdrawals"`
-	BlobGasUsed   string        `json:"blob_gas_used"`
-	ExcessBlobGas string        `json:"excess_blob_gas"`
-}
-
-type ExecutionPayloadHeaderDeneb struct {
-	ParentHash       string `json:"parent_hash"`
-	FeeRecipient     string `json:"fee_recipient"`
-	StateRoot        string `json:"state_root"`
-	ReceiptsRoot     string `json:"receipts_root"`
-	LogsBloom        string `json:"logs_bloom"`
-	PrevRandao       string `json:"prev_randao"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	Timestamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data"`
-	BaseFeePerGas    string `json:"base_fee_per_gas"`
-	BlockHash        string `json:"block_hash"`
-	TransactionsRoot string `json:"transactions_root"`
-	WithdrawalsRoot  string `json:"withdrawals_root"`
-	BlobGasUsed      string `json:"blob_gas_used"`
-	ExcessBlobGas    string `json:"excess_blob_gas"`
-}
-
 // ----------------------------------------------------------------------------
 // Electra
 // ----------------------------------------------------------------------------
@@ -560,14 +450,6 @@ type BlindedBeaconBlockBodyElectra struct {
 	ExecutionRequests      *ExecutionRequests            `json:"execution_requests"`
 }

-type (
-	ExecutionRequests struct {
-		Deposits       []*DepositRequest       `json:"deposits"`
-		Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
-		Consolidations []*ConsolidationRequest `json:"consolidations"`
-	}
-)
-
 // ----------------------------------------------------------------------------
 // Fulu
 // ----------------------------------------------------------------------------
@@ -579,14 +461,14 @@ type SignedBeaconBlockContentsFulu struct {
 }

 type BeaconBlockContentsFulu struct {
-	Block     *BeaconBlockFulu `json:"block"`
-	KzgProofs []string         `json:"kzg_proofs"`
-	Blobs     []string         `json:"blobs"`
+	Block     *BeaconBlockElectra `json:"block"`
+	KzgProofs []string            `json:"kzg_proofs"`
+	Blobs     []string            `json:"blobs"`
 }

 type SignedBeaconBlockFulu struct {
-	Message   *BeaconBlockFulu `json:"message"`
-	Signature string           `json:"signature"`
+	Message   *BeaconBlockElectra `json:"message"`
+	Signature string              `json:"signature"`
 }

 var _ SignedMessageJsoner = &SignedBeaconBlockFulu{}
@@ -599,36 +481,12 @@ func (s *SignedBeaconBlockFulu) SigString() string {
 	return s.Signature
 }

-type BeaconBlockFulu struct {
-	Slot          string               `json:"slot"`
-	ProposerIndex string               `json:"proposer_index"`
-	ParentRoot    string               `json:"parent_root"`
-	StateRoot     string               `json:"state_root"`
-	Body          *BeaconBlockBodyFulu `json:"body"`
-}
-
-type BeaconBlockBodyFulu struct {
-	RandaoReveal          string                        `json:"randao_reveal"`
-	Eth1Data              *Eth1Data                     `json:"eth1_data"`
-	Graffiti              string                        `json:"graffiti"`
-	ProposerSlashings     []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings     []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations          []*AttestationElectra         `json:"attestations"`
-	Deposits              []*Deposit                    `json:"deposits"`
-	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayload      *ExecutionPayloadDeneb        `json:"execution_payload"`
-	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
-	ExecutionRequests     *ExecutionRequests            `json:"execution_requests"`
-}
-
 type BlindedBeaconBlockFulu struct {
-	Slot          string                      `json:"slot"`
-	ProposerIndex string                      `json:"proposer_index"`
-	ParentRoot    string                      `json:"parent_root"`
-	StateRoot     string                      `json:"state_root"`
-	Body          *BlindedBeaconBlockBodyFulu `json:"body"`
+	Slot          string                         `json:"slot"`
+	ProposerIndex string                         `json:"proposer_index"`
+	ParentRoot    string                         `json:"parent_root"`
+	StateRoot     string                         `json:"state_root"`
+	Body          *BlindedBeaconBlockBodyElectra `json:"body"`
 }

 type SignedBlindedBeaconBlockFulu struct {
@@ -645,19 +503,3 @@ func (s *SignedBlindedBeaconBlockFulu) MessageRawJson() ([]byte, error) {
 func (s *SignedBlindedBeaconBlockFulu) SigString() string {
 	return s.Signature
 }
-
-type BlindedBeaconBlockBodyFulu struct {
-	RandaoReveal           string                        `json:"randao_reveal"`
-	Eth1Data               *Eth1Data                     `json:"eth1_data"`
-	Graffiti               string                        `json:"graffiti"`
-	ProposerSlashings      []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings      []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations           []*AttestationElectra         `json:"attestations"`
-	Deposits               []*Deposit                    `json:"deposits"`
-	VoluntaryExits         []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate          *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayloadHeader *ExecutionPayloadHeaderDeneb  `json:"execution_payload_header"`
-	BLSToExecutionChanges  []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
-	ExecutionRequests      *ExecutionRequests            `json:"execution_requests"`
-}
--- a/api/server/structs/block_execution.go
+++ b/api/server/structs/block_execution.go
@@ -0,0 +1,157 @@
+package structs
+
+// ----------------------------------------------------------------------------
+// Bellatrix
+// ----------------------------------------------------------------------------
+
+type ExecutionPayload struct {
+	ParentHash    string   `json:"parent_hash"`
+	FeeRecipient  string   `json:"fee_recipient"`
+	StateRoot     string   `json:"state_root"`
+	ReceiptsRoot  string   `json:"receipts_root"`
+	LogsBloom     string   `json:"logs_bloom"`
+	PrevRandao    string   `json:"prev_randao"`
+	BlockNumber   string   `json:"block_number"`
+	GasLimit      string   `json:"gas_limit"`
+	GasUsed       string   `json:"gas_used"`
+	Timestamp     string   `json:"timestamp"`
+	ExtraData     string   `json:"extra_data"`
+	BaseFeePerGas string   `json:"base_fee_per_gas"`
+	BlockHash     string   `json:"block_hash"`
+	Transactions  []string `json:"transactions"`
+}
+
+type ExecutionPayloadHeader struct {
+	ParentHash       string `json:"parent_hash"`
+	FeeRecipient     string `json:"fee_recipient"`
+	StateRoot        string `json:"state_root"`
+	ReceiptsRoot     string `json:"receipts_root"`
+	LogsBloom        string `json:"logs_bloom"`
+	PrevRandao       string `json:"prev_randao"`
+	BlockNumber      string `json:"block_number"`
+	GasLimit         string `json:"gas_limit"`
+	GasUsed          string `json:"gas_used"`
+	Timestamp        string `json:"timestamp"`
+	ExtraData        string `json:"extra_data"`
+	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlockHash        string `json:"block_hash"`
+	TransactionsRoot string `json:"transactions_root"`
+}
+
+// ----------------------------------------------------------------------------
+// Capella
+// ----------------------------------------------------------------------------
+
+type ExecutionPayloadCapella struct {
+	ParentHash    string        `json:"parent_hash"`
+	FeeRecipient  string        `json:"fee_recipient"`
+	StateRoot     string        `json:"state_root"`
+	ReceiptsRoot  string        `json:"receipts_root"`
+	LogsBloom     string        `json:"logs_bloom"`
+	PrevRandao    string        `json:"prev_randao"`
+	BlockNumber   string        `json:"block_number"`
+	GasLimit      string        `json:"gas_limit"`
+	GasUsed       string        `json:"gas_used"`
+	Timestamp     string        `json:"timestamp"`
+	ExtraData     string        `json:"extra_data"`
+	BaseFeePerGas string        `json:"base_fee_per_gas"`
+	BlockHash     string        `json:"block_hash"`
+	Transactions  []string      `json:"transactions"`
+	Withdrawals   []*Withdrawal `json:"withdrawals"`
+}
+
+type ExecutionPayloadHeaderCapella struct {
+	ParentHash       string `json:"parent_hash"`
+	FeeRecipient     string `json:"fee_recipient"`
+	StateRoot        string `json:"state_root"`
+	ReceiptsRoot     string `json:"receipts_root"`
+	LogsBloom        string `json:"logs_bloom"`
+	PrevRandao       string `json:"prev_randao"`
+	BlockNumber      string `json:"block_number"`
+	GasLimit         string `json:"gas_limit"`
+	GasUsed          string `json:"gas_used"`
+	Timestamp        string `json:"timestamp"`
+	ExtraData        string `json:"extra_data"`
+	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlockHash        string `json:"block_hash"`
+	TransactionsRoot string `json:"transactions_root"`
+	WithdrawalsRoot  string `json:"withdrawals_root"`
+}
+
+// ----------------------------------------------------------------------------
+// Deneb
+// ----------------------------------------------------------------------------
+
+type ExecutionPayloadDeneb struct {
+	ParentHash    string        `json:"parent_hash"`
+	FeeRecipient  string        `json:"fee_recipient"`
+	StateRoot     string        `json:"state_root"`
+	ReceiptsRoot  string        `json:"receipts_root"`
+	LogsBloom     string        `json:"logs_bloom"`
+	PrevRandao    string        `json:"prev_randao"`
+	BlockNumber   string        `json:"block_number"`
+	GasLimit      string        `json:"gas_limit"`
+	GasUsed       string        `json:"gas_used"`
+	Timestamp     string        `json:"timestamp"`
+	ExtraData     string        `json:"extra_data"`
+	BaseFeePerGas string        `json:"base_fee_per_gas"`
+	BlockHash     string        `json:"block_hash"`
+	Transactions  []string      `json:"transactions"`
+	Withdrawals   []*Withdrawal `json:"withdrawals"`
+	BlobGasUsed   string        `json:"blob_gas_used"`
+	ExcessBlobGas string        `json:"excess_blob_gas"`
+}
+
+type ExecutionPayloadHeaderDeneb struct {
+	ParentHash       string `json:"parent_hash"`
+	FeeRecipient     string `json:"fee_recipient"`
+	StateRoot        string `json:"state_root"`
+	ReceiptsRoot     string `json:"receipts_root"`
+	LogsBloom        string `json:"logs_bloom"`
+	PrevRandao       string `json:"prev_randao"`
+	BlockNumber      string `json:"block_number"`
+	GasLimit         string `json:"gas_limit"`
+	GasUsed          string `json:"gas_used"`
+	Timestamp        string `json:"timestamp"`
+	ExtraData        string `json:"extra_data"`
+	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlockHash        string `json:"block_hash"`
+	TransactionsRoot string `json:"transactions_root"`
+	WithdrawalsRoot  string `json:"withdrawals_root"`
+	BlobGasUsed      string `json:"blob_gas_used"`
+	ExcessBlobGas    string `json:"excess_blob_gas"`
+}
+
+// ----------------------------------------------------------------------------
+// Electra
+// ----------------------------------------------------------------------------
+
+type ExecutionRequests struct {
+	Deposits       []*DepositRequest       `json:"deposits"`
+	Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
+	Consolidations []*ConsolidationRequest `json:"consolidations"`
+}
+
+type DepositRequest struct {
+	Pubkey                string `json:"pubkey"`
+	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Amount                string `json:"amount"`
+	Signature             string `json:"signature"`
+	Index                 string `json:"index"`
+}
+
+type WithdrawalRequest struct {
+	SourceAddress   string `json:"source_address"`
+	ValidatorPubkey string `json:"validator_pubkey"`
+	Amount          string `json:"amount"`
+}
+
+type ConsolidationRequest struct {
+	SourceAddress string `json:"source_address"`
+	SourcePubkey  string `json:"source_pubkey"`
+	TargetPubkey  string `json:"target_pubkey"`
+}
+
+// ----------------------------------------------------------------------------
+// Fulu
+// ----------------------------------------------------------------------------
--- a/api/server/structs/conversions.go
+++ b/api/server/structs/conversions.go
@@ -889,126 +889,6 @@ func WithdrawalFromConsensus(w *enginev1.Withdrawal) *Withdrawal {
 	}
 }

-func WithdrawalRequestsFromConsensus(ws []*enginev1.WithdrawalRequest) []*WithdrawalRequest {
-	result := make([]*WithdrawalRequest, len(ws))
-	for i, w := range ws {
-		result[i] = WithdrawalRequestFromConsensus(w)
-	}
-	return result
-}
-
-func WithdrawalRequestFromConsensus(w *enginev1.WithdrawalRequest) *WithdrawalRequest {
-	return &WithdrawalRequest{
-		SourceAddress:   hexutil.Encode(w.SourceAddress),
-		ValidatorPubkey: hexutil.Encode(w.ValidatorPubkey),
-		Amount:          fmt.Sprintf("%d", w.Amount),
-	}
-}
-
-func (w *WithdrawalRequest) ToConsensus() (*enginev1.WithdrawalRequest, error) {
-	src, err := bytesutil.DecodeHexWithLength(w.SourceAddress, common.AddressLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SourceAddress")
-	}
-	pubkey, err := bytesutil.DecodeHexWithLength(w.ValidatorPubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ValidatorPubkey")
-	}
-	amount, err := strconv.ParseUint(w.Amount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Amount")
-	}
-	return &enginev1.WithdrawalRequest{
-		SourceAddress:   src,
-		ValidatorPubkey: pubkey,
-		Amount:          amount,
-	}, nil
-}
-
-func ConsolidationRequestsFromConsensus(cs []*enginev1.ConsolidationRequest) []*ConsolidationRequest {
-	result := make([]*ConsolidationRequest, len(cs))
-	for i, c := range cs {
-		result[i] = ConsolidationRequestFromConsensus(c)
-	}
-	return result
-}
-
-func ConsolidationRequestFromConsensus(c *enginev1.ConsolidationRequest) *ConsolidationRequest {
-	return &ConsolidationRequest{
-		SourceAddress: hexutil.Encode(c.SourceAddress),
-		SourcePubkey:  hexutil.Encode(c.SourcePubkey),
-		TargetPubkey:  hexutil.Encode(c.TargetPubkey),
-	}
-}
-
-func (c *ConsolidationRequest) ToConsensus() (*enginev1.ConsolidationRequest, error) {
-	srcAddress, err := bytesutil.DecodeHexWithLength(c.SourceAddress, common.AddressLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SourceAddress")
-	}
-	srcPubkey, err := bytesutil.DecodeHexWithLength(c.SourcePubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SourcePubkey")
-	}
-	targetPubkey, err := bytesutil.DecodeHexWithLength(c.TargetPubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "TargetPubkey")
-	}
-	return &enginev1.ConsolidationRequest{
-		SourceAddress: srcAddress,
-		SourcePubkey:  srcPubkey,
-		TargetPubkey:  targetPubkey,
-	}, nil
-}
-
-func DepositRequestsFromConsensus(ds []*enginev1.DepositRequest) []*DepositRequest {
-	result := make([]*DepositRequest, len(ds))
-	for i, d := range ds {
-		result[i] = DepositRequestFromConsensus(d)
-	}
-	return result
-}
-
-func DepositRequestFromConsensus(d *enginev1.DepositRequest) *DepositRequest {
-	return &DepositRequest{
-		Pubkey:                hexutil.Encode(d.Pubkey),
-		WithdrawalCredentials: hexutil.Encode(d.WithdrawalCredentials),
-		Amount:                fmt.Sprintf("%d", d.Amount),
-		Signature:             hexutil.Encode(d.Signature),
-		Index:                 fmt.Sprintf("%d", d.Index),
-	}
-}
-
-func (d *DepositRequest) ToConsensus() (*enginev1.DepositRequest, error) {
-	pubkey, err := bytesutil.DecodeHexWithLength(d.Pubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Pubkey")
-	}
-	withdrawalCredentials, err := bytesutil.DecodeHexWithLength(d.WithdrawalCredentials, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "WithdrawalCredentials")
-	}
-	amount, err := strconv.ParseUint(d.Amount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Amount")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(d.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	index, err := strconv.ParseUint(d.Index, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Index")
-	}
-	return &enginev1.DepositRequest{
-		Pubkey:                pubkey,
-		WithdrawalCredentials: withdrawalCredentials,
-		Amount:                amount,
-		Signature:             sig,
-		Index:                 index,
-	}, nil
-}
-
 func ProposerSlashingsToConsensus(src []*ProposerSlashing) ([]*eth.ProposerSlashing, error) {
 	if src == nil {
 		return nil, server.NewDecodeError(errNilValue, "ProposerSlashings")
--- a/api/server/structs/conversions_block.go
+++ b/api/server/structs/conversions_block.go
--- a/api/server/structs/conversions_block_execution.go
+++ b/api/server/structs/conversions_block_execution.go
@@ -0,0 +1,973 @@
+package structs
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/prysmaticlabs/prysm/v5/api/server"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/container/slice"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+)
+
+// ----------------------------------------------------------------------------
+// Bellatrix
+// ----------------------------------------------------------------------------
+
+func ExecutionPayloadFromConsensus(payload *enginev1.ExecutionPayload) (*ExecutionPayload, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+	transactions := make([]string, len(payload.Transactions))
+	for i, tx := range payload.Transactions {
+		transactions[i] = hexutil.Encode(tx)
+	}
+
+	return &ExecutionPayload{
+		ParentHash:    hexutil.Encode(payload.ParentHash),
+		FeeRecipient:  hexutil.Encode(payload.FeeRecipient),
+		StateRoot:     hexutil.Encode(payload.StateRoot),
+		ReceiptsRoot:  hexutil.Encode(payload.ReceiptsRoot),
+		LogsBloom:     hexutil.Encode(payload.LogsBloom),
+		PrevRandao:    hexutil.Encode(payload.PrevRandao),
+		BlockNumber:   fmt.Sprintf("%d", payload.BlockNumber),
+		GasLimit:      fmt.Sprintf("%d", payload.GasLimit),
+		GasUsed:       fmt.Sprintf("%d", payload.GasUsed),
+		Timestamp:     fmt.Sprintf("%d", payload.Timestamp),
+		ExtraData:     hexutil.Encode(payload.ExtraData),
+		BaseFeePerGas: baseFeePerGas,
+		BlockHash:     hexutil.Encode(payload.BlockHash),
+		Transactions:  transactions,
+	}, nil
+}
+
+func (e *ExecutionPayload) ToConsensus() (*enginev1.ExecutionPayload, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionPayload")
+	}
+	payloadParentHash, err := bytesutil.DecodeHexWithLength(e.ParentHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ParentHash")
+	}
+	payloadFeeRecipient, err := bytesutil.DecodeHexWithLength(e.FeeRecipient, fieldparams.FeeRecipientLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.FeeRecipient")
+	}
+	payloadStateRoot, err := bytesutil.DecodeHexWithLength(e.StateRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.StateRoot")
+	}
+	payloadReceiptsRoot, err := bytesutil.DecodeHexWithLength(e.ReceiptsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ReceiptsRoot")
+	}
+	payloadLogsBloom, err := bytesutil.DecodeHexWithLength(e.LogsBloom, fieldparams.LogsBloomLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.LogsBloom")
+	}
+	payloadPrevRandao, err := bytesutil.DecodeHexWithLength(e.PrevRandao, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.PrevRandao")
+	}
+	payloadBlockNumber, err := strconv.ParseUint(e.BlockNumber, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlockNumber")
+	}
+	payloadGasLimit, err := strconv.ParseUint(e.GasLimit, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.GasLimit")
+	}
+	payloadGasUsed, err := strconv.ParseUint(e.GasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.GasUsed")
+	}
+	payloadTimestamp, err := strconv.ParseUint(e.Timestamp, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Timestamp")
+	}
+	payloadExtraData, err := bytesutil.DecodeHexWithMaxLength(e.ExtraData, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ExtraData")
+	}
+	payloadBaseFeePerGas, err := bytesutil.Uint256ToSSZBytes(e.BaseFeePerGas)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BaseFeePerGas")
+	}
+	payloadBlockHash, err := bytesutil.DecodeHexWithLength(e.BlockHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlockHash")
+	}
+	err = slice.VerifyMaxLength(e.Transactions, fieldparams.MaxTxsPerPayloadLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Transactions")
+	}
+	payloadTxs := make([][]byte, len(e.Transactions))
+	for i, tx := range e.Transactions {
+		payloadTxs[i], err = bytesutil.DecodeHexWithMaxLength(tx, fieldparams.MaxBytesPerTxLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Transactions[%d]", i))
+		}
+	}
+	return &enginev1.ExecutionPayload{
+		ParentHash:    payloadParentHash,
+		FeeRecipient:  payloadFeeRecipient,
+		StateRoot:     payloadStateRoot,
+		ReceiptsRoot:  payloadReceiptsRoot,
+		LogsBloom:     payloadLogsBloom,
+		PrevRandao:    payloadPrevRandao,
+		BlockNumber:   payloadBlockNumber,
+		GasLimit:      payloadGasLimit,
+		GasUsed:       payloadGasUsed,
+		Timestamp:     payloadTimestamp,
+		ExtraData:     payloadExtraData,
+		BaseFeePerGas: payloadBaseFeePerGas,
+		BlockHash:     payloadBlockHash,
+		Transactions:  payloadTxs,
+	}, nil
+}
+
+func ExecutionPayloadHeaderFromConsensus(payload *enginev1.ExecutionPayloadHeader) (*ExecutionPayloadHeader, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ExecutionPayloadHeader{
+		ParentHash:       hexutil.Encode(payload.ParentHash),
+		FeeRecipient:     hexutil.Encode(payload.FeeRecipient),
+		StateRoot:        hexutil.Encode(payload.StateRoot),
+		ReceiptsRoot:     hexutil.Encode(payload.ReceiptsRoot),
+		LogsBloom:        hexutil.Encode(payload.LogsBloom),
+		PrevRandao:       hexutil.Encode(payload.PrevRandao),
+		BlockNumber:      fmt.Sprintf("%d", payload.BlockNumber),
+		GasLimit:         fmt.Sprintf("%d", payload.GasLimit),
+		GasUsed:          fmt.Sprintf("%d", payload.GasUsed),
+		Timestamp:        fmt.Sprintf("%d", payload.Timestamp),
+		ExtraData:        hexutil.Encode(payload.ExtraData),
+		BaseFeePerGas:    baseFeePerGas,
+		BlockHash:        hexutil.Encode(payload.BlockHash),
+		TransactionsRoot: hexutil.Encode(payload.TransactionsRoot),
+	}, nil
+}
+
+func (e *ExecutionPayloadHeader) ToConsensus() (*enginev1.ExecutionPayloadHeader, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionPayloadHeader")
+	}
+	payloadParentHash, err := bytesutil.DecodeHexWithLength(e.ParentHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ParentHash")
+	}
+	payloadFeeRecipient, err := bytesutil.DecodeHexWithLength(e.FeeRecipient, fieldparams.FeeRecipientLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.FeeRecipient")
+	}
+	payloadStateRoot, err := bytesutil.DecodeHexWithLength(e.StateRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.StateRoot")
+	}
+	payloadReceiptsRoot, err := bytesutil.DecodeHexWithLength(e.ReceiptsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ReceiptsRoot")
+	}
+	payloadLogsBloom, err := bytesutil.DecodeHexWithLength(e.LogsBloom, fieldparams.LogsBloomLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.LogsBloom")
+	}
+	payloadPrevRandao, err := bytesutil.DecodeHexWithLength(e.PrevRandao, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.PrevRandao")
+	}
+	payloadBlockNumber, err := strconv.ParseUint(e.BlockNumber, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BlockNumber")
+	}
+	payloadGasLimit, err := strconv.ParseUint(e.GasLimit, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.GasLimit")
+	}
+	payloadGasUsed, err := strconv.ParseUint(e.GasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.GasUsed")
+	}
+	payloadTimestamp, err := strconv.ParseUint(e.Timestamp, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.Timestamp")
+	}
+	payloadExtraData, err := bytesutil.DecodeHexWithMaxLength(e.ExtraData, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ExtraData")
+	}
+	payloadBaseFeePerGas, err := bytesutil.Uint256ToSSZBytes(e.BaseFeePerGas)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BaseFeePerGas")
+	}
+	payloadBlockHash, err := bytesutil.DecodeHexWithLength(e.BlockHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BlockHash")
+	}
+	payloadTxsRoot, err := bytesutil.DecodeHexWithLength(e.TransactionsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.TransactionsRoot")
+	}
+
+	return &enginev1.ExecutionPayloadHeader{
+		ParentHash:       payloadParentHash,
+		FeeRecipient:     payloadFeeRecipient,
+		StateRoot:        payloadStateRoot,
+		ReceiptsRoot:     payloadReceiptsRoot,
+		LogsBloom:        payloadLogsBloom,
+		PrevRandao:       payloadPrevRandao,
+		BlockNumber:      payloadBlockNumber,
+		GasLimit:         payloadGasLimit,
+		GasUsed:          payloadGasUsed,
+		Timestamp:        payloadTimestamp,
+		ExtraData:        payloadExtraData,
+		BaseFeePerGas:    payloadBaseFeePerGas,
+		BlockHash:        payloadBlockHash,
+		TransactionsRoot: payloadTxsRoot,
+	}, nil
+}
+
+// ----------------------------------------------------------------------------
+// Capella
+// ----------------------------------------------------------------------------
+
+func ExecutionPayloadCapellaFromConsensus(payload *enginev1.ExecutionPayloadCapella) (*ExecutionPayloadCapella, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+	transactions := make([]string, len(payload.Transactions))
+	for i, tx := range payload.Transactions {
+		transactions[i] = hexutil.Encode(tx)
+	}
+
+	return &ExecutionPayloadCapella{
+		ParentHash:    hexutil.Encode(payload.ParentHash),
+		FeeRecipient:  hexutil.Encode(payload.FeeRecipient),
+		StateRoot:     hexutil.Encode(payload.StateRoot),
+		ReceiptsRoot:  hexutil.Encode(payload.ReceiptsRoot),
+		LogsBloom:     hexutil.Encode(payload.LogsBloom),
+		PrevRandao:    hexutil.Encode(payload.PrevRandao),
+		BlockNumber:   fmt.Sprintf("%d", payload.BlockNumber),
+		GasLimit:      fmt.Sprintf("%d", payload.GasLimit),
+		GasUsed:       fmt.Sprintf("%d", payload.GasUsed),
+		Timestamp:     fmt.Sprintf("%d", payload.Timestamp),
+		ExtraData:     hexutil.Encode(payload.ExtraData),
+		BaseFeePerGas: baseFeePerGas,
+		BlockHash:     hexutil.Encode(payload.BlockHash),
+		Transactions:  transactions,
+		Withdrawals:   WithdrawalsFromConsensus(payload.Withdrawals),
+	}, nil
+}
+
+func (e *ExecutionPayloadCapella) ToConsensus() (*enginev1.ExecutionPayloadCapella, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionPayload")
+	}
+	payloadParentHash, err := bytesutil.DecodeHexWithLength(e.ParentHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ParentHash")
+	}
+	payloadFeeRecipient, err := bytesutil.DecodeHexWithLength(e.FeeRecipient, fieldparams.FeeRecipientLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.FeeRecipient")
+	}
+	payloadStateRoot, err := bytesutil.DecodeHexWithLength(e.StateRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.StateRoot")
+	}
+	payloadReceiptsRoot, err := bytesutil.DecodeHexWithLength(e.ReceiptsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ReceiptsRoot")
+	}
+	payloadLogsBloom, err := bytesutil.DecodeHexWithLength(e.LogsBloom, fieldparams.LogsBloomLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.LogsBloom")
+	}
+	payloadPrevRandao, err := bytesutil.DecodeHexWithLength(e.PrevRandao, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.PrevRandao")
+	}
+	payloadBlockNumber, err := strconv.ParseUint(e.BlockNumber, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlockNumber")
+	}
+	payloadGasLimit, err := strconv.ParseUint(e.GasLimit, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.GasLimit")
+	}
+	payloadGasUsed, err := strconv.ParseUint(e.GasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.GasUsed")
+	}
+	payloadTimestamp, err := strconv.ParseUint(e.Timestamp, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Timestamp")
+	}
+	payloadExtraData, err := bytesutil.DecodeHexWithMaxLength(e.ExtraData, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ExtraData")
+	}
+	payloadBaseFeePerGas, err := bytesutil.Uint256ToSSZBytes(e.BaseFeePerGas)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BaseFeePerGas")
+	}
+	payloadBlockHash, err := bytesutil.DecodeHexWithLength(e.BlockHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlockHash")
+	}
+	err = slice.VerifyMaxLength(e.Transactions, fieldparams.MaxTxsPerPayloadLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Transactions")
+	}
+	payloadTxs := make([][]byte, len(e.Transactions))
+	for i, tx := range e.Transactions {
+		payloadTxs[i], err = bytesutil.DecodeHexWithMaxLength(tx, fieldparams.MaxBytesPerTxLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Transactions[%d]", i))
+		}
+	}
+	err = slice.VerifyMaxLength(e.Withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Withdrawals")
+	}
+	withdrawals := make([]*enginev1.Withdrawal, len(e.Withdrawals))
+	for i, w := range e.Withdrawals {
+		withdrawalIndex, err := strconv.ParseUint(w.WithdrawalIndex, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].WithdrawalIndex", i))
+		}
+		validatorIndex, err := strconv.ParseUint(w.ValidatorIndex, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].ValidatorIndex", i))
+		}
+		address, err := bytesutil.DecodeHexWithLength(w.ExecutionAddress, common.AddressLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].ExecutionAddress", i))
+		}
+		amount, err := strconv.ParseUint(w.Amount, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].Amount", i))
+		}
+		withdrawals[i] = &enginev1.Withdrawal{
+			Index:          withdrawalIndex,
+			ValidatorIndex: primitives.ValidatorIndex(validatorIndex),
+			Address:        address,
+			Amount:         amount,
+		}
+	}
+	return &enginev1.ExecutionPayloadCapella{
+		ParentHash:    payloadParentHash,
+		FeeRecipient:  payloadFeeRecipient,
+		StateRoot:     payloadStateRoot,
+		ReceiptsRoot:  payloadReceiptsRoot,
+		LogsBloom:     payloadLogsBloom,
+		PrevRandao:    payloadPrevRandao,
+		BlockNumber:   payloadBlockNumber,
+		GasLimit:      payloadGasLimit,
+		GasUsed:       payloadGasUsed,
+		Timestamp:     payloadTimestamp,
+		ExtraData:     payloadExtraData,
+		BaseFeePerGas: payloadBaseFeePerGas,
+		BlockHash:     payloadBlockHash,
+		Transactions:  payloadTxs,
+		Withdrawals:   withdrawals,
+	}, nil
+}
+
+func ExecutionPayloadHeaderCapellaFromConsensus(payload *enginev1.ExecutionPayloadHeaderCapella) (*ExecutionPayloadHeaderCapella, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ExecutionPayloadHeaderCapella{
+		ParentHash:       hexutil.Encode(payload.ParentHash),
+		FeeRecipient:     hexutil.Encode(payload.FeeRecipient),
+		StateRoot:        hexutil.Encode(payload.StateRoot),
+		ReceiptsRoot:     hexutil.Encode(payload.ReceiptsRoot),
+		LogsBloom:        hexutil.Encode(payload.LogsBloom),
+		PrevRandao:       hexutil.Encode(payload.PrevRandao),
+		BlockNumber:      fmt.Sprintf("%d", payload.BlockNumber),
+		GasLimit:         fmt.Sprintf("%d", payload.GasLimit),
+		GasUsed:          fmt.Sprintf("%d", payload.GasUsed),
+		Timestamp:        fmt.Sprintf("%d", payload.Timestamp),
+		ExtraData:        hexutil.Encode(payload.ExtraData),
+		BaseFeePerGas:    baseFeePerGas,
+		BlockHash:        hexutil.Encode(payload.BlockHash),
+		TransactionsRoot: hexutil.Encode(payload.TransactionsRoot),
+		WithdrawalsRoot:  hexutil.Encode(payload.WithdrawalsRoot),
+	}, nil
+}
+
+func (e *ExecutionPayloadHeaderCapella) ToConsensus() (*enginev1.ExecutionPayloadHeaderCapella, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionPayloadHeader")
+	}
+	payloadParentHash, err := bytesutil.DecodeHexWithLength(e.ParentHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ParentHash")
+	}
+	payloadFeeRecipient, err := bytesutil.DecodeHexWithLength(e.FeeRecipient, fieldparams.FeeRecipientLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.FeeRecipient")
+	}
+	payloadStateRoot, err := bytesutil.DecodeHexWithLength(e.StateRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.StateRoot")
+	}
+	payloadReceiptsRoot, err := bytesutil.DecodeHexWithLength(e.ReceiptsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ReceiptsRoot")
+	}
+	payloadLogsBloom, err := bytesutil.DecodeHexWithLength(e.LogsBloom, fieldparams.LogsBloomLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.LogsBloom")
+	}
+	payloadPrevRandao, err := bytesutil.DecodeHexWithLength(e.PrevRandao, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.PrevRandao")
+	}
+	payloadBlockNumber, err := strconv.ParseUint(e.BlockNumber, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BlockNumber")
+	}
+	payloadGasLimit, err := strconv.ParseUint(e.GasLimit, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.GasLimit")
+	}
+	payloadGasUsed, err := strconv.ParseUint(e.GasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.GasUsed")
+	}
+	payloadTimestamp, err := strconv.ParseUint(e.Timestamp, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.Timestamp")
+	}
+	payloadExtraData, err := bytesutil.DecodeHexWithMaxLength(e.ExtraData, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ExtraData")
+	}
+	payloadBaseFeePerGas, err := bytesutil.Uint256ToSSZBytes(e.BaseFeePerGas)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BaseFeePerGas")
+	}
+	payloadBlockHash, err := bytesutil.DecodeHexWithMaxLength(e.BlockHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BlockHash")
+	}
+	payloadTxsRoot, err := bytesutil.DecodeHexWithMaxLength(e.TransactionsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.TransactionsRoot")
+	}
+	payloadWithdrawalsRoot, err := bytesutil.DecodeHexWithMaxLength(e.WithdrawalsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.WithdrawalsRoot")
+	}
+	return &enginev1.ExecutionPayloadHeaderCapella{
+		ParentHash:       payloadParentHash,
+		FeeRecipient:     payloadFeeRecipient,
+		StateRoot:        payloadStateRoot,
+		ReceiptsRoot:     payloadReceiptsRoot,
+		LogsBloom:        payloadLogsBloom,
+		PrevRandao:       payloadPrevRandao,
+		BlockNumber:      payloadBlockNumber,
+		GasLimit:         payloadGasLimit,
+		GasUsed:          payloadGasUsed,
+		Timestamp:        payloadTimestamp,
+		ExtraData:        payloadExtraData,
+		BaseFeePerGas:    payloadBaseFeePerGas,
+		BlockHash:        payloadBlockHash,
+		TransactionsRoot: payloadTxsRoot,
+		WithdrawalsRoot:  payloadWithdrawalsRoot,
+	}, nil
+}
+
+// ----------------------------------------------------------------------------
+// Deneb
+// ----------------------------------------------------------------------------
+
+func ExecutionPayloadDenebFromConsensus(payload *enginev1.ExecutionPayloadDeneb) (*ExecutionPayloadDeneb, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+	transactions := make([]string, len(payload.Transactions))
+	for i, tx := range payload.Transactions {
+		transactions[i] = hexutil.Encode(tx)
+	}
+
+	return &ExecutionPayloadDeneb{
+		ParentHash:    hexutil.Encode(payload.ParentHash),
+		FeeRecipient:  hexutil.Encode(payload.FeeRecipient),
+		StateRoot:     hexutil.Encode(payload.StateRoot),
+		ReceiptsRoot:  hexutil.Encode(payload.ReceiptsRoot),
+		LogsBloom:     hexutil.Encode(payload.LogsBloom),
+		PrevRandao:    hexutil.Encode(payload.PrevRandao),
+		BlockNumber:   fmt.Sprintf("%d", payload.BlockNumber),
+		GasLimit:      fmt.Sprintf("%d", payload.GasLimit),
+		GasUsed:       fmt.Sprintf("%d", payload.GasUsed),
+		Timestamp:     fmt.Sprintf("%d", payload.Timestamp),
+		ExtraData:     hexutil.Encode(payload.ExtraData),
+		BaseFeePerGas: baseFeePerGas,
+		BlockHash:     hexutil.Encode(payload.BlockHash),
+		Transactions:  transactions,
+		Withdrawals:   WithdrawalsFromConsensus(payload.Withdrawals),
+		BlobGasUsed:   fmt.Sprintf("%d", payload.BlobGasUsed),
+		ExcessBlobGas: fmt.Sprintf("%d", payload.ExcessBlobGas),
+	}, nil
+}
+
+func (e *ExecutionPayloadDeneb) ToConsensus() (*enginev1.ExecutionPayloadDeneb, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionPayload")
+	}
+	payloadParentHash, err := bytesutil.DecodeHexWithLength(e.ParentHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ParentHash")
+	}
+	payloadFeeRecipient, err := bytesutil.DecodeHexWithLength(e.FeeRecipient, fieldparams.FeeRecipientLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.FeeRecipient")
+	}
+	payloadStateRoot, err := bytesutil.DecodeHexWithLength(e.StateRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.StateRoot")
+	}
+	payloadReceiptsRoot, err := bytesutil.DecodeHexWithLength(e.ReceiptsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ReceiptsRoot")
+	}
+	payloadLogsBloom, err := bytesutil.DecodeHexWithLength(e.LogsBloom, fieldparams.LogsBloomLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.LogsBloom")
+	}
+	payloadPrevRandao, err := bytesutil.DecodeHexWithLength(e.PrevRandao, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.PrevRandao")
+	}
+	payloadBlockNumber, err := strconv.ParseUint(e.BlockNumber, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlockNumber")
+	}
+	payloadGasLimit, err := strconv.ParseUint(e.GasLimit, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.GasLimit")
+	}
+	payloadGasUsed, err := strconv.ParseUint(e.GasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.GasUsed")
+	}
+	payloadTimestamp, err := strconv.ParseUint(e.Timestamp, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.Timestamp")
+	}
+	payloadExtraData, err := bytesutil.DecodeHexWithMaxLength(e.ExtraData, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ExtraData")
+	}
+	payloadBaseFeePerGas, err := bytesutil.Uint256ToSSZBytes(e.BaseFeePerGas)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BaseFeePerGas")
+	}
+	payloadBlockHash, err := bytesutil.DecodeHexWithLength(e.BlockHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlockHash")
+	}
+	err = slice.VerifyMaxLength(e.Transactions, fieldparams.MaxTxsPerPayloadLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Transactions")
+	}
+	txs := make([][]byte, len(e.Transactions))
+	for i, tx := range e.Transactions {
+		txs[i], err = bytesutil.DecodeHexWithMaxLength(tx, fieldparams.MaxBytesPerTxLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Transactions[%d]", i))
+		}
+	}
+	err = slice.VerifyMaxLength(e.Withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.Withdrawals")
+	}
+	withdrawals := make([]*enginev1.Withdrawal, len(e.Withdrawals))
+	for i, w := range e.Withdrawals {
+		withdrawalIndex, err := strconv.ParseUint(w.WithdrawalIndex, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].WithdrawalIndex", i))
+		}
+		validatorIndex, err := strconv.ParseUint(w.ValidatorIndex, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].ValidatorIndex", i))
+		}
+		address, err := bytesutil.DecodeHexWithLength(w.ExecutionAddress, common.AddressLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].ExecutionAddress", i))
+		}
+		amount, err := strconv.ParseUint(w.Amount, 10, 64)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionPayload.Withdrawals[%d].Amount", i))
+		}
+		withdrawals[i] = &enginev1.Withdrawal{
+			Index:          withdrawalIndex,
+			ValidatorIndex: primitives.ValidatorIndex(validatorIndex),
+			Address:        address,
+			Amount:         amount,
+		}
+	}
+
+	payloadBlobGasUsed, err := strconv.ParseUint(e.BlobGasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlobGasUsed")
+	}
+	payloadExcessBlobGas, err := strconv.ParseUint(e.ExcessBlobGas, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ExcessBlobGas")
+	}
+	return &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    payloadParentHash,
+		FeeRecipient:  payloadFeeRecipient,
+		StateRoot:     payloadStateRoot,
+		ReceiptsRoot:  payloadReceiptsRoot,
+		LogsBloom:     payloadLogsBloom,
+		PrevRandao:    payloadPrevRandao,
+		BlockNumber:   payloadBlockNumber,
+		GasLimit:      payloadGasLimit,
+		GasUsed:       payloadGasUsed,
+		Timestamp:     payloadTimestamp,
+		ExtraData:     payloadExtraData,
+		BaseFeePerGas: payloadBaseFeePerGas,
+		BlockHash:     payloadBlockHash,
+		Transactions:  txs,
+		Withdrawals:   withdrawals,
+		BlobGasUsed:   payloadBlobGasUsed,
+		ExcessBlobGas: payloadExcessBlobGas,
+	}, nil
+}
+
+func ExecutionPayloadHeaderDenebFromConsensus(payload *enginev1.ExecutionPayloadHeaderDeneb) (*ExecutionPayloadHeaderDeneb, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ExecutionPayloadHeaderDeneb{
+		ParentHash:       hexutil.Encode(payload.ParentHash),
+		FeeRecipient:     hexutil.Encode(payload.FeeRecipient),
+		StateRoot:        hexutil.Encode(payload.StateRoot),
+		ReceiptsRoot:     hexutil.Encode(payload.ReceiptsRoot),
+		LogsBloom:        hexutil.Encode(payload.LogsBloom),
+		PrevRandao:       hexutil.Encode(payload.PrevRandao),
+		BlockNumber:      fmt.Sprintf("%d", payload.BlockNumber),
+		GasLimit:         fmt.Sprintf("%d", payload.GasLimit),
+		GasUsed:          fmt.Sprintf("%d", payload.GasUsed),
+		Timestamp:        fmt.Sprintf("%d", payload.Timestamp),
+		ExtraData:        hexutil.Encode(payload.ExtraData),
+		BaseFeePerGas:    baseFeePerGas,
+		BlockHash:        hexutil.Encode(payload.BlockHash),
+		TransactionsRoot: hexutil.Encode(payload.TransactionsRoot),
+		WithdrawalsRoot:  hexutil.Encode(payload.WithdrawalsRoot),
+		BlobGasUsed:      fmt.Sprintf("%d", payload.BlobGasUsed),
+		ExcessBlobGas:    fmt.Sprintf("%d", payload.ExcessBlobGas),
+	}, nil
+}
+
+func (e *ExecutionPayloadHeaderDeneb) ToConsensus() (*enginev1.ExecutionPayloadHeaderDeneb, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionPayloadHeader")
+	}
+	payloadParentHash, err := bytesutil.DecodeHexWithLength(e.ParentHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ParentHash")
+	}
+	payloadFeeRecipient, err := bytesutil.DecodeHexWithLength(e.FeeRecipient, fieldparams.FeeRecipientLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.FeeRecipient")
+	}
+	payloadStateRoot, err := bytesutil.DecodeHexWithLength(e.StateRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.StateRoot")
+	}
+	payloadReceiptsRoot, err := bytesutil.DecodeHexWithLength(e.ReceiptsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ReceiptsRoot")
+	}
+	payloadLogsBloom, err := bytesutil.DecodeHexWithLength(e.LogsBloom, fieldparams.LogsBloomLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.LogsBloom")
+	}
+	payloadPrevRandao, err := bytesutil.DecodeHexWithLength(e.PrevRandao, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.PrevRandao")
+	}
+	payloadBlockNumber, err := strconv.ParseUint(e.BlockNumber, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BlockNumber")
+	}
+	payloadGasLimit, err := strconv.ParseUint(e.GasLimit, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.GasLimit")
+	}
+	payloadGasUsed, err := strconv.ParseUint(e.GasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.GasUsed")
+	}
+	payloadTimestamp, err := strconv.ParseUint(e.Timestamp, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.Timestamp")
+	}
+	payloadExtraData, err := bytesutil.DecodeHexWithMaxLength(e.ExtraData, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.ExtraData")
+	}
+	payloadBaseFeePerGas, err := bytesutil.Uint256ToSSZBytes(e.BaseFeePerGas)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BaseFeePerGas")
+	}
+	payloadBlockHash, err := bytesutil.DecodeHexWithLength(e.BlockHash, common.HashLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.BlockHash")
+	}
+	payloadTxsRoot, err := bytesutil.DecodeHexWithLength(e.TransactionsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.TransactionsRoot")
+	}
+	payloadWithdrawalsRoot, err := bytesutil.DecodeHexWithLength(e.WithdrawalsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayloadHeader.WithdrawalsRoot")
+	}
+	payloadBlobGasUsed, err := strconv.ParseUint(e.BlobGasUsed, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.BlobGasUsed")
+	}
+	payloadExcessBlobGas, err := strconv.ParseUint(e.ExcessBlobGas, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ExecutionPayload.ExcessBlobGas")
+	}
+	return &enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payloadParentHash,
+		FeeRecipient:     payloadFeeRecipient,
+		StateRoot:        payloadStateRoot,
+		ReceiptsRoot:     payloadReceiptsRoot,
+		LogsBloom:        payloadLogsBloom,
+		PrevRandao:       payloadPrevRandao,
+		BlockNumber:      payloadBlockNumber,
+		GasLimit:         payloadGasLimit,
+		GasUsed:          payloadGasUsed,
+		Timestamp:        payloadTimestamp,
+		ExtraData:        payloadExtraData,
+		BaseFeePerGas:    payloadBaseFeePerGas,
+		BlockHash:        payloadBlockHash,
+		TransactionsRoot: payloadTxsRoot,
+		WithdrawalsRoot:  payloadWithdrawalsRoot,
+		BlobGasUsed:      payloadBlobGasUsed,
+		ExcessBlobGas:    payloadExcessBlobGas,
+	}, nil
+}
+
+// ----------------------------------------------------------------------------
+// Electra
+// ----------------------------------------------------------------------------
+
+var (
+	ExecutionPayloadElectraFromConsensus       = ExecutionPayloadDenebFromConsensus
+	ExecutionPayloadHeaderElectraFromConsensus = ExecutionPayloadHeaderDenebFromConsensus
+)
+
+func WithdrawalRequestsFromConsensus(ws []*enginev1.WithdrawalRequest) []*WithdrawalRequest {
+	result := make([]*WithdrawalRequest, len(ws))
+	for i, w := range ws {
+		result[i] = WithdrawalRequestFromConsensus(w)
+	}
+	return result
+}
+
+func WithdrawalRequestFromConsensus(w *enginev1.WithdrawalRequest) *WithdrawalRequest {
+	return &WithdrawalRequest{
+		SourceAddress:   hexutil.Encode(w.SourceAddress),
+		ValidatorPubkey: hexutil.Encode(w.ValidatorPubkey),
+		Amount:          fmt.Sprintf("%d", w.Amount),
+	}
+}
+
+func (w *WithdrawalRequest) ToConsensus() (*enginev1.WithdrawalRequest, error) {
+	if w == nil {
+		return nil, server.NewDecodeError(errNilValue, "WithdrawalRequest")
+	}
+	src, err := bytesutil.DecodeHexWithLength(w.SourceAddress, common.AddressLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SourceAddress")
+	}
+	pubkey, err := bytesutil.DecodeHexWithLength(w.ValidatorPubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ValidatorPubkey")
+	}
+	amount, err := strconv.ParseUint(w.Amount, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Amount")
+	}
+	return &enginev1.WithdrawalRequest{
+		SourceAddress:   src,
+		ValidatorPubkey: pubkey,
+		Amount:          amount,
+	}, nil
+}
+
+func ConsolidationRequestsFromConsensus(cs []*enginev1.ConsolidationRequest) []*ConsolidationRequest {
+	result := make([]*ConsolidationRequest, len(cs))
+	for i, c := range cs {
+		result[i] = ConsolidationRequestFromConsensus(c)
+	}
+	return result
+}
+
+func ConsolidationRequestFromConsensus(c *enginev1.ConsolidationRequest) *ConsolidationRequest {
+	return &ConsolidationRequest{
+		SourceAddress: hexutil.Encode(c.SourceAddress),
+		SourcePubkey:  hexutil.Encode(c.SourcePubkey),
+		TargetPubkey:  hexutil.Encode(c.TargetPubkey),
+	}
+}
+
+func (c *ConsolidationRequest) ToConsensus() (*enginev1.ConsolidationRequest, error) {
+	if c == nil {
+		return nil, server.NewDecodeError(errNilValue, "ConsolidationRequest")
+	}
+	srcAddress, err := bytesutil.DecodeHexWithLength(c.SourceAddress, common.AddressLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SourceAddress")
+	}
+	srcPubkey, err := bytesutil.DecodeHexWithLength(c.SourcePubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SourcePubkey")
+	}
+	targetPubkey, err := bytesutil.DecodeHexWithLength(c.TargetPubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "TargetPubkey")
+	}
+	return &enginev1.ConsolidationRequest{
+		SourceAddress: srcAddress,
+		SourcePubkey:  srcPubkey,
+		TargetPubkey:  targetPubkey,
+	}, nil
+}
+
+func DepositRequestsFromConsensus(ds []*enginev1.DepositRequest) []*DepositRequest {
+	result := make([]*DepositRequest, len(ds))
+	for i, d := range ds {
+		result[i] = DepositRequestFromConsensus(d)
+	}
+	return result
+}
+
+func DepositRequestFromConsensus(d *enginev1.DepositRequest) *DepositRequest {
+	return &DepositRequest{
+		Pubkey:                hexutil.Encode(d.Pubkey),
+		WithdrawalCredentials: hexutil.Encode(d.WithdrawalCredentials),
+		Amount:                fmt.Sprintf("%d", d.Amount),
+		Signature:             hexutil.Encode(d.Signature),
+		Index:                 fmt.Sprintf("%d", d.Index),
+	}
+}
+
+func (d *DepositRequest) ToConsensus() (*enginev1.DepositRequest, error) {
+	if d == nil {
+		return nil, server.NewDecodeError(errNilValue, "DepositRequest")
+	}
+	pubkey, err := bytesutil.DecodeHexWithLength(d.Pubkey, fieldparams.BLSPubkeyLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Pubkey")
+	}
+	withdrawalCredentials, err := bytesutil.DecodeHexWithLength(d.WithdrawalCredentials, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "WithdrawalCredentials")
+	}
+	amount, err := strconv.ParseUint(d.Amount, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Amount")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(d.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+	index, err := strconv.ParseUint(d.Index, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Index")
+	}
+	return &enginev1.DepositRequest{
+		Pubkey:                pubkey,
+		WithdrawalCredentials: withdrawalCredentials,
+		Amount:                amount,
+		Signature:             sig,
+		Index:                 index,
+	}, nil
+}
+
+func ExecutionRequestsFromConsensus(er *enginev1.ExecutionRequests) *ExecutionRequests {
+	return &ExecutionRequests{
+		Deposits:       DepositRequestsFromConsensus(er.Deposits),
+		Withdrawals:    WithdrawalRequestsFromConsensus(er.Withdrawals),
+		Consolidations: ConsolidationRequestsFromConsensus(er.Consolidations),
+	}
+}
+
+func (e *ExecutionRequests) ToConsensus() (*enginev1.ExecutionRequests, error) {
+	if e == nil {
+		return nil, server.NewDecodeError(errNilValue, "ExecutionRequests")
+	}
+	var err error
+	if err = slice.VerifyMaxLength(e.Deposits, params.BeaconConfig().MaxDepositRequestsPerPayload); err != nil {
+		return nil, err
+	}
+	depositRequests := make([]*enginev1.DepositRequest, len(e.Deposits))
+	for i, d := range e.Deposits {
+		depositRequests[i], err = d.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionRequests.Deposits[%d]", i))
+		}
+	}
+
+	if err = slice.VerifyMaxLength(e.Withdrawals, params.BeaconConfig().MaxWithdrawalRequestsPerPayload); err != nil {
+		return nil, err
+	}
+	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(e.Withdrawals))
+	for i, w := range e.Withdrawals {
+		withdrawalRequests[i], err = w.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionRequests.Withdrawals[%d]", i))
+		}
+	}
+
+	if err = slice.VerifyMaxLength(e.Consolidations, params.BeaconConfig().MaxConsolidationsRequestsPerPayload); err != nil {
+		return nil, err
+	}
+	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(e.Consolidations))
+	for i, c := range e.Consolidations {
+		consolidationRequests[i], err = c.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("ExecutionRequests.Consolidations[%d]", i))
+		}
+	}
+	return &enginev1.ExecutionRequests{
+		Deposits:       depositRequests,
+		Withdrawals:    withdrawalRequests,
+		Consolidations: consolidationRequests,
+	}, nil
+}
+
+// ----------------------------------------------------------------------------
+// Fulu
+// ----------------------------------------------------------------------------
+
+var (
+	ExecutionPayloadFuluFromConsensus       = ExecutionPayloadDenebFromConsensus
+	ExecutionPayloadHeaderFuluFromConsensus = ExecutionPayloadHeaderDenebFromConsensus
+	BeaconBlockFuluFromConsensus            = BeaconBlockElectraFromConsensus
+)
--- a/api/server/structs/conversions_block_execution_test.go
+++ b/api/server/structs/conversions_block_execution_test.go
@@ -0,0 +1,563 @@
+package structs
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func fillByteSlice(sliceLength int, value byte) []byte {
+	bytes := make([]byte, sliceLength)
+
+	for index := range bytes {
+		bytes[index] = value
+	}
+
+	return bytes
+}
+
+// TestExecutionPayloadFromConsensus_HappyPath checks the
+// ExecutionPayloadFromConsensus function under normal conditions.
+func TestExecutionPayloadFromConsensus_HappyPath(t *testing.T) {
+	consensusPayload := &enginev1.ExecutionPayload{
+		ParentHash:    fillByteSlice(common.HashLength, 0xaa),
+		FeeRecipient:  fillByteSlice(20, 0xbb),
+		StateRoot:     fillByteSlice(32, 0xcc),
+		ReceiptsRoot:  fillByteSlice(32, 0xdd),
+		LogsBloom:     fillByteSlice(256, 0xee),
+		PrevRandao:    fillByteSlice(32, 0xff),
+		BlockNumber:   12345,
+		GasLimit:      15000000,
+		GasUsed:       8000000,
+		Timestamp:     1680000000,
+		ExtraData:     fillByteSlice(8, 0x11),
+		BaseFeePerGas: fillByteSlice(32, 0x01),
+		BlockHash:     fillByteSlice(common.HashLength, 0x22),
+		Transactions: [][]byte{
+			fillByteSlice(10, 0x33),
+			fillByteSlice(10, 0x44),
+		},
+	}
+
+	result, err := ExecutionPayloadFromConsensus(consensusPayload)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Equal(t, hexutil.Encode(consensusPayload.ParentHash), result.ParentHash)
+	require.Equal(t, hexutil.Encode(consensusPayload.FeeRecipient), result.FeeRecipient)
+	require.Equal(t, hexutil.Encode(consensusPayload.StateRoot), result.StateRoot)
+	require.Equal(t, hexutil.Encode(consensusPayload.ReceiptsRoot), result.ReceiptsRoot)
+	require.Equal(t, fmt.Sprintf("%d", consensusPayload.BlockNumber), result.BlockNumber)
+}
+
+// TestExecutionPayload_ToConsensus_HappyPath checks the
+// (*ExecutionPayload).ToConsensus function under normal conditions.
+func TestExecutionPayload_ToConsensus_HappyPath(t *testing.T) {
+	payload := &ExecutionPayload{
+		ParentHash:    hexutil.Encode(fillByteSlice(common.HashLength, 0xaa)),
+		FeeRecipient:  hexutil.Encode(fillByteSlice(20, 0xbb)),
+		StateRoot:     hexutil.Encode(fillByteSlice(32, 0xcc)),
+		ReceiptsRoot:  hexutil.Encode(fillByteSlice(32, 0xdd)),
+		LogsBloom:     hexutil.Encode(fillByteSlice(256, 0xee)),
+		PrevRandao:    hexutil.Encode(fillByteSlice(32, 0xff)),
+		BlockNumber:   "12345",
+		GasLimit:      "15000000",
+		GasUsed:       "8000000",
+		Timestamp:     "1680000000",
+		ExtraData:     "0x11111111",
+		BaseFeePerGas: "1234",
+		BlockHash:     hexutil.Encode(fillByteSlice(common.HashLength, 0x22)),
+		Transactions: []string{
+			hexutil.Encode(fillByteSlice(10, 0x33)),
+			hexutil.Encode(fillByteSlice(10, 0x44)),
+		},
+	}
+
+	result, err := payload.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, result.ParentHash, fillByteSlice(common.HashLength, 0xaa))
+	require.DeepEqual(t, result.FeeRecipient, fillByteSlice(20, 0xbb))
+	require.DeepEqual(t, result.StateRoot, fillByteSlice(32, 0xcc))
+}
+
+// TestExecutionPayloadHeaderFromConsensus_HappyPath checks the
+// ExecutionPayloadHeaderFromConsensus function under normal conditions.
+func TestExecutionPayloadHeaderFromConsensus_HappyPath(t *testing.T) {
+	consensusHeader := &enginev1.ExecutionPayloadHeader{
+		ParentHash:       fillByteSlice(common.HashLength, 0xaa),
+		FeeRecipient:     fillByteSlice(20, 0xbb),
+		StateRoot:        fillByteSlice(32, 0xcc),
+		ReceiptsRoot:     fillByteSlice(32, 0xdd),
+		LogsBloom:        fillByteSlice(256, 0xee),
+		PrevRandao:       fillByteSlice(32, 0xff),
+		BlockNumber:      9999,
+		GasLimit:         5000000,
+		GasUsed:          2500000,
+		Timestamp:        1111111111,
+		ExtraData:        fillByteSlice(4, 0x12),
+		BaseFeePerGas:    fillByteSlice(32, 0x34),
+		BlockHash:        fillByteSlice(common.HashLength, 0x56),
+		TransactionsRoot: fillByteSlice(32, 0x78),
+	}
+
+	result, err := ExecutionPayloadHeaderFromConsensus(consensusHeader)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Equal(t, hexutil.Encode(consensusHeader.ParentHash), result.ParentHash)
+	require.Equal(t, fmt.Sprintf("%d", consensusHeader.BlockNumber), result.BlockNumber)
+}
+
+// TestExecutionPayloadHeader_ToConsensus_HappyPath checks the
+// (*ExecutionPayloadHeader).ToConsensus function under normal conditions.
+func TestExecutionPayloadHeader_ToConsensus_HappyPath(t *testing.T) {
+	header := &ExecutionPayloadHeader{
+		ParentHash:       hexutil.Encode(fillByteSlice(common.HashLength, 0xaa)),
+		FeeRecipient:     hexutil.Encode(fillByteSlice(20, 0xbb)),
+		StateRoot:        hexutil.Encode(fillByteSlice(32, 0xcc)),
+		ReceiptsRoot:     hexutil.Encode(fillByteSlice(32, 0xdd)),
+		LogsBloom:        hexutil.Encode(fillByteSlice(256, 0xee)),
+		PrevRandao:       hexutil.Encode(fillByteSlice(32, 0xff)),
+		BlockNumber:      "9999",
+		GasLimit:         "5000000",
+		GasUsed:          "2500000",
+		Timestamp:        "1111111111",
+		ExtraData:        "0x1234abcd",
+		BaseFeePerGas:    "1234",
+		BlockHash:        hexutil.Encode(fillByteSlice(common.HashLength, 0x56)),
+		TransactionsRoot: hexutil.Encode(fillByteSlice(32, 0x78)),
+	}
+
+	result, err := header.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, hexutil.Encode(result.ParentHash), header.ParentHash)
+	require.DeepEqual(t, hexutil.Encode(result.FeeRecipient), header.FeeRecipient)
+	require.DeepEqual(t, hexutil.Encode(result.StateRoot), header.StateRoot)
+}
+
+// TestExecutionPayloadCapellaFromConsensus_HappyPath checks the
+// ExecutionPayloadCapellaFromConsensus function under normal conditions.
+func TestExecutionPayloadCapellaFromConsensus_HappyPath(t *testing.T) {
+	capellaPayload := &enginev1.ExecutionPayloadCapella{
+		ParentHash:    fillByteSlice(common.HashLength, 0xaa),
+		FeeRecipient:  fillByteSlice(20, 0xbb),
+		StateRoot:     fillByteSlice(32, 0xcc),
+		ReceiptsRoot:  fillByteSlice(32, 0xdd),
+		LogsBloom:     fillByteSlice(256, 0xee),
+		PrevRandao:    fillByteSlice(32, 0xff),
+		BlockNumber:   123,
+		GasLimit:      9876543,
+		GasUsed:       1234567,
+		Timestamp:     5555555,
+		ExtraData:     fillByteSlice(6, 0x11),
+		BaseFeePerGas: fillByteSlice(32, 0x22),
+		BlockHash:     fillByteSlice(common.HashLength, 0x33),
+		Transactions: [][]byte{
+			fillByteSlice(5, 0x44),
+		},
+		Withdrawals: []*enginev1.Withdrawal{
+			{
+				Index:          1,
+				ValidatorIndex: 2,
+				Address:        fillByteSlice(20, 0xaa),
+				Amount:         100,
+			},
+		},
+	}
+
+	result, err := ExecutionPayloadCapellaFromConsensus(capellaPayload)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Equal(t, hexutil.Encode(capellaPayload.ParentHash), result.ParentHash)
+	require.Equal(t, len(capellaPayload.Transactions), len(result.Transactions))
+	require.Equal(t, len(capellaPayload.Withdrawals), len(result.Withdrawals))
+}
+
+// TestExecutionPayloadCapella_ToConsensus_HappyPath checks the
+// (*ExecutionPayloadCapella).ToConsensus function under normal conditions.
+func TestExecutionPayloadCapella_ToConsensus_HappyPath(t *testing.T) {
+	capella := &ExecutionPayloadCapella{
+		ParentHash:    hexutil.Encode(fillByteSlice(common.HashLength, 0xaa)),
+		FeeRecipient:  hexutil.Encode(fillByteSlice(20, 0xbb)),
+		StateRoot:     hexutil.Encode(fillByteSlice(32, 0xcc)),
+		ReceiptsRoot:  hexutil.Encode(fillByteSlice(32, 0xdd)),
+		LogsBloom:     hexutil.Encode(fillByteSlice(256, 0xee)),
+		PrevRandao:    hexutil.Encode(fillByteSlice(32, 0xff)),
+		BlockNumber:   "123",
+		GasLimit:      "9876543",
+		GasUsed:       "1234567",
+		Timestamp:     "5555555",
+		ExtraData:     hexutil.Encode(fillByteSlice(6, 0x11)),
+		BaseFeePerGas: "1234",
+		BlockHash:     hexutil.Encode(fillByteSlice(common.HashLength, 0x33)),
+		Transactions: []string{
+			hexutil.Encode(fillByteSlice(5, 0x44)),
+		},
+		Withdrawals: []*Withdrawal{
+			{
+				WithdrawalIndex:  "1",
+				ValidatorIndex:   "2",
+				ExecutionAddress: hexutil.Encode(fillByteSlice(20, 0xaa)),
+				Amount:           "100",
+			},
+		},
+	}
+
+	result, err := capella.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, hexutil.Encode(result.ParentHash), capella.ParentHash)
+	require.DeepEqual(t, hexutil.Encode(result.FeeRecipient), capella.FeeRecipient)
+	require.DeepEqual(t, hexutil.Encode(result.StateRoot), capella.StateRoot)
+}
+
+// TestExecutionPayloadDenebFromConsensus_HappyPath checks the
+// ExecutionPayloadDenebFromConsensus function under normal conditions.
+func TestExecutionPayloadDenebFromConsensus_HappyPath(t *testing.T) {
+	denebPayload := &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    fillByteSlice(common.HashLength, 0xaa),
+		FeeRecipient:  fillByteSlice(20, 0xbb),
+		StateRoot:     fillByteSlice(32, 0xcc),
+		ReceiptsRoot:  fillByteSlice(32, 0xdd),
+		LogsBloom:     fillByteSlice(256, 0xee),
+		PrevRandao:    fillByteSlice(32, 0xff),
+		BlockNumber:   999,
+		GasLimit:      2222222,
+		GasUsed:       1111111,
+		Timestamp:     666666,
+		ExtraData:     fillByteSlice(6, 0x11),
+		BaseFeePerGas: fillByteSlice(32, 0x22),
+		BlockHash:     fillByteSlice(common.HashLength, 0x33),
+		Transactions: [][]byte{
+			fillByteSlice(5, 0x44),
+		},
+		Withdrawals: []*enginev1.Withdrawal{
+			{
+				Index:          1,
+				ValidatorIndex: 2,
+				Address:        fillByteSlice(20, 0xaa),
+				Amount:         100,
+			},
+		},
+		BlobGasUsed:   1234,
+		ExcessBlobGas: 5678,
+	}
+
+	result, err := ExecutionPayloadDenebFromConsensus(denebPayload)
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(denebPayload.ParentHash), result.ParentHash)
+	require.Equal(t, len(denebPayload.Transactions), len(result.Transactions))
+	require.Equal(t, len(denebPayload.Withdrawals), len(result.Withdrawals))
+	require.Equal(t, "1234", result.BlobGasUsed)
+	require.Equal(t, fmt.Sprintf("%d", denebPayload.BlockNumber), result.BlockNumber)
+}
+
+// TestExecutionPayloadDeneb_ToConsensus_HappyPath checks the
+// (*ExecutionPayloadDeneb).ToConsensus function under normal conditions.
+func TestExecutionPayloadDeneb_ToConsensus_HappyPath(t *testing.T) {
+	deneb := &ExecutionPayloadDeneb{
+		ParentHash:    hexutil.Encode(fillByteSlice(common.HashLength, 0xaa)),
+		FeeRecipient:  hexutil.Encode(fillByteSlice(20, 0xbb)),
+		StateRoot:     hexutil.Encode(fillByteSlice(32, 0xcc)),
+		ReceiptsRoot:  hexutil.Encode(fillByteSlice(32, 0xdd)),
+		LogsBloom:     hexutil.Encode(fillByteSlice(256, 0xee)),
+		PrevRandao:    hexutil.Encode(fillByteSlice(32, 0xff)),
+		BlockNumber:   "999",
+		GasLimit:      "2222222",
+		GasUsed:       "1111111",
+		Timestamp:     "666666",
+		ExtraData:     hexutil.Encode(fillByteSlice(6, 0x11)),
+		BaseFeePerGas: "1234",
+		BlockHash:     hexutil.Encode(fillByteSlice(common.HashLength, 0x33)),
+		Transactions: []string{
+			hexutil.Encode(fillByteSlice(5, 0x44)),
+		},
+		Withdrawals: []*Withdrawal{
+			{
+				WithdrawalIndex:  "1",
+				ValidatorIndex:   "2",
+				ExecutionAddress: hexutil.Encode(fillByteSlice(20, 0xaa)),
+				Amount:           "100",
+			},
+		},
+		BlobGasUsed:   "1234",
+		ExcessBlobGas: "5678",
+	}
+
+	result, err := deneb.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, hexutil.Encode(result.ParentHash), deneb.ParentHash)
+	require.DeepEqual(t, hexutil.Encode(result.FeeRecipient), deneb.FeeRecipient)
+	require.Equal(t, result.BlockNumber, uint64(999))
+}
+
+func TestExecutionPayloadHeaderCapellaFromConsensus_HappyPath(t *testing.T) {
+	capellaHeader := &enginev1.ExecutionPayloadHeaderCapella{
+		ParentHash:       fillByteSlice(common.HashLength, 0xaa),
+		FeeRecipient:     fillByteSlice(20, 0xbb),
+		StateRoot:        fillByteSlice(32, 0xcc),
+		ReceiptsRoot:     fillByteSlice(32, 0xdd),
+		LogsBloom:        fillByteSlice(256, 0xee),
+		PrevRandao:       fillByteSlice(32, 0xff),
+		BlockNumber:      555,
+		GasLimit:         1111111,
+		GasUsed:          222222,
+		Timestamp:        3333333333,
+		ExtraData:        fillByteSlice(4, 0x12),
+		BaseFeePerGas:    fillByteSlice(32, 0x34),
+		BlockHash:        fillByteSlice(common.HashLength, 0x56),
+		TransactionsRoot: fillByteSlice(32, 0x78),
+		WithdrawalsRoot:  fillByteSlice(32, 0x99),
+	}
+
+	result, err := ExecutionPayloadHeaderCapellaFromConsensus(capellaHeader)
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(capellaHeader.ParentHash), result.ParentHash)
+	require.DeepEqual(t, hexutil.Encode(capellaHeader.WithdrawalsRoot), result.WithdrawalsRoot)
+}
+
+func TestExecutionPayloadHeaderCapella_ToConsensus_HappyPath(t *testing.T) {
+	header := &ExecutionPayloadHeaderCapella{
+		ParentHash:       hexutil.Encode(fillByteSlice(common.HashLength, 0xaa)),
+		FeeRecipient:     hexutil.Encode(fillByteSlice(20, 0xbb)),
+		StateRoot:        hexutil.Encode(fillByteSlice(32, 0xcc)),
+		ReceiptsRoot:     hexutil.Encode(fillByteSlice(32, 0xdd)),
+		LogsBloom:        hexutil.Encode(fillByteSlice(256, 0xee)),
+		PrevRandao:       hexutil.Encode(fillByteSlice(32, 0xff)),
+		BlockNumber:      "555",
+		GasLimit:         "1111111",
+		GasUsed:          "222222",
+		Timestamp:        "3333333333",
+		ExtraData:        "0x1234abcd",
+		BaseFeePerGas:    "1234",
+		BlockHash:        hexutil.Encode(fillByteSlice(common.HashLength, 0x56)),
+		TransactionsRoot: hexutil.Encode(fillByteSlice(32, 0x78)),
+		WithdrawalsRoot:  hexutil.Encode(fillByteSlice(32, 0x99)),
+	}
+
+	result, err := header.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, hexutil.Encode(result.ParentHash), header.ParentHash)
+	require.DeepEqual(t, hexutil.Encode(result.FeeRecipient), header.FeeRecipient)
+	require.DeepEqual(t, hexutil.Encode(result.StateRoot), header.StateRoot)
+	require.DeepEqual(t, hexutil.Encode(result.ReceiptsRoot), header.ReceiptsRoot)
+	require.DeepEqual(t, hexutil.Encode(result.WithdrawalsRoot), header.WithdrawalsRoot)
+}
+
+func TestExecutionPayloadHeaderDenebFromConsensus_HappyPath(t *testing.T) {
+	denebHeader := &enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       fillByteSlice(common.HashLength, 0xaa),
+		FeeRecipient:     fillByteSlice(20, 0xbb),
+		StateRoot:        fillByteSlice(32, 0xcc),
+		ReceiptsRoot:     fillByteSlice(32, 0xdd),
+		LogsBloom:        fillByteSlice(256, 0xee),
+		PrevRandao:       fillByteSlice(32, 0xff),
+		BlockNumber:      999,
+		GasLimit:         5000000,
+		GasUsed:          2500000,
+		Timestamp:        4444444444,
+		ExtraData:        fillByteSlice(4, 0x12),
+		BaseFeePerGas:    fillByteSlice(32, 0x34),
+		BlockHash:        fillByteSlice(common.HashLength, 0x56),
+		TransactionsRoot: fillByteSlice(32, 0x78),
+		WithdrawalsRoot:  fillByteSlice(32, 0x99),
+		BlobGasUsed:      1234,
+		ExcessBlobGas:    5678,
+	}
+
+	result, err := ExecutionPayloadHeaderDenebFromConsensus(denebHeader)
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(denebHeader.ParentHash), result.ParentHash)
+	require.DeepEqual(t, hexutil.Encode(denebHeader.FeeRecipient), result.FeeRecipient)
+	require.DeepEqual(t, hexutil.Encode(denebHeader.StateRoot), result.StateRoot)
+	require.DeepEqual(t, fmt.Sprintf("%d", denebHeader.BlobGasUsed), result.BlobGasUsed)
+}
+
+func TestExecutionPayloadHeaderDeneb_ToConsensus_HappyPath(t *testing.T) {
+	header := &ExecutionPayloadHeaderDeneb{
+		ParentHash:       hexutil.Encode(fillByteSlice(common.HashLength, 0xaa)),
+		FeeRecipient:     hexutil.Encode(fillByteSlice(20, 0xbb)),
+		StateRoot:        hexutil.Encode(fillByteSlice(32, 0xcc)),
+		ReceiptsRoot:     hexutil.Encode(fillByteSlice(32, 0xdd)),
+		LogsBloom:        hexutil.Encode(fillByteSlice(256, 0xee)),
+		PrevRandao:       hexutil.Encode(fillByteSlice(32, 0xff)),
+		BlockNumber:      "999",
+		GasLimit:         "5000000",
+		GasUsed:          "2500000",
+		Timestamp:        "4444444444",
+		ExtraData:        "0x1234abcd",
+		BaseFeePerGas:    "1234",
+		BlockHash:        hexutil.Encode(fillByteSlice(common.HashLength, 0x56)),
+		TransactionsRoot: hexutil.Encode(fillByteSlice(32, 0x78)),
+		WithdrawalsRoot:  hexutil.Encode(fillByteSlice(32, 0x99)),
+		BlobGasUsed:      "1234",
+		ExcessBlobGas:    "5678",
+	}
+
+	result, err := header.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, hexutil.Encode(result.ParentHash), header.ParentHash)
+	require.DeepEqual(t, result.BlobGasUsed, uint64(1234))
+	require.DeepEqual(t, result.ExcessBlobGas, uint64(5678))
+	require.DeepEqual(t, result.BlockNumber, uint64(999))
+}
+
+func TestWithdrawalRequestsFromConsensus_HappyPath(t *testing.T) {
+	consensusRequests := []*enginev1.WithdrawalRequest{
+		{
+			SourceAddress:   fillByteSlice(20, 0xbb),
+			ValidatorPubkey: fillByteSlice(48, 0xbb),
+			Amount:          12345,
+		},
+		{
+			SourceAddress:   fillByteSlice(20, 0xcc),
+			ValidatorPubkey: fillByteSlice(48, 0xcc),
+			Amount:          54321,
+		},
+	}
+
+	result := WithdrawalRequestsFromConsensus(consensusRequests)
+	require.DeepEqual(t, len(result), len(consensusRequests))
+	require.DeepEqual(t, result[0].Amount, fmt.Sprintf("%d", consensusRequests[0].Amount))
+}
+
+func TestWithdrawalRequestFromConsensus_HappyPath(t *testing.T) {
+	req := &enginev1.WithdrawalRequest{
+		SourceAddress:   fillByteSlice(20, 0xbb),
+		ValidatorPubkey: fillByteSlice(48, 0xbb),
+		Amount:          42,
+	}
+	result := WithdrawalRequestFromConsensus(req)
+	require.NotNil(t, result)
+	require.DeepEqual(t, result.SourceAddress, hexutil.Encode(fillByteSlice(20, 0xbb)))
+}
+
+func TestWithdrawalRequest_ToConsensus_HappyPath(t *testing.T) {
+	withdrawalReq := &WithdrawalRequest{
+		SourceAddress:   hexutil.Encode(fillByteSlice(20, 111)),
+		ValidatorPubkey: hexutil.Encode(fillByteSlice(48, 123)),
+		Amount:          "12345",
+	}
+	result, err := withdrawalReq.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, result.Amount, uint64(12345))
+}
+
+func TestConsolidationRequestsFromConsensus_HappyPath(t *testing.T) {
+	consensusRequests := []*enginev1.ConsolidationRequest{
+		{
+			SourceAddress: fillByteSlice(20, 111),
+			SourcePubkey:  fillByteSlice(48, 112),
+			TargetPubkey:  fillByteSlice(48, 113),
+		},
+	}
+	result := ConsolidationRequestsFromConsensus(consensusRequests)
+	require.DeepEqual(t, len(result), len(consensusRequests))
+	require.DeepEqual(t, result[0].SourceAddress, "0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f")
+}
+
+func TestDepositRequestsFromConsensus_HappyPath(t *testing.T) {
+	ds := []*enginev1.DepositRequest{
+		{
+			Pubkey:                fillByteSlice(48, 0xbb),
+			WithdrawalCredentials: fillByteSlice(32, 0xdd),
+			Amount:                98765,
+			Signature:             fillByteSlice(96, 0xff),
+			Index:                 111,
+		},
+	}
+	result := DepositRequestsFromConsensus(ds)
+	require.DeepEqual(t, len(result), len(ds))
+	require.DeepEqual(t, result[0].Amount, "98765")
+}
+
+func TestDepositRequest_ToConsensus_HappyPath(t *testing.T) {
+	req := &DepositRequest{
+		Pubkey:                hexutil.Encode(fillByteSlice(48, 0xbb)),
+		WithdrawalCredentials: hexutil.Encode(fillByteSlice(32, 0xaa)),
+		Amount:                "123",
+		Signature:             hexutil.Encode(fillByteSlice(96, 0xdd)),
+		Index:                 "456",
+	}
+
+	result, err := req.ToConsensus()
+	require.NoError(t, err)
+	require.DeepEqual(t, result.Amount, uint64(123))
+	require.DeepEqual(t, result.Signature, fillByteSlice(96, 0xdd))
+}
+
+func TestExecutionRequestsFromConsensus_HappyPath(t *testing.T) {
+	er := &enginev1.ExecutionRequests{
+		Deposits: []*enginev1.DepositRequest{
+			{
+				Pubkey:                fillByteSlice(48, 0xba),
+				WithdrawalCredentials: fillByteSlice(32, 0xaa),
+				Amount:                33,
+				Signature:             fillByteSlice(96, 0xff),
+				Index:                 44,
+			},
+		},
+		Withdrawals: []*enginev1.WithdrawalRequest{
+			{
+				SourceAddress:   fillByteSlice(20, 0xaa),
+				ValidatorPubkey: fillByteSlice(48, 0xba),
+				Amount:          555,
+			},
+		},
+		Consolidations: []*enginev1.ConsolidationRequest{
+			{
+				SourceAddress: fillByteSlice(20, 0xdd),
+				SourcePubkey:  fillByteSlice(48, 0xdd),
+				TargetPubkey:  fillByteSlice(48, 0xcc),
+			},
+		},
+	}
+
+	result := ExecutionRequestsFromConsensus(er)
+	require.NotNil(t, result)
+	require.Equal(t, 1, len(result.Deposits))
+	require.Equal(t, "33", result.Deposits[0].Amount)
+	require.Equal(t, 1, len(result.Withdrawals))
+	require.Equal(t, "555", result.Withdrawals[0].Amount)
+	require.Equal(t, 1, len(result.Consolidations))
+	require.Equal(t, "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", result.Consolidations[0].TargetPubkey)
+}
+
+func TestExecutionRequests_ToConsensus_HappyPath(t *testing.T) {
+	execReq := &ExecutionRequests{
+		Deposits: []*DepositRequest{
+			{
+				Pubkey:                hexutil.Encode(fillByteSlice(48, 0xbb)),
+				WithdrawalCredentials: hexutil.Encode(fillByteSlice(32, 0xaa)),
+				Amount:                "33",
+				Signature:             hexutil.Encode(fillByteSlice(96, 0xff)),
+				Index:                 "44",
+			},
+		},
+		Withdrawals: []*WithdrawalRequest{
+			{
+				SourceAddress:   hexutil.Encode(fillByteSlice(20, 0xdd)),
+				ValidatorPubkey: hexutil.Encode(fillByteSlice(48, 0xbb)),
+				Amount:          "555",
+			},
+		},
+		Consolidations: []*ConsolidationRequest{
+			{
+				SourceAddress: hexutil.Encode(fillByteSlice(20, 0xcc)),
+				SourcePubkey:  hexutil.Encode(fillByteSlice(48, 0xbb)),
+				TargetPubkey:  hexutil.Encode(fillByteSlice(48, 0xcc)),
+			},
+		},
+	}
+
+	result, err := execReq.ToConsensus()
+	require.NoError(t, err)
+
+	require.Equal(t, 1, len(result.Deposits))
+	require.Equal(t, uint64(33), result.Deposits[0].Amount)
+	require.Equal(t, 1, len(result.Withdrawals))
+	require.Equal(t, uint64(555), result.Withdrawals[0].Amount)
+	require.Equal(t, 1, len(result.Consolidations))
+	require.DeepEqual(t, fillByteSlice(48, 0xcc), result.Consolidations[0].TargetPubkey)
+}
--- a/api/server/structs/endpoints_beacon.go
+++ b/api/server/structs/endpoints_beacon.go
@@ -250,3 +250,17 @@ type ChainHead struct {
 	PreviousJustifiedBlockRoot string `json:"previous_justified_block_root"`
 	OptimisticStatus           bool   `json:"optimistic_status"`
 }
+
+type GetPendingDepositsResponse struct {
+	Version             string            `json:"version"`
+	ExecutionOptimistic bool              `json:"execution_optimistic"`
+	Finalized           bool              `json:"finalized"`
+	Data                []*PendingDeposit `json:"data"`
+}
+
+type GetPendingPartialWithdrawalsResponse struct {
+	Version             string                      `json:"version"`
+	ExecutionOptimistic bool                        `json:"execution_optimistic"`
+	Finalized           bool                        `json:"finalized"`
+	Data                []*PendingPartialWithdrawal `json:"data"`
+}
--- a/api/server/structs/other.go
+++ b/api/server/structs/other.go
@@ -244,26 +244,6 @@ type Withdrawal struct {
 	Amount           string `json:"amount"`
 }

-type DepositRequest struct {
-	Pubkey                string `json:"pubkey"`
-	WithdrawalCredentials string `json:"withdrawal_credentials"`
-	Amount                string `json:"amount"`
-	Signature             string `json:"signature"`
-	Index                 string `json:"index"`
-}
-
-type WithdrawalRequest struct {
-	SourceAddress   string `json:"source_address"`
-	ValidatorPubkey string `json:"validator_pubkey"`
-	Amount          string `json:"amount"`
-}
-
-type ConsolidationRequest struct {
-	SourceAddress string `json:"source_address"`
-	SourcePubkey  string `json:"source_pubkey"`
-	TargetPubkey  string `json:"target_pubkey"`
-}
-
 type PendingDeposit struct {
 	Pubkey                string `json:"pubkey"`
 	WithdrawalCredentials string `json:"withdrawal_credentials"`
--- a/async/multilock.go
+++ b/async/multilock.go
@@ -125,7 +125,7 @@ func getChan(key string) chan byte {

 // Return a new string with unique elements.
 func unique(arr []string) []string {
-	if arr == nil || len(arr) <= 1 {
+	if len(arr) <= 1 {
 		return arr
 	}

--- a/beacon-chain/blockchain/BUILD.bazel
+++ b/beacon-chain/blockchain/BUILD.bazel
@@ -12,6 +12,7 @@ go_library(
        "forkchoice_update_execution.go",
        "head.go",
        "head_sync_committee_info.go",
+        "holeskyhack.go",
        "init_sync_process_block.go",
        "log.go",
        "merge_ascii_art.go",
--- a/beacon-chain/blockchain/holeskyhack.go
+++ b/beacon-chain/blockchain/holeskyhack.go
@@ -0,0 +1,21 @@
+package blockchain
+
+import (
+	"encoding/hex"
+
+	"github.com/pkg/errors"
+)
+
+var errHoleskyForbiddenRoot = errors.New("refusing to process forbidden holesky block")
+
+// hack to prevent bad holesky block importation
+var badHoleskyRoot [32]byte
+
+func init() {
+	hexStr := "2db899881ed8546476d0b92c6aa9110bea9a4cd0dbeb5519eb0ea69575f1f359"
+	bytes, err := hex.DecodeString(hexStr)
+	if err != nil {
+		panic(err)
+	}
+	badHoleskyRoot = [32]byte(bytes)
+}
--- a/beacon-chain/blockchain/log.go
+++ b/beacon-chain/blockchain/log.go
@@ -69,6 +69,22 @@ func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
 			log = log.WithField("kzgCommitmentCount", len(kzgs))
 		}
 	}
+	if b.Version() >= version.Electra {
+		eReqs, err := b.Body().ExecutionRequests()
+		if err != nil {
+			log.WithError(err).Error("Failed to get execution requests")
+		} else {
+			if len(eReqs.Deposits) > 0 {
+				log = log.WithField("depositRequestCount", len(eReqs.Deposits))
+			}
+			if len(eReqs.Consolidations) > 0 {
+				log = log.WithField("consolidationRequestCount", len(eReqs.Consolidations))
+			}
+			if len(eReqs.Withdrawals) > 0 {
+				log = log.WithField("withdrawalRequestCount", len(eReqs.Withdrawals))
+			}
+		}
+	}
 	log.Info("Finished applying state transition")
 	return nil
 }
--- a/beacon-chain/blockchain/process_block.go
+++ b/beacon-chain/blockchain/process_block.go
@@ -173,6 +173,9 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	var set *bls.SignatureBatch
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
+		if b.Root() == badHoleskyRoot {
+			return errHoleskyForbiddenRoot
+		}
 		v, h, err := getStateVersionAndPayload(preState)
 		if err != nil {
 			return err
--- a/beacon-chain/blockchain/receive_block.go
+++ b/beacon-chain/blockchain/receive_block.go
@@ -65,6 +65,11 @@ type SlashingReceiver interface {
 func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityStore) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
+
+	if blockRoot == badHoleskyRoot {
+		return errHoleskyForbiddenRoot
+	}
+
 	// Return early if the block has been synced
 	if s.InForkchoice(blockRoot) {
 		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring already synced block")
--- a/beacon-chain/cache/BUILD.bazel
+++ b/beacon-chain/cache/BUILD.bazel
@@ -84,6 +84,7 @@ go_test(
        "sync_committee_head_state_test.go",
        "sync_committee_test.go",
        "sync_subnet_ids_test.go",
+        "tracked_validators_test.go",
    ],
    embed = [":go_default_library"],
    deps = [
--- a/beacon-chain/cache/tracked_validators.go
+++ b/beacon-chain/cache/tracked_validators.go
@@ -1,49 +1,139 @@
 package cache

 import (
-	"sync"
+	"strconv"
+	"time"

+	"github.com/patrickmn/go-cache"
+	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/sirupsen/logrus"
 )

-type TrackedValidator struct {
-	Active       bool
-	FeeRecipient primitives.ExecutionAddress
-	Index        primitives.ValidatorIndex
-}
+const (
+	defaultExpiration = 1 * time.Hour
+	cleanupInterval   = 15 * time.Minute
+)

-type TrackedValidatorsCache struct {
-	sync.Mutex
-	trackedValidators map[primitives.ValidatorIndex]TrackedValidator
-}
+type (
+	TrackedValidator struct {
+		Active       bool
+		FeeRecipient primitives.ExecutionAddress
+		Index        primitives.ValidatorIndex
+	}

+	TrackedValidatorsCache struct {
+		trackedValidators cache.Cache
+	}
+)
+
+var (
+	// Metrics.
+	trackedValidatorsCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "tracked_validators_cache_miss",
+		Help: "The number of tracked validators requests that are not present in the cache.",
+	})
+
+	trackedValidatorsCacheTotal = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "tracked_validators_cache_total",
+		Help: "The total number of tracked validators requests in the cache.",
+	})
+
+	trackedValidatorsCacheCount = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "tracked_validators_cache_count",
+		Help: "The number of tracked validators in the cache.",
+	})
+)
+
+// NewTrackedValidatorsCache creates a new cache for tracking validators.
 func NewTrackedValidatorsCache() *TrackedValidatorsCache {
 	return &TrackedValidatorsCache{
-		trackedValidators: make(map[primitives.ValidatorIndex]TrackedValidator),
+		trackedValidators: *cache.New(defaultExpiration, cleanupInterval),
 	}
 }

+// Validator retrieves a tracked validator from the cache (if present).
 func (t *TrackedValidatorsCache) Validator(index primitives.ValidatorIndex) (TrackedValidator, bool) {
-	t.Lock()
-	defer t.Unlock()
-	val, ok := t.trackedValidators[index]
-	return val, ok
+	trackedValidatorsCacheTotal.Inc()
+
+	key := toCacheKey(index)
+	item, ok := t.trackedValidators.Get(key)
+	if !ok {
+		trackedValidatorsCacheMiss.Inc()
+		return TrackedValidator{}, false
+	}
+
+	val, ok := item.(TrackedValidator)
+	if !ok {
+		logrus.Errorf("Failed to cast tracked validator from cache, got unexpected item type %T", item)
+		return TrackedValidator{}, false
+	}
+
+	return val, true
 }

+// Set adds a tracked validator to the cache.
 func (t *TrackedValidatorsCache) Set(val TrackedValidator) {
-	t.Lock()
-	defer t.Unlock()
-	t.trackedValidators[val.Index] = val
+	key := toCacheKey(val.Index)
+	t.trackedValidators.Set(key, val, cache.DefaultExpiration)
 }

+// Delete removes a tracked validator from the cache.
 func (t *TrackedValidatorsCache) Prune() {
-	t.Lock()
-	defer t.Unlock()
-	t.trackedValidators = make(map[primitives.ValidatorIndex]TrackedValidator)
+	t.trackedValidators.Flush()
+	trackedValidatorsCacheCount.Set(0)
 }

+// Validating returns true if there are at least one tracked validators in the cache.
 func (t *TrackedValidatorsCache) Validating() bool {
-	t.Lock()
-	defer t.Unlock()
-	return len(t.trackedValidators) > 0
+	count := t.trackedValidators.ItemCount()
+	trackedValidatorsCacheCount.Set(float64(count))
+
+	return count > 0
+}
+
+// ItemCount returns the number of tracked validators in the cache.
+func (t *TrackedValidatorsCache) ItemCount() int {
+	count := t.trackedValidators.ItemCount()
+	trackedValidatorsCacheCount.Set(float64(count))
+
+	return count
+}
+
+// Indices returns a map of validator indices that are being tracked.
+func (t *TrackedValidatorsCache) Indices() map[primitives.ValidatorIndex]bool {
+	items := t.trackedValidators.Items()
+	count := len(items)
+	trackedValidatorsCacheCount.Set(float64(count))
+
+	indices := make(map[primitives.ValidatorIndex]bool, count)
+
+	for cacheKey := range items {
+		index, err := fromCacheKey(cacheKey)
+		if err != nil {
+			logrus.WithError(err).Error("Failed to get validator index from cache key")
+			continue
+		}
+
+		indices[index] = true
+	}
+
+	return indices
+}
+
+// toCacheKey creates a cache key from the validator index.
+func toCacheKey(validatorIndex primitives.ValidatorIndex) string {
+	return strconv.FormatUint(uint64(validatorIndex), 10)
+}
+
+// fromCacheKey gets the validator index from the cache key.
+func fromCacheKey(key string) (primitives.ValidatorIndex, error) {
+	validatorIndex, err := strconv.ParseUint(key, 10, 64)
+	if err != nil {
+		return 0, errors.Wrapf(err, "parse Uint: %s", key)
+	}
+
+	return primitives.ValidatorIndex(validatorIndex), nil
 }
--- a/beacon-chain/cache/tracked_validators_test.go
+++ b/beacon-chain/cache/tracked_validators_test.go
@@ -0,0 +1,79 @@
+package cache
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func mapEqual(a, b map[primitives.ValidatorIndex]bool) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for k, v := range a {
+		if b[k] != v {
+			return false
+		}
+	}
+
+	return true
+}
+
+func TestTrackedValidatorsCache(t *testing.T) {
+	vc := NewTrackedValidatorsCache()
+
+	// No validators in cache.
+	require.Equal(t, 0, vc.ItemCount())
+	require.Equal(t, false, vc.Validating())
+	require.Equal(t, 0, len(vc.Indices()))
+
+	_, ok := vc.Validator(41)
+	require.Equal(t, false, ok)
+
+	// Add some validators (one twice).
+	v42Expected := TrackedValidator{Active: true, FeeRecipient: [20]byte{1}, Index: 42}
+	v43Expected := TrackedValidator{Active: false, FeeRecipient: [20]byte{2}, Index: 43}
+
+	vc.Set(v42Expected)
+	vc.Set(v43Expected)
+	vc.Set(v42Expected)
+
+	// Check if they are in the cache.
+	v42Actual, ok := vc.Validator(42)
+	require.Equal(t, true, ok)
+	require.Equal(t, v42Expected, v42Actual)
+
+	v43Actual, ok := vc.Validator(43)
+	require.Equal(t, true, ok)
+	require.Equal(t, v43Expected, v43Actual)
+
+	expected := map[primitives.ValidatorIndex]bool{42: true, 43: true}
+	actual := vc.Indices()
+	require.Equal(t, true, mapEqual(expected, actual))
+
+	// Check the item count and if the cache is validating.
+	require.Equal(t, 2, vc.ItemCount())
+	require.Equal(t, true, vc.Validating())
+
+	// Check if a non-existing validator is in the cache.
+	_, ok = vc.Validator(41)
+	require.Equal(t, false, ok)
+
+	// Prune the cache and test it.
+	vc.Prune()
+
+	_, ok = vc.Validator(41)
+	require.Equal(t, false, ok)
+
+	_, ok = vc.Validator(42)
+	require.Equal(t, false, ok)
+
+	_, ok = vc.Validator(43)
+	require.Equal(t, false, ok)
+
+	require.Equal(t, 0, vc.ItemCount())
+	require.Equal(t, false, vc.Validating())
+	require.Equal(t, 0, len(vc.Indices()))
+}
--- a/beacon-chain/core/fulu/upgrade.go
+++ b/beacon-chain/core/fulu/upgrade.go
@@ -102,7 +102,7 @@ func UpgradeToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 		return nil, err
 	}

-	s := &ethpb.BeaconStateFulu{
+	s := &ethpb.BeaconStateElectra{
 		GenesisTime:           beaconState.GenesisTime(),
 		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
 		Slot:                  beaconState.Slot(),
--- a/beacon-chain/db/filesystem/iteration.go
+++ b/beacon-chain/db/filesystem/iteration.go
@@ -3,7 +3,6 @@ package filesystem
 import (
 	"fmt"
 	"io"
-	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -193,7 +192,7 @@ func rootFromPath(p string) ([32]byte, error) {
 }

 func idxFromPath(p string) (uint64, error) {
-	p = path.Base(p)
+	p = filepath.Base(p)

 	if !isSszFile(p) {
 		return 0, errors.Wrap(errNotBlobSSZ, "does not have .ssz extension")
--- a/beacon-chain/db/kv/lightclient.go
+++ b/beacon-chain/db/kv/lightclient.go
@@ -215,7 +215,7 @@ func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod u
 	if err != nil {
 		return nil, err
 	}
-	return updates, err
+	return updates, nil
 }

 func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error) {
--- a/beacon-chain/db/kv/state.go
+++ b/beacon-chain/db/kv/state.go
@@ -518,9 +518,9 @@ func (s *Store) unmarshalState(_ context.Context, enc []byte, validatorEntries [

 	switch {
 	case hasFuluKey(enc):
-		protoState := &ethpb.BeaconStateFulu{}
+		protoState := &ethpb.BeaconStateElectra{}
 		if err := protoState.UnmarshalSSZ(enc[len(fuluKey):]); err != nil {
-			return nil, errors.Wrap(err, "failed to unmarshal encoding for Electra")
+			return nil, errors.Wrap(err, "failed to unmarshal encoding for Fulu")
 		}
 		ok, err := s.isStateValidatorMigrationOver()
 		if err != nil {
@@ -690,7 +690,7 @@ func marshalState(ctx context.Context, st state.ReadOnlyBeaconState) ([]byte, er
 		}
 		return snappy.Encode(nil, append(ElectraKey, rawObj...)), nil
 	case version.Fulu:
-		rState, ok := st.ToProtoUnsafe().(*ethpb.BeaconStateFulu)
+		rState, ok := st.ToProtoUnsafe().(*ethpb.BeaconStateElectra)
 		if !ok {
 			return nil, errors.New("non valid inner state")
 		}
--- a/beacon-chain/execution/engine_client.go
+++ b/beacon-chain/execution/engine_client.go
@@ -36,17 +36,19 @@ var (
 		NewPayloadMethod,
 		NewPayloadMethodV2,
 		NewPayloadMethodV3,
-		NewPayloadMethodV4,
 		ForkchoiceUpdatedMethod,
 		ForkchoiceUpdatedMethodV2,
 		ForkchoiceUpdatedMethodV3,
 		GetPayloadMethod,
 		GetPayloadMethodV2,
 		GetPayloadMethodV3,
-		GetPayloadMethodV4,
 		GetPayloadBodiesByHashV1,
 		GetPayloadBodiesByRangeV1,
 	}
+	electraEngineEndpoints = []string{
+		NewPayloadMethodV4,
+		GetPayloadMethodV4,
+	}
 )

 const (
@@ -296,6 +298,10 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExchangeCapabilities")
 	defer span.End()

+	// Only check for electra related engine methods if it has been activated.
+	if params.ElectraEnabled() {
+		supportedEngineEndpoints = append(supportedEngineEndpoints, electraEngineEndpoints...)
+	}
 	var result []string
 	err := s.rpcClient.CallContext(ctx, &result, ExchangeCapabilities, supportedEngineEndpoints)
 	if err != nil {
--- a/beacon-chain/forkchoice/doubly-linked-tree/proposer_boost.go
+++ b/beacon-chain/forkchoice/doubly-linked-tree/proposer_boost.go
@@ -1,8 +1,6 @@
 package doublylinkedtree

 import (
-	"fmt"
-
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 )
@@ -15,7 +13,7 @@ func (f *ForkChoice) applyProposerBoostScore() error {
 	if s.previousProposerBoostRoot != params.BeaconConfig().ZeroHash {
 		previousNode, ok := s.nodeByRoot[s.previousProposerBoostRoot]
 		if !ok || previousNode == nil {
-			log.WithError(errInvalidProposerBoostRoot).Errorf(fmt.Sprintf("invalid prev root %#x", s.previousProposerBoostRoot))
+			log.WithError(errInvalidProposerBoostRoot).Errorf("invalid prev root %#x", s.previousProposerBoostRoot)
 		} else {
 			previousNode.balance -= s.previousProposerBoostScore
 		}
@@ -24,7 +22,7 @@ func (f *ForkChoice) applyProposerBoostScore() error {
 	if s.proposerBoostRoot != params.BeaconConfig().ZeroHash {
 		currentNode, ok := s.nodeByRoot[s.proposerBoostRoot]
 		if !ok || currentNode == nil {
-			log.WithError(errInvalidProposerBoostRoot).Errorf(fmt.Sprintf("invalid current root %#x", s.proposerBoostRoot))
+			log.WithError(errInvalidProposerBoostRoot).Errorf("invalid current root %#x", s.proposerBoostRoot)
 		} else {
 			proposerScore = (s.committeeWeight * params.BeaconConfig().ProposerScoreBoost) / 100
 			currentNode.balance += proposerScore
--- a/beacon-chain/monitor/process_attestation.go
+++ b/beacon-chain/monitor/process_attestation.go
@@ -166,6 +166,23 @@ func (s *Service) processIncludedAttestation(ctx context.Context, state state.Be
 	}
 }

+// processSingleAttestation logs when the beacon node observes a single attestation from tracked validator.
+func (s *Service) processSingleAttestation(att ethpb.Att) {
+	s.RLock()
+	defer s.RUnlock()
+
+	single, ok := att.(*ethpb.SingleAttestation)
+	if !ok {
+		log.Errorf("Wrong attestation type (expected %T, got %T)", &ethpb.SingleAttestation{}, att)
+		return
+	}
+
+	if s.canUpdateAttestedValidator(single.AttesterIndex, single.GetData().Slot) {
+		logFields := logMessageTimelyFlagsForIndex(single.AttesterIndex, att.GetData())
+		log.WithFields(logFields).Info("Processed unaggregated attestation")
+	}
+}
+
 // processUnaggregatedAttestation logs when the beacon node observes an unaggregated attestation from tracked validator.
 func (s *Service) processUnaggregatedAttestation(ctx context.Context, att ethpb.Att) {
 	s.RLock()
--- a/beacon-chain/monitor/service.go
+++ b/beacon-chain/monitor/service.go
@@ -241,7 +241,7 @@ func (s *Service) monitorRoutine(stateChannel chan *feed.Event, stateSub event.S
 				if !ok {
 					log.Error("Event feed data is not of type *operation.SingleAttReceivedData")
 				} else {
-					s.processUnaggregatedAttestation(s.ctx, data.Attestation)
+					s.processSingleAttestation(data.Attestation)
 				}
 			case operation.ExitReceived:
 				data, ok := e.Data.(*operation.ExitReceivedData)
--- a/beacon-chain/node/config.go
+++ b/beacon-chain/node/config.go
@@ -14,6 +14,7 @@ import (

 func configureTracing(cliCtx *cli.Context) error {
 	return tracing.Setup(
+		cliCtx.Context,
 		"beacon-chain", // service name
 		cliCtx.String(cmd.TracingProcessNameFlag.Name),
 		cliCtx.String(cmd.TracingEndpointFlag.Name),
@@ -165,7 +166,7 @@ func configureExecutionSetting(cliCtx *cli.Context) error {
 	}

 	if !cliCtx.IsSet(flags.SuggestedFeeRecipient.Name) {
-		log.Warnf("In order to receive transaction fees from proposing blocks, " +
+		log.Warn("In order to receive transaction fees from proposing blocks, " +
 			"you must provide flag --" + flags.SuggestedFeeRecipient.Name + " with a valid ethereum address when starting your beacon node. " +
 			"Please see our documentation for more information on this requirement (https://docs.prylabs.network/docs/execution-node/fee-recipient).")
 		return nil
--- a/beacon-chain/p2p/types/object_mapping.go
+++ b/beacon-chain/p2p/types/object_mapping.go
@@ -33,6 +33,9 @@ var (
 	// AggregateAttestationMap maps the fork-version to the underlying data type for that
 	// particular fork period.
 	AggregateAttestationMap map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error)
+	// AttesterSlashingMap maps the fork-version to the underlying data type for that particular
+	// fork period.
+	AttesterSlashingMap map[[4]byte]func() (ethpb.AttSlashing, error)
 )

 // InitializeDataMaps initializes all the relevant object maps. This function is called to
@@ -72,7 +75,7 @@ func InitializeDataMaps() {
 		},
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.ReadOnlySignedBeaconBlock, error) {
 			return blocks.NewSignedBeaconBlock(
-				&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockFulu{Body: &ethpb.BeaconBlockBodyFulu{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
+				&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
 			)
 		},
 	}
@@ -151,4 +154,29 @@ func InitializeDataMaps() {
 			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
 	}
+
+	// Reset our aggregate attestation map.
+	AttesterSlashingMap = map[[4]byte]func() (ethpb.AttSlashing, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashingElectra{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashingElectra{}, nil
+		},
+	}
 }
--- a/beacon-chain/p2p/types/object_mapping_test.go
+++ b/beacon-chain/p2p/types/object_mapping_test.go
@@ -76,6 +76,13 @@ func TestInitializeDataMaps(t *testing.T) {
 				require.NoError(t, err)
 				assert.Equal(t, version.Phase0, agg.Version())
 			}
+			attSlashFunc, ok := AttesterSlashingMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			assert.Equal(t, tt.exists, ok)
+			if tt.exists {
+				attSlash, err := attSlashFunc()
+				require.NoError(t, err)
+				assert.Equal(t, version.Phase0, attSlash.Version())
+			}
 		})
 	}
 }
--- a/beacon-chain/p2p/utils_test.go
+++ b/beacon-chain/p2p/utils_test.go
@@ -1,7 +1,6 @@
 package p2p

 import (
-	"fmt"
 	"testing"

 	"github.com/ethereum/go-ethereum/crypto"
@@ -28,7 +27,7 @@ func TestVerifyConnectivity(t *testing.T) {
 		{"123.123.123.123", 19000, false, "Dialing an unreachable IP: 123.123.123.123:19000"},
 	}
 	for _, tc := range cases {
-		t.Run(fmt.Sprintf(tc.name),
+		t.Run(tc.name,
 			func(t *testing.T) {
 				verifyConnectivity(tc.address, tc.port, "tcp")
 				logMessage := "IP address is not accessible"
--- a/beacon-chain/rpc/endpoints.go
+++ b/beacon-chain/rpc/endpoints.go
@@ -161,6 +161,7 @@ func (s *Service) builderEndpoints(stater lookup.Stater) []endpoint {
 	const namespace = "builder"
 	return []endpoint{
 		{
+			// Deprecated: use SSE from /eth/v1/events for `Payload Attributes` instead
 			template: "/eth/v1/builder/states/{state_id}/expected_withdrawals",
 			name:     namespace + ".ExpectedWithdrawals",
 			middleware: []middleware.Middleware{
@@ -225,6 +226,7 @@ func (s *Service) validatorEndpoints(
 	const namespace = "validator"
 	return []endpoint{
 		{
+			// Deprecated: use /eth/v2/validator/aggregate_attestation instead
 			template: "/eth/v1/validator/aggregate_attestation",
 			name:     namespace + ".GetAggregateAttestation",
 			middleware: []middleware.Middleware{
@@ -253,6 +255,7 @@ func (s *Service) validatorEndpoints(
 			methods: []string{http.MethodPost},
 		},
 		{
+			// Deprecated: use /eth/v2/validator/aggregate_and_proofs instead
 			template: "/eth/v1/validator/aggregate_and_proofs",
 			name:     namespace + ".SubmitAggregateAndProofs",
 			middleware: []middleware.Middleware{
@@ -583,6 +586,7 @@ func (s *Service) beaconEndpoints(
 			methods: []string{http.MethodGet},
 		},
 		{
+			// Deprecated: use /eth/v2/beacon/blocks instead
 			template: "/eth/v1/beacon/blocks",
 			name:     namespace + ".PublishBlock",
 			middleware: []middleware.Middleware{
@@ -593,6 +597,7 @@ func (s *Service) beaconEndpoints(
 			methods: []string{http.MethodPost},
 		},
 		{
+			// Deprecated: use /eth/v2/beacon/blinded_blocks instead
 			template: "/eth/v1/beacon/blinded_blocks",
 			name:     namespace + ".PublishBlindedBlock",
 			middleware: []middleware.Middleware{
@@ -632,6 +637,7 @@ func (s *Service) beaconEndpoints(
 			methods: []string{http.MethodGet},
 		},
 		{
+			// Deprecated: use /eth/v2/beacon/blocks/{block_id}/attestations instead
 			template: "/eth/v1/beacon/blocks/{block_id}/attestations",
 			name:     namespace + ".GetBlockAttestations",
 			middleware: []middleware.Middleware{
@@ -668,6 +674,7 @@ func (s *Service) beaconEndpoints(
 			methods: []string{http.MethodGet},
 		},
 		{
+			// Deprecated: use /eth/v2/beacon/pool/attestations instead
 			template: "/eth/v1/beacon/pool/attestations",
 			name:     namespace + ".ListAttestations",
 			middleware: []middleware.Middleware{
@@ -754,6 +761,7 @@ func (s *Service) beaconEndpoints(
 			methods: []string{http.MethodPost},
 		},
 		{
+			// Deprecated: use /eth/v2/beacon/pool/attester_slashings instead
 			template: "/eth/v1/beacon/pool/attester_slashings",
 			name:     namespace + ".GetAttesterSlashings",
 			middleware: []middleware.Middleware{
@@ -876,6 +884,7 @@ func (s *Service) beaconEndpoints(
 			methods: []string{http.MethodGet, http.MethodPost},
 		},
 		{
+			// Deprecated: no longer needed post Electra
 			template: "/eth/v1/beacon/deposit_snapshot",
 			name:     namespace + ".GetDepositSnapshot",
 			middleware: []middleware.Middleware{
@@ -884,6 +893,24 @@ func (s *Service) beaconEndpoints(
 			handler: server.GetDepositSnapshot,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/eth/v1/beacon/states/{state_id}/pending_deposits",
+			name:     namespace + ".GetPendingDeposits",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetPendingDeposits,
+			methods: []string{http.MethodGet},
+		},
+		{
+			template: "/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals",
+			name:     namespace + ".GetPendingPartialWithdrawals",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetPendingPartialWithdrawals,
+			methods: []string{http.MethodGet},
+		},
 	}
 }

--- a/beacon-chain/rpc/endpoints_test.go
+++ b/beacon-chain/rpc/endpoints_test.go
@@ -17,38 +17,40 @@ func Test_endpoints(t *testing.T) {
 	}

 	beaconRoutes := map[string][]string{
-		"/eth/v1/beacon/genesis":                                     {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/root":                      {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/fork":                      {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/finality_checkpoints":      {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/validators":                {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/states/{state_id}/validators/{validator_id}": {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/validator_balances":        {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/states/{state_id}/committees":                {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/sync_committees":           {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/randao":                    {http.MethodGet},
-		"/eth/v1/beacon/headers":                                     {http.MethodGet},
-		"/eth/v1/beacon/headers/{block_id}":                          {http.MethodGet},
-		"/eth/v1/beacon/blinded_blocks":                              {http.MethodPost},
-		"/eth/v2/beacon/blinded_blocks":                              {http.MethodPost},
-		"/eth/v1/beacon/blocks":                                      {http.MethodPost},
-		"/eth/v2/beacon/blocks":                                      {http.MethodPost},
-		"/eth/v2/beacon/blocks/{block_id}":                           {http.MethodGet},
-		"/eth/v1/beacon/blocks/{block_id}/root":                      {http.MethodGet},
-		"/eth/v1/beacon/blocks/{block_id}/attestations":              {http.MethodGet},
-		"/eth/v2/beacon/blocks/{block_id}/attestations":              {http.MethodGet},
-		"/eth/v1/beacon/blob_sidecars/{block_id}":                    {http.MethodGet},
-		"/eth/v1/beacon/deposit_snapshot":                            {http.MethodGet},
-		"/eth/v1/beacon/blinded_blocks/{block_id}":                   {http.MethodGet},
-		"/eth/v1/beacon/pool/attestations":                           {http.MethodGet, http.MethodPost},
-		"/eth/v2/beacon/pool/attestations":                           {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/attester_slashings":                     {http.MethodGet, http.MethodPost},
-		"/eth/v2/beacon/pool/attester_slashings":                     {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/proposer_slashings":                     {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/sync_committees":                        {http.MethodPost},
-		"/eth/v1/beacon/pool/voluntary_exits":                        {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/bls_to_execution_changes":               {http.MethodGet, http.MethodPost},
-		"/prysm/v1/beacon/individual_votes":                          {http.MethodPost},
+		"/eth/v1/beacon/genesis":                                       {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/root":                        {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/fork":                        {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/finality_checkpoints":        {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/validators":                  {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/states/{state_id}/validators/{validator_id}":   {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/validator_balances":          {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/states/{state_id}/committees":                  {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/sync_committees":             {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/randao":                      {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/pending_deposits":            {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals": {http.MethodGet},
+		"/eth/v1/beacon/headers":                                       {http.MethodGet},
+		"/eth/v1/beacon/headers/{block_id}":                            {http.MethodGet},
+		"/eth/v1/beacon/blinded_blocks":                                {http.MethodPost},
+		"/eth/v2/beacon/blinded_blocks":                                {http.MethodPost},
+		"/eth/v1/beacon/blocks":                                        {http.MethodPost},
+		"/eth/v2/beacon/blocks":                                        {http.MethodPost},
+		"/eth/v2/beacon/blocks/{block_id}":                             {http.MethodGet},
+		"/eth/v1/beacon/blocks/{block_id}/root":                        {http.MethodGet},
+		"/eth/v1/beacon/blocks/{block_id}/attestations":                {http.MethodGet},
+		"/eth/v2/beacon/blocks/{block_id}/attestations":                {http.MethodGet},
+		"/eth/v1/beacon/blob_sidecars/{block_id}":                      {http.MethodGet},
+		"/eth/v1/beacon/deposit_snapshot":                              {http.MethodGet},
+		"/eth/v1/beacon/blinded_blocks/{block_id}":                     {http.MethodGet},
+		"/eth/v1/beacon/pool/attestations":                             {http.MethodGet, http.MethodPost},
+		"/eth/v2/beacon/pool/attestations":                             {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/attester_slashings":                       {http.MethodGet, http.MethodPost},
+		"/eth/v2/beacon/pool/attester_slashings":                       {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/proposer_slashings":                       {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/sync_committees":                          {http.MethodPost},
+		"/eth/v1/beacon/pool/voluntary_exits":                          {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/bls_to_execution_changes":                 {http.MethodGet, http.MethodPost},
+		"/prysm/v1/beacon/individual_votes":                            {http.MethodPost},
 	}

 	lightClientRoutes := map[string][]string{
--- a/beacon-chain/rpc/eth/beacon/handlers.go
+++ b/beacon-chain/rpc/eth/beacon/handlers.go
@@ -292,6 +292,7 @@ func (s *Server) getBlockResponseBodyJson(ctx context.Context, blk interfaces.Re
 	}, nil
 }

+// Deprecated: use GetBlockAttestationsV2 instead
 // GetBlockAttestations retrieves attestation included in requested block.
 func (s *Server) GetBlockAttestations(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockAttestations")
@@ -394,6 +395,7 @@ func (s *Server) blockData(ctx context.Context, w http.ResponseWriter, r *http.R
 	return blk, isOptimistic, root
 }

+// Deprecated: use PublishBlindedBlockV2 instead
 // PublishBlindedBlock instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct
 // and publish a SignedBeaconBlock by swapping out the transactions_root for the corresponding full list of `transactions`.
 // The beacon node should broadcast a newly constructed SignedBeaconBlock to the beacon network, to be included in the
@@ -624,6 +626,7 @@ func decodeBlindedBellatrixJSON(body []byte) (*eth.GenericSignedBeaconBlock, err
 	)
 }

+// Deprecated: use PublishBlockV2 instead
 // PublishBlock instructs the beacon node to broadcast a newly signed beacon block to the beacon network,
 // to be included in the beacon chain. A success response (20x) indicates that the block
 // passed gossip validation and was successfully broadcast onto the network.
@@ -1534,6 +1537,7 @@ func (s *Server) GetGenesis(w http.ResponseWriter, r *http.Request) {
 	httputil.WriteJson(w, resp)
 }

+// Deprecated: no longer needed post Electra
 // GetDepositSnapshot retrieves the EIP-4881 Deposit Tree Snapshot. Either a JSON or,
 // if the Accept header was added, bytes serialized by SSZ will be returned.
 func (s *Server) GetDepositSnapshot(w http.ResponseWriter, r *http.Request) {
@@ -1608,3 +1612,129 @@ func (s *Server) broadcastSeenBlockSidecars(
 	}
 	return nil
 }
+
+// GetPendingDeposits returns pending deposits for state with given 'stateId'.
+// Should return 400 if the state retrieved is prior to Electra.
+// Supports both JSON and SSZ responses based on Accept header.
+func (s *Server) GetPendingDeposits(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetPendingDeposits")
+	defer span.End()
+
+	stateId := r.PathValue("state_id")
+	if stateId == "" {
+		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	st, err := s.Stater.State(ctx, []byte(stateId))
+	if err != nil {
+		shared.WriteStateFetchError(w, err)
+		return
+	}
+	if st.Version() < version.Electra {
+		httputil.HandleError(w, "state_id is prior to electra", http.StatusBadRequest)
+		return
+	}
+	pd, err := st.PendingDeposits()
+	if err != nil {
+		httputil.HandleError(w, "Could not get pending deposits: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set(api.VersionHeader, version.String(st.Version()))
+	if httputil.RespondWithSsz(r) {
+		sszData, err := serializeItems(pd)
+		if err != nil {
+			httputil.HandleError(w, "Failed to serialize pending deposits: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, sszData, "pending_deposits.ssz")
+	} else {
+		isOptimistic, err := helpers.IsOptimistic(ctx, []byte(stateId), s.OptimisticModeFetcher, s.Stater, s.ChainInfoFetcher, s.BeaconDB)
+		if err != nil {
+			httputil.HandleError(w, "Could not check optimistic status: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		blockRoot, err := st.LatestBlockHeader().HashTreeRoot()
+		if err != nil {
+			httputil.HandleError(w, "Could not calculate root of latest block header: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		isFinalized := s.FinalizationFetcher.IsFinalized(ctx, blockRoot)
+		resp := structs.GetPendingDepositsResponse{
+			Version:             version.String(st.Version()),
+			ExecutionOptimistic: isOptimistic,
+			Finalized:           isFinalized,
+			Data:                structs.PendingDepositsFromConsensus(pd),
+		}
+		httputil.WriteJson(w, resp)
+	}
+}
+
+// GetPendingPartialWithdrawals returns pending partial withdrawals for state with given 'stateId'.
+// Should return 400 if the state retrieved is prior to Electra.
+// Supports both JSON and SSZ responses based on Accept header.
+func (s *Server) GetPendingPartialWithdrawals(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetPendingPartialWithdrawals")
+	defer span.End()
+
+	stateId := r.PathValue("state_id")
+	if stateId == "" {
+		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	st, err := s.Stater.State(ctx, []byte(stateId))
+	if err != nil {
+		shared.WriteStateFetchError(w, err)
+		return
+	}
+	if st.Version() < version.Electra {
+		httputil.HandleError(w, "state_id is prior to electra", http.StatusBadRequest)
+		return
+	}
+	ppw, err := st.PendingPartialWithdrawals()
+	if err != nil {
+		httputil.HandleError(w, "Could not get pending partial withdrawals: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set(api.VersionHeader, version.String(st.Version()))
+	if httputil.RespondWithSsz(r) {
+		sszData, err := serializeItems(ppw)
+		if err != nil {
+			httputil.HandleError(w, "Failed to serialize pending partial withdrawals: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, sszData, "pending_partial_withdrawals.ssz")
+	} else {
+		isOptimistic, err := helpers.IsOptimistic(ctx, []byte(stateId), s.OptimisticModeFetcher, s.Stater, s.ChainInfoFetcher, s.BeaconDB)
+		if err != nil {
+			httputil.HandleError(w, "Could not check optimistic status: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		blockRoot, err := st.LatestBlockHeader().HashTreeRoot()
+		if err != nil {
+			httputil.HandleError(w, "Could not calculate root of latest block header: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		isFinalized := s.FinalizationFetcher.IsFinalized(ctx, blockRoot)
+		resp := structs.GetPendingPartialWithdrawalsResponse{
+			Version:             version.String(st.Version()),
+			ExecutionOptimistic: isOptimistic,
+			Finalized:           isFinalized,
+			Data:                structs.PendingPartialWithdrawalsFromConsensus(ppw),
+		}
+		httputil.WriteJson(w, resp)
+	}
+}
+
+// SerializeItems serializes a slice of items, each of which implements the MarshalSSZ method,
+// into a single byte array.
+func serializeItems[T interface{ MarshalSSZ() ([]byte, error) }](items []T) ([]byte, error) {
+	var result []byte
+	for _, item := range items {
+		b, err := item.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, b...)
+	}
+	return result, nil
+}
--- a/beacon-chain/rpc/eth/beacon/handlers_pool.go
+++ b/beacon-chain/rpc/eth/beacon/handlers_pool.go
@@ -34,6 +34,7 @@ import (

 const broadcastBLSChangesRateLimit = 128

+// Deprecated: use ListAttestationsV2 instead
 // ListAttestations retrieves attestations known by the node but
 // not necessarily incorporated into any block. Allows filtering by committee index or slot.
 func (s *Server) ListAttestations(w http.ResponseWriter, r *http.Request) {
@@ -707,6 +708,7 @@ func (s *Server) ListBLSToExecutionChanges(w http.ResponseWriter, r *http.Reques
 	})
 }

+// Deprecated: use GetAttesterSlashingsV2 instead
 // GetAttesterSlashings retrieves attester slashings known by the node but
 // not necessarily incorporated into any block.
 func (s *Server) GetAttesterSlashings(w http.ResponseWriter, r *http.Request) {
--- a/beacon-chain/rpc/eth/beacon/handlers_test.go
+++ b/beacon-chain/rpc/eth/beacon/handlers_test.go
@@ -327,7 +327,7 @@ func TestGetBlockV2(t *testing.T) {
 		resp := &structs.GetBlockV2Response{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		assert.Equal(t, version.String(version.Fulu), resp.Version)
-		sbb := &structs.SignedBeaconBlockFulu{Message: &structs.BeaconBlockFulu{}}
+		sbb := &structs.SignedBeaconBlockFulu{Message: &structs.BeaconBlockElectra{}}
 		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
 		sbb.Signature = resp.Data.Signature
 		blk, err := sbb.ToConsensus()
@@ -1910,8 +1910,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
 			return ok
 		}))
 		server := &Server{
@@ -1919,16 +1918,16 @@ func TestPublishBlockSSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}

-		var blk structs.SignedBeaconBlockContentsFulu
+		var blk structs.SignedBeaconBlockContentsElectra
 		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
@@ -2420,8 +2419,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
 			return ok
 		}))
 		server := &Server{
@@ -2429,16 +2427,16 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}

-		var blk structs.SignedBlindedBeaconBlockFulu
-		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
@@ -2888,8 +2886,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
 			return ok
 		}))
 		server := &Server{
@@ -2897,16 +2894,16 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}

-		var blk structs.SignedBeaconBlockContentsFulu
-		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blk)
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
@@ -3377,8 +3374,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
 			return ok
 		}))
 		server := &Server{
@@ -3386,16 +3382,16 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}

-		var blk structs.SignedBlindedBeaconBlockFulu
-		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
@@ -4758,3 +4754,386 @@ func Test_validateBlobSidecars(t *testing.T) {
 	require.NoError(t, err)
 	require.ErrorContains(t, "could not verify blob proof: can't verify opening proof", s.validateBlobSidecars(b, [][]byte{blob[:]}, [][]byte{proof[:]}))
 }
+
+func TestGetPendingDeposits(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 10)
+
+	validators := st.Validators()
+	dummySig := make([]byte, 96)
+	for j := 0; j < 96; j++ {
+		dummySig[j] = byte(j)
+	}
+	deps := make([]*eth.PendingDeposit, 10)
+	for i := 0; i < len(deps); i += 1 {
+		deps[i] = &eth.PendingDeposit{
+			PublicKey:             validators[i].PublicKey,
+			WithdrawalCredentials: validators[i].WithdrawalCredentials,
+			Amount:                100,
+			Slot:                  0,
+			Signature:             dummySig,
+		}
+	}
+	require.NoError(t, st.SetPendingDeposits(deps))
+
+	chainService := &chainMock.ChainService{
+		Optimistic:     false,
+		FinalizedRoots: map[[32]byte]bool{},
+	}
+	server := &Server{
+		Stater: &testutil.MockStater{
+			BeaconState: st,
+		},
+		OptimisticModeFetcher: chainService,
+		FinalizationFetcher:   chainService,
+	}
+
+	t.Run("json response", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingDeposits(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+		require.Equal(t, "electra", rec.Header().Get(api.VersionHeader))
+
+		var resp structs.GetPendingDepositsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+
+		expectedVersion := version.String(st.Version())
+		require.Equal(t, expectedVersion, resp.Version)
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+
+		expectedDeposits := structs.PendingDepositsFromConsensus(deps)
+		require.DeepEqual(t, expectedDeposits, resp.Data)
+	})
+	t.Run("ssz response", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		req.Header.Set("Accept", "application/octet-stream")
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingDeposits(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+		require.Equal(t, "electra", rec.Header().Get(api.VersionHeader))
+
+		responseBytes := rec.Body.Bytes()
+		var recoveredDeposits []*eth.PendingDeposit
+
+		// Verify total size matches expected number of deposits
+		depositSize := (&eth.PendingDeposit{}).SizeSSZ()
+		require.Equal(t, len(responseBytes), depositSize*len(deps))
+
+		for i := 0; i < len(deps); i++ {
+			start := i * depositSize
+			end := start + depositSize
+
+			var deposit eth.PendingDeposit
+			require.NoError(t, deposit.UnmarshalSSZ(responseBytes[start:end]))
+			recoveredDeposits = append(recoveredDeposits, &deposit)
+		}
+		require.DeepEqual(t, deps, recoveredDeposits)
+	})
+	t.Run("pre electra state", func(t *testing.T) {
+		preElectraSt, _ := util.DeterministicGenesisStateDeneb(t, 1)
+		preElectraServer := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: preElectraSt,
+			},
+			OptimisticModeFetcher: chainService,
+			FinalizationFetcher:   chainService,
+		}
+
+		// Test JSON request
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		preElectraServer.GetPendingDeposits(rec, req)
+		require.Equal(t, http.StatusBadRequest, rec.Code)
+
+		var errResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &errResp))
+		require.Equal(t, "state_id is prior to electra", errResp.Message)
+
+		// Test SSZ request
+		sszReq := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		sszReq.Header.Set("Accept", "application/octet-stream")
+		sszReq.SetPathValue("state_id", "head")
+		sszRec := httptest.NewRecorder()
+		sszRec.Body = new(bytes.Buffer)
+
+		preElectraServer.GetPendingDeposits(sszRec, sszReq)
+		require.Equal(t, http.StatusBadRequest, sszRec.Code)
+
+		var sszErrResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(sszRec.Body.Bytes(), &sszErrResp))
+		require.Equal(t, "state_id is prior to electra", sszErrResp.Message)
+	})
+	t.Run("missing state_id parameter", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		// Intentionally not setting state_id
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingDeposits(rec, req)
+		require.Equal(t, http.StatusBadRequest, rec.Code)
+
+		var errResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &errResp))
+		require.Equal(t, "state_id is required in URL params", errResp.Message)
+	})
+	t.Run("optimistic node", func(t *testing.T) {
+		optimisticChainService := &chainMock.ChainService{
+			Optimistic:     true,
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		optimisticServer := &Server{
+			Stater:                server.Stater,
+			OptimisticModeFetcher: optimisticChainService,
+			FinalizationFetcher:   optimisticChainService,
+		}
+
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		optimisticServer.GetPendingDeposits(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+
+		var resp structs.GetPendingDepositsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+		require.Equal(t, true, resp.ExecutionOptimistic)
+	})
+
+	t.Run("finalized node", func(t *testing.T) {
+		blockRoot, err := st.LatestBlockHeader().HashTreeRoot()
+		require.NoError(t, err)
+
+		finalizedChainService := &chainMock.ChainService{
+			Optimistic:     false,
+			FinalizedRoots: map[[32]byte]bool{blockRoot: true},
+		}
+		finalizedServer := &Server{
+			Stater:                server.Stater,
+			OptimisticModeFetcher: finalizedChainService,
+			FinalizationFetcher:   finalizedChainService,
+		}
+
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_deposits", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		finalizedServer.GetPendingDeposits(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+
+		var resp structs.GetPendingDepositsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+		require.Equal(t, true, resp.Finalized)
+	})
+}
+
+func TestGetPendingPartialWithdrawals(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 10)
+	for i := 0; i < 10; i += 1 {
+		err := st.AppendPendingPartialWithdrawal(
+			&eth.PendingPartialWithdrawal{
+				Index:             primitives.ValidatorIndex(i),
+				Amount:            100,
+				WithdrawableEpoch: primitives.Epoch(0),
+			})
+		require.NoError(t, err)
+	}
+	withdrawals, err := st.PendingPartialWithdrawals()
+	require.NoError(t, err)
+
+	chainService := &chainMock.ChainService{
+		Optimistic:     false,
+		FinalizedRoots: map[[32]byte]bool{},
+	}
+	server := &Server{
+		Stater: &testutil.MockStater{
+			BeaconState: st,
+		},
+		OptimisticModeFetcher: chainService,
+		FinalizationFetcher:   chainService,
+	}
+
+	t.Run("json response", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingPartialWithdrawals(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+		require.Equal(t, "electra", rec.Header().Get(api.VersionHeader))
+
+		var resp structs.GetPendingPartialWithdrawalsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+
+		expectedVersion := version.String(st.Version())
+		require.Equal(t, expectedVersion, resp.Version)
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+
+		expectedWithdrawals := structs.PendingPartialWithdrawalsFromConsensus(withdrawals)
+		require.DeepEqual(t, expectedWithdrawals, resp.Data)
+	})
+
+	t.Run("ssz response", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		req.Header.Set("Accept", "application/octet-stream")
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingPartialWithdrawals(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+		require.Equal(t, "electra", rec.Header().Get(api.VersionHeader))
+
+		responseBytes := rec.Body.Bytes()
+		var recoveredWithdrawals []*eth.PendingPartialWithdrawal
+
+		withdrawalSize := (&eth.PendingPartialWithdrawal{}).SizeSSZ()
+		require.Equal(t, len(responseBytes), withdrawalSize*len(withdrawals))
+
+		for i := 0; i < len(withdrawals); i++ {
+			start := i * withdrawalSize
+			end := start + withdrawalSize
+
+			var withdrawal eth.PendingPartialWithdrawal
+			require.NoError(t, withdrawal.UnmarshalSSZ(responseBytes[start:end]))
+			recoveredWithdrawals = append(recoveredWithdrawals, &withdrawal)
+		}
+		require.DeepEqual(t, withdrawals, recoveredWithdrawals)
+	})
+
+	t.Run("pre electra state", func(t *testing.T) {
+		preElectraSt, _ := util.DeterministicGenesisStateDeneb(t, 1)
+		preElectraServer := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: preElectraSt,
+			},
+			OptimisticModeFetcher: chainService,
+			FinalizationFetcher:   chainService,
+		}
+
+		// Test JSON request
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		preElectraServer.GetPendingPartialWithdrawals(rec, req)
+		require.Equal(t, http.StatusBadRequest, rec.Code)
+
+		var errResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &errResp))
+		require.Equal(t, "state_id is prior to electra", errResp.Message)
+
+		// Test SSZ request
+		sszReq := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		sszReq.Header.Set("Accept", "application/octet-stream")
+		sszReq.SetPathValue("state_id", "head")
+		sszRec := httptest.NewRecorder()
+		sszRec.Body = new(bytes.Buffer)
+
+		preElectraServer.GetPendingPartialWithdrawals(sszRec, sszReq)
+		require.Equal(t, http.StatusBadRequest, sszRec.Code)
+
+		var sszErrResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(sszRec.Body.Bytes(), &sszErrResp))
+		require.Equal(t, "state_id is prior to electra", sszErrResp.Message)
+	})
+
+	t.Run("missing state_id parameter", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		// Intentionally not setting state_id
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingPartialWithdrawals(rec, req)
+		require.Equal(t, http.StatusBadRequest, rec.Code)
+
+		var errResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &errResp))
+		require.Equal(t, "state_id is required in URL params", errResp.Message)
+	})
+
+	t.Run("optimistic node", func(t *testing.T) {
+		optimisticChainService := &chainMock.ChainService{
+			Optimistic:     true,
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		optimisticServer := &Server{
+			Stater:                server.Stater,
+			OptimisticModeFetcher: optimisticChainService,
+			FinalizationFetcher:   optimisticChainService,
+		}
+
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		optimisticServer.GetPendingPartialWithdrawals(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+
+		var resp structs.GetPendingPartialWithdrawalsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+		require.Equal(t, true, resp.ExecutionOptimistic)
+	})
+
+	t.Run("finalized node", func(t *testing.T) {
+		blockRoot, err := st.LatestBlockHeader().HashTreeRoot()
+		require.NoError(t, err)
+
+		finalizedChainService := &chainMock.ChainService{
+			Optimistic:     false,
+			FinalizedRoots: map[[32]byte]bool{blockRoot: true},
+		}
+		finalizedServer := &Server{
+			Stater:                server.Stater,
+			OptimisticModeFetcher: finalizedChainService,
+			FinalizationFetcher:   finalizedChainService,
+		}
+
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		finalizedServer.GetPendingPartialWithdrawals(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+
+		var resp structs.GetPendingPartialWithdrawalsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+		require.Equal(t, true, resp.Finalized)
+	})
+}
--- a/beacon-chain/rpc/eth/builder/handlers.go
+++ b/beacon-chain/rpc/eth/builder/handlers.go
@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )

+// Deprecated: use SSE from events for `payload attributes` instead
 // ExpectedWithdrawals get the withdrawals computed from the specified state, that will be included in the block that gets built on the specified state.
 func (s *Server) ExpectedWithdrawals(w http.ResponseWriter, r *http.Request) {
 	// Retrieve beacon state
@@ -125,7 +126,7 @@ func buildExpectedWithdrawalsData(withdrawals []*enginev1.Withdrawal) []*structs

 func handleWrapError(err error, message string, code int) *httputil.DefaultJsonError {
 	return &httputil.DefaultJsonError{
-		Message: errors.Wrapf(err, message).Error(),
+		Message: errors.Wrap(err, message).Error(),
 		Code:    code,
 	}
 }
--- a/beacon-chain/rpc/eth/events/events.go
+++ b/beacon-chain/rpc/eth/events/events.go
@@ -142,7 +142,7 @@ func newTopicRequest(topics []string) (*topicRequest, error) {
 		} else if topicsForOpsFeed[name] {
 			req.needOpsFeed = true
 		} else {
-			return nil, errors.Wrapf(errInvalidTopicName, name)
+			return nil, errors.Wrap(errInvalidTopicName, name)
 		}
 		req.topics[name] = true
 	}
--- a/beacon-chain/rpc/eth/node/handlers_peers_test.go
+++ b/beacon-chain/rpc/eth/node/handlers_peers_test.go
@@ -239,7 +239,7 @@ func TestGetPeers(t *testing.T) {
 					}
 				}
 				if !found {
-					t.Errorf("Expected ID '" + expectedId + "' not found")
+					t.Error("Expected ID '" + expectedId + "' not found")
 				}
 			}
 		})
--- a/beacon-chain/rpc/eth/validator/handlers.go
+++ b/beacon-chain/rpc/eth/validator/handlers.go
@@ -43,6 +43,7 @@ import (
 	"google.golang.org/grpc/status"
 )

+// Deprecated: use GetAggregateAttestationV2 instead
 // GetAggregateAttestation aggregates all attestations matching the given attestation data root and slot, returning the aggregated result.
 func (s *Server) GetAggregateAttestation(w http.ResponseWriter, r *http.Request) {
 	_, span := trace.StartSpan(r.Context(), "validator.GetAggregateAttestation")
@@ -256,6 +257,7 @@ func (s *Server) SubmitContributionAndProofs(w http.ResponseWriter, r *http.Requ
 	}
 }

+// Deprecated: use SubmitAggregateAndProofsV2 instead
 // SubmitAggregateAndProofs verifies given aggregate and proofs and publishes them on appropriate gossipsub topic.
 func (s *Server) SubmitAggregateAndProofs(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "validator.SubmitAggregateAndProofs")
--- a/beacon-chain/rpc/eth/validator/handlers_block_test.go
+++ b/beacon-chain/rpc/eth/validator/handlers_block_test.go
@@ -2063,4 +2063,86 @@ func TestProduceBlockV3SSZ(t *testing.T) {
 		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
 		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
 	})
+	t.Run("Fulu", func(t *testing.T) {
+		var block *structs.SignedBeaconBlockContentsFulu
+		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &block)
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.ToUnsigned().ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v3/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV3(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		g, err := block.ToUnsigned().ToGeneric()
+		require.NoError(t, err)
+		bl, ok := g.Block.(*eth.GenericBeaconBlock_Fulu)
+		require.Equal(t, true, ok)
+		ssz, err := bl.Fulu.MarshalSSZ()
+		require.NoError(t, err)
+		require.Equal(t, string(ssz), writer.Body.String())
+		require.Equal(t, "false", writer.Header().Get(api.ExecutionPayloadBlindedHeader))
+		require.Equal(t, "2000", writer.Header().Get(api.ExecutionPayloadValueHeader))
+		require.Equal(t, "fulu", writer.Header().Get(api.VersionHeader))
+		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
+	})
+	t.Run("Blinded Fulu", func(t *testing.T) {
+		var block *structs.SignedBlindedBeaconBlockFulu
+		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &block)
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.Message.ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v3/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV3(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		g, err := block.Message.ToGeneric()
+		require.NoError(t, err)
+		bl, ok := g.Block.(*eth.GenericBeaconBlock_BlindedFulu)
+		require.Equal(t, true, ok)
+		ssz, err := bl.BlindedFulu.MarshalSSZ()
+		require.NoError(t, err)
+		require.Equal(t, string(ssz), writer.Body.String())
+		require.Equal(t, "true", writer.Header().Get(api.ExecutionPayloadBlindedHeader))
+		require.Equal(t, "2000", writer.Header().Get(api.ExecutionPayloadValueHeader))
+		require.Equal(t, "fulu", writer.Header().Get(api.VersionHeader))
+		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
+	})
 }
--- a/beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go
@@ -110,6 +110,14 @@ func convertToBlockContainer(blk interfaces.ReadOnlySignedBeaconBlock, root [32]
 		ctr.Block = &ethpb.BeaconBlockContainer_BlindedDenebBlock{BlindedDenebBlock: pbStruct}
 	case *ethpb.SignedBeaconBlockDeneb:
 		ctr.Block = &ethpb.BeaconBlockContainer_DenebBlock{DenebBlock: pbStruct}
+	case *ethpb.SignedBlindedBeaconBlockElectra:
+		ctr.Block = &ethpb.BeaconBlockContainer_BlindedElectraBlock{BlindedElectraBlock: pbStruct}
+	case *ethpb.SignedBeaconBlockElectra:
+		ctr.Block = &ethpb.BeaconBlockContainer_ElectraBlock{ElectraBlock: pbStruct}
+	case *ethpb.SignedBlindedBeaconBlockFulu:
+		ctr.Block = &ethpb.BeaconBlockContainer_BlindedFuluBlock{BlindedFuluBlock: pbStruct}
+	case *ethpb.SignedBeaconBlockFulu:
+		ctr.Block = &ethpb.BeaconBlockContainer_FuluBlock{FuluBlock: pbStruct}
 	default:
 		return nil, errors.Errorf("block type is not recognized: %d", blk.Version())
 	}
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block.go
@@ -96,7 +96,7 @@ func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, p
 	if isBlinded {
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blockProto.(*ethpb.BlindedBeaconBlockFulu)}, IsBlinded: true, PayloadValue: payloadValue}
 	}
-	fuluContents := &ethpb.BeaconBlockContentsFulu{Block: blockProto.(*ethpb.BeaconBlockFulu)}
+	fuluContents := &ethpb.BeaconBlockContentsFulu{Block: blockProto.(*ethpb.BeaconBlockElectra)}
 	if bundle != nil {
 		fuluContents.KzgProofs = bundle.Proofs
 		fuluContents.Blobs = bundle.Blobs
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go
@@ -417,7 +417,7 @@ func (vs *Server) PrepareBeaconProposer(
 	for _, r := range request.Recipients {
 		recipient := hexutil.Encode(r.FeeRecipient)
 		if !common.IsHexAddress(recipient) {
-			return nil, status.Errorf(codes.InvalidArgument, fmt.Sprintf("Invalid fee recipient address: %v", recipient))
+			return nil, status.Errorf(codes.InvalidArgument, "Invalid fee recipient address: %v", recipient)
 		}
 		// Use default address if the burn address is return
 		feeRecipient := primitives.ExecutionAddress(r.FeeRecipient)
@@ -470,7 +470,7 @@ func (vs *Server) GetFeeRecipientByPubKey(ctx context.Context, request *ethpb.Fe
 			}, nil
 		} else {
 			log.WithError(err).Error("An error occurred while retrieving fee recipient from db")
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, status.Errorf(codes.Internal, "error=%s", err)
 		}
 	}
 	return &ethpb.FeeRecipientByPubKeyResponse{
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations.go
@@ -2,8 +2,10 @@ package validator

 import (
 	"bytes"
+	"cmp"
 	"context"
 	"fmt"
+	"slices"
 	"sort"

 	"github.com/pkg/errors"
@@ -277,7 +279,14 @@ func (a proposerAtts) sortOnChainAggregates() (proposerAtts, error) {
 		return a, nil
 	}

-	return a.sortByProfitabilityUsingMaxCover()
+	// Sort by slot first, then by bit count.
+	slices.SortFunc(a, func(a, b ethpb.Att) int {
+		return cmp.Or(
+			-cmp.Compare(a.GetData().Slot, b.GetData().Slot),
+			-cmp.Compare(a.GetAggregationBits().Count(), b.GetAggregationBits().Count()))
+	})
+
+	return a, nil
 }

 // Separate attestations by slot, as slot number takes higher precedence when sorting.
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations_test.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations_test.go
@@ -794,17 +794,19 @@ func Test_packAttestations_ElectraOnChainAggregates(t *testing.T) {

 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))

-	atts, err := s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch)
-	require.NoError(t, err)
-	require.Equal(t, 6, len(atts))
-	assert.Equal(t, true,
-		atts[0].GetAggregationBits().Count() >= atts[1].GetAggregationBits().Count() &&
-			atts[1].GetAggregationBits().Count() >= atts[2].GetAggregationBits().Count() &&
-			atts[2].GetAggregationBits().Count() >= atts[3].GetAggregationBits().Count() &&
-			atts[3].GetAggregationBits().Count() >= atts[4].GetAggregationBits().Count() &&
-			atts[4].GetAggregationBits().Count() >= atts[5].GetAggregationBits().Count(),
-		"on-chain aggregates are not sorted by aggregation bit count",
-	)
+	t.Run("ok", func(t *testing.T) {
+		atts, err := s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch)
+		require.NoError(t, err)
+		require.Equal(t, 6, len(atts))
+		assert.Equal(t, true,
+			atts[0].GetAggregationBits().Count() >= atts[1].GetAggregationBits().Count() &&
+				atts[1].GetAggregationBits().Count() >= atts[2].GetAggregationBits().Count() &&
+				atts[2].GetAggregationBits().Count() >= atts[3].GetAggregationBits().Count() &&
+				atts[3].GetAggregationBits().Count() >= atts[4].GetAggregationBits().Count() &&
+				atts[4].GetAggregationBits().Count() >= atts[5].GetAggregationBits().Count(),
+			"on-chain aggregates are not sorted by aggregation bit count",
+		)
+	})

 	t.Run("slot takes precedence", func(t *testing.T) {
 		moreRecentAtt := &ethpb.AttestationElectra{
@@ -814,7 +816,7 @@ func Test_packAttestations_ElectraOnChainAggregates(t *testing.T) {
 			Signature:       sig.Marshal(),
 		}
 		require.NoError(t, pool.SaveUnaggregatedAttestations([]ethpb.Att{moreRecentAtt}))
-		atts, err = s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch)
+		atts, err := s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch)
 		require.NoError(t, err)
 		require.Equal(t, 7, len(atts))
 		assert.Equal(t, true, atts[0].GetData().Slot == 1)
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block.go
@@ -17,7 +17,7 @@ func getEmptyBlock(slot primitives.Slot) (interfaces.SignedBeaconBlock, error) {
 	epoch := slots.ToEpoch(slot)
 	switch {
 	case epoch >= params.BeaconConfig().FuluForkEpoch:
-		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockFulu{Body: &ethpb.BeaconBlockBodyFulu{}}})
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
 		}
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block_test.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block_test.go
@@ -76,7 +76,7 @@ func Test_getEmptyBlock(t *testing.T) {
 			name: "fulu",
 			slot: primitives.Slot(params.BeaconConfig().FuluForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
 			want: func() interfaces.ReadOnlySignedBeaconBlock {
-				b, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockFulu{Body: &ethpb.BeaconBlockBodyFulu{}}})
+				b, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 				require.NoError(t, err)
 				return b
 			},
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go
@@ -737,11 +737,11 @@ func TestServer_GetBeaconBlock_Fulu(t *testing.T) {
 		},
 	}
 	blk := &ethpb.SignedBeaconBlockFulu{
-		Block: &ethpb.BeaconBlockFulu{
+		Block: &ethpb.BeaconBlockElectra{
 			Slot:       fuluSlot + 1,
 			ParentRoot: parentRoot[:],
 			StateRoot:  genesis.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBodyFulu{
+			Body: &ethpb.BeaconBlockBodyElectra{
 				RandaoReveal:  genesis.Block.Body.RandaoReveal,
 				Graffiti:      genesis.Block.Body.Graffiti,
 				Eth1Data:      genesis.Block.Body.Eth1Data,
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/status.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/status.go
@@ -269,7 +269,7 @@ func (vs *Server) optimisticStatus(ctx context.Context) error {
 		return nil
 	}

-	return status.Errorf(codes.Unavailable, errOptimisticMode.Error())
+	return status.Errorf(codes.Unavailable, "error=%v", errOptimisticMode)
 }

 // validatorStatus searches for the requested validator's state and deposit to retrieve its inclusion estimate. Also returns the validators index.
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/sync_committee.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/sync_committee.go
@@ -36,7 +36,7 @@ func (vs *Server) GetSyncMessageBlockRoot(
 // It also saves the sync committee message into the pending pool for block inclusion.
 func (vs *Server) SubmitSyncMessage(ctx context.Context, msg *ethpb.SyncCommitteeMessage) (*emptypb.Empty, error) {
 	if err := vs.CoreService.SubmitSyncMessage(ctx, msg); err != nil {
-		return &emptypb.Empty{}, status.Errorf(core.ErrorReasonToGRPC(err.Reason), err.Err.Error())
+		return &emptypb.Empty{}, status.Errorf(core.ErrorReasonToGRPC(err.Reason), "error=%s", err.Err)
 	}
 	return &emptypb.Empty{}, nil
 }
@@ -105,7 +105,7 @@ func (vs *Server) SubmitSignedContributionAndProof(
 ) (*emptypb.Empty, error) {
 	err := vs.CoreService.SubmitSignedContributionAndProof(ctx, s)
 	if err != nil {
-		return &emptypb.Empty{}, status.Errorf(core.ErrorReasonToGRPC(err.Reason), err.Err.Error())
+		return &emptypb.Empty{}, status.Errorf(core.ErrorReasonToGRPC(err.Reason), "error=%s", err.Err)
 	}
 	return &emptypb.Empty{}, nil
 }
--- a/beacon-chain/state/state-native/getters_state.go
+++ b/beacon-chain/state/state-native/getters_state.go
@@ -182,7 +182,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			NextWithdrawalValidatorIndex: b.nextWithdrawalValidatorIndex,
 			HistoricalSummaries:          b.historicalSummaries,
 		}
-	case version.Electra:
+	case version.Electra, version.Fulu:
 		return &ethpb.BeaconStateElectra{
 			GenesisTime:                   b.genesisTime,
 			GenesisValidatorsRoot:         gvrCopy[:],
@@ -222,46 +222,6 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			PendingPartialWithdrawals:     b.pendingPartialWithdrawals,
 			PendingConsolidations:         b.pendingConsolidations,
 		}
-	case version.Fulu:
-		return &ethpb.BeaconStateFulu{
-			GenesisTime:                   b.genesisTime,
-			GenesisValidatorsRoot:         gvrCopy[:],
-			Slot:                          b.slot,
-			Fork:                          b.fork,
-			LatestBlockHeader:             b.latestBlockHeader,
-			BlockRoots:                    br,
-			StateRoots:                    sr,
-			HistoricalRoots:               b.historicalRoots.Slice(),
-			Eth1Data:                      b.eth1Data,
-			Eth1DataVotes:                 b.eth1DataVotes,
-			Eth1DepositIndex:              b.eth1DepositIndex,
-			Validators:                    vals,
-			Balances:                      bals,
-			RandaoMixes:                   rm,
-			Slashings:                     b.slashings,
-			PreviousEpochParticipation:    b.previousEpochParticipation,
-			CurrentEpochParticipation:     b.currentEpochParticipation,
-			JustificationBits:             b.justificationBits,
-			PreviousJustifiedCheckpoint:   b.previousJustifiedCheckpoint,
-			CurrentJustifiedCheckpoint:    b.currentJustifiedCheckpoint,
-			FinalizedCheckpoint:           b.finalizedCheckpoint,
-			InactivityScores:              inactivityScores,
-			CurrentSyncCommittee:          b.currentSyncCommittee,
-			NextSyncCommittee:             b.nextSyncCommittee,
-			LatestExecutionPayloadHeader:  b.latestExecutionPayloadHeaderDeneb,
-			NextWithdrawalIndex:           b.nextWithdrawalIndex,
-			NextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
-			HistoricalSummaries:           b.historicalSummaries,
-			DepositRequestsStartIndex:     b.depositRequestsStartIndex,
-			DepositBalanceToConsume:       b.depositBalanceToConsume,
-			ExitBalanceToConsume:          b.exitBalanceToConsume,
-			EarliestExitEpoch:             b.earliestExitEpoch,
-			ConsolidationBalanceToConsume: b.consolidationBalanceToConsume,
-			EarliestConsolidationEpoch:    b.earliestConsolidationEpoch,
-			PendingDeposits:               b.pendingDeposits,
-			PendingPartialWithdrawals:     b.pendingPartialWithdrawals,
-			PendingConsolidations:         b.pendingConsolidations,
-		}
 	default:
 		return nil
 	}
@@ -428,7 +388,7 @@ func (b *BeaconState) ToProto() interface{} {
 			NextWithdrawalValidatorIndex: b.nextWithdrawalValidatorIndex,
 			HistoricalSummaries:          b.historicalSummariesVal(),
 		}
-	case version.Electra:
+	case version.Electra, version.Fulu:
 		return &ethpb.BeaconStateElectra{
 			GenesisTime:                   b.genesisTime,
 			GenesisValidatorsRoot:         gvrCopy[:],
@@ -468,46 +428,6 @@ func (b *BeaconState) ToProto() interface{} {
 			PendingPartialWithdrawals:     b.pendingPartialWithdrawalsVal(),
 			PendingConsolidations:         b.pendingConsolidationsVal(),
 		}
-	case version.Fulu:
-		return &ethpb.BeaconStateFulu{
-			GenesisTime:                   b.genesisTime,
-			GenesisValidatorsRoot:         gvrCopy[:],
-			Slot:                          b.slot,
-			Fork:                          b.forkVal(),
-			LatestBlockHeader:             b.latestBlockHeaderVal(),
-			BlockRoots:                    br,
-			StateRoots:                    sr,
-			HistoricalRoots:               b.historicalRoots.Slice(),
-			Eth1Data:                      b.eth1DataVal(),
-			Eth1DataVotes:                 b.eth1DataVotesVal(),
-			Eth1DepositIndex:              b.eth1DepositIndex,
-			Validators:                    b.validatorsVal(),
-			Balances:                      b.balancesVal(),
-			RandaoMixes:                   rm,
-			Slashings:                     b.slashingsVal(),
-			PreviousEpochParticipation:    b.previousEpochParticipationVal(),
-			CurrentEpochParticipation:     b.currentEpochParticipationVal(),
-			JustificationBits:             b.justificationBitsVal(),
-			PreviousJustifiedCheckpoint:   b.previousJustifiedCheckpointVal(),
-			CurrentJustifiedCheckpoint:    b.currentJustifiedCheckpointVal(),
-			FinalizedCheckpoint:           b.finalizedCheckpointVal(),
-			InactivityScores:              b.inactivityScoresVal(),
-			CurrentSyncCommittee:          b.currentSyncCommitteeVal(),
-			NextSyncCommittee:             b.nextSyncCommitteeVal(),
-			LatestExecutionPayloadHeader:  b.latestExecutionPayloadHeaderDeneb.Copy(),
-			NextWithdrawalIndex:           b.nextWithdrawalIndex,
-			NextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
-			HistoricalSummaries:           b.historicalSummariesVal(),
-			DepositRequestsStartIndex:     b.depositRequestsStartIndex,
-			DepositBalanceToConsume:       b.depositBalanceToConsume,
-			ExitBalanceToConsume:          b.exitBalanceToConsume,
-			EarliestExitEpoch:             b.earliestExitEpoch,
-			ConsolidationBalanceToConsume: b.consolidationBalanceToConsume,
-			EarliestConsolidationEpoch:    b.earliestConsolidationEpoch,
-			PendingDeposits:               b.pendingDepositsVal(),
-			PendingPartialWithdrawals:     b.pendingPartialWithdrawalsVal(),
-			PendingConsolidations:         b.pendingConsolidationsVal(),
-		}
 	default:
 		return nil
 	}
@@ -634,12 +554,4 @@ func ProtobufBeaconStateElectra(s interface{}) (*ethpb.BeaconStateElectra, error
 	return pbState, nil
 }

-// ProtobufBeaconStateFulu transforms an input into beacon state Fulu in the form of protobuf.
-// Error is returned if the input is not type protobuf beacon state.
-func ProtobufBeaconStateFulu(s interface{}) (*ethpb.BeaconStateFulu, error) {
-	pbState, ok := s.(*ethpb.BeaconStateFulu)
-	if !ok {
-		return nil, errors.New("input is not type pb.BeaconStateFulu")
-	}
-	return pbState, nil
-}
+var ProtobufBeaconStateFulu = ProtobufBeaconStateElectra
--- a/beacon-chain/state/state-native/state_trie.go
+++ b/beacon-chain/state/state-native/state_trie.go
@@ -159,8 +159,8 @@ func InitializeFromProtoElectra(st *ethpb.BeaconStateElectra) (state.BeaconState
 }

 // InitializeFromProtoFulu the beacon state from a protobuf representation.
-func InitializeFromProtoFulu(st *ethpb.BeaconStateFulu) (state.BeaconState, error) {
-	return InitializeFromProtoUnsafeFulu(proto.Clone(st).(*ethpb.BeaconStateFulu))
+func InitializeFromProtoFulu(st *ethpb.BeaconStateElectra) (state.BeaconState, error) {
+	return InitializeFromProtoUnsafeFulu(proto.Clone(st).(*ethpb.BeaconStateElectra))
 }

 // InitializeFromProtoUnsafePhase0 directly uses the beacon state protobuf fields
@@ -842,7 +842,7 @@ func InitializeFromProtoUnsafeElectra(st *ethpb.BeaconStateElectra) (state.Beaco

 // InitializeFromProtoUnsafeFulu directly uses the beacon state protobuf fields
 // and sets them as fields of the BeaconState type.
-func InitializeFromProtoUnsafeFulu(st *ethpb.BeaconStateFulu) (state.BeaconState, error) {
+func InitializeFromProtoUnsafeFulu(st *ethpb.BeaconStateElectra) (state.BeaconState, error) {
 	if st == nil {
 		return nil, errors.New("received nil state")
 	}
--- a/beacon-chain/sync/decode_pubsub.go
+++ b/beacon-chain/sync/decode_pubsub.go
@@ -87,6 +87,8 @@ func extractValidDataTypeFromTopic(topic string, digest []byte, clock *startup.C
 		return extractDataTypeFromTypeMap(types.AttestationMap, digest, clock)
 	case p2p.AggregateAndProofSubnetTopicFormat:
 		return extractDataTypeFromTypeMap(types.AggregateAttestationMap, digest, clock)
+	case p2p.AttesterSlashingSubnetTopicFormat:
+		return extractDataTypeFromTypeMap(types.AttesterSlashingMap, digest, clock)
 	}
 	return nil, nil
 }
--- a/beacon-chain/sync/decode_pubsub_test.go
+++ b/beacon-chain/sync/decode_pubsub_test.go
@@ -137,13 +137,14 @@ func TestExtractDataType(t *testing.T) {
 		chain  blockchain.ChainInfoFetcher
 	}
 	tests := []struct {
-		name          string
-		args          args
-		wantBlock     interfaces.ReadOnlySignedBeaconBlock
-		wantMd        metadata.Metadata
-		wantAtt       ethpb.Att
-		wantAggregate ethpb.SignedAggregateAttAndProof
-		wantErr       bool
+		name            string
+		args            args
+		wantBlock       interfaces.ReadOnlySignedBeaconBlock
+		wantMd          metadata.Metadata
+		wantAtt         ethpb.Att
+		wantAggregate   ethpb.SignedAggregateAttAndProof
+		wantAttSlashing ethpb.AttSlashing
+		wantErr         bool
 	}{
 		{
 			name: "no digest",
@@ -156,10 +157,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "invalid digest",
@@ -167,11 +169,12 @@ func TestExtractDataType(t *testing.T) {
 				digest: []byte{0x00, 0x01},
 				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
 			},
-			wantBlock:     nil,
-			wantMd:        nil,
-			wantAtt:       nil,
-			wantAggregate: nil,
-			wantErr:       true,
+			wantBlock:       nil,
+			wantMd:          nil,
+			wantAtt:         nil,
+			wantAggregate:   nil,
+			wantAttSlashing: nil,
+			wantErr:         true,
 		},
 		{
 			name: "non existent digest",
@@ -179,11 +182,12 @@ func TestExtractDataType(t *testing.T) {
 				digest: []byte{0x00, 0x01, 0x02, 0x03},
 				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
 			},
-			wantBlock:     nil,
-			wantMd:        nil,
-			wantAtt:       nil,
-			wantAggregate: nil,
-			wantErr:       true,
+			wantBlock:       nil,
+			wantMd:          nil,
+			wantAtt:         nil,
+			wantAggregate:   nil,
+			wantAttSlashing: nil,
+			wantErr:         true,
 		},
 		{
 			name: "genesis fork version",
@@ -196,9 +200,10 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "altair fork version",
@@ -211,10 +216,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "bellatrix fork version",
@@ -227,10 +233,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "capella fork version",
@@ -243,10 +250,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "deneb fork version",
@@ -259,10 +267,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "electra fork version",
@@ -275,10 +284,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.SingleAttestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProofElectra{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.SingleAttestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProofElectra{},
+			wantAttSlashing: &ethpb.AttesterSlashingElectra{},
+			wantErr:         false,
 		},
 		{
 			name: "fulu fork version",
@@ -287,14 +297,15 @@ func TestExtractDataType(t *testing.T) {
 				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
 			},
 			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
-				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockFulu{Body: &ethpb.BeaconBlockBodyFulu{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}})
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}})
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.SingleAttestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProofElectra{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.SingleAttestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProofElectra{},
+			wantAttSlashing: &ethpb.AttesterSlashingElectra{},
+			wantErr:         false,
 		},
 	}
 	for _, tt := range tests {
@@ -323,6 +334,14 @@ func TestExtractDataType(t *testing.T) {
 			if !reflect.DeepEqual(gotAggregate, tt.wantAggregate) {
 				t.Errorf("aggregate: got = %v, want %v", gotAggregate, tt.wantAggregate)
 			}
+			gotAttSlashing, err := extractDataTypeFromTypeMap(types.AttesterSlashingMap, tt.args.digest, tt.args.chain)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("attester slashing: error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAttSlashing, tt.wantAttSlashing) {
+				t.Errorf("attester slashin: got = %v, want %v", gotAttSlashing, tt.wantAttSlashing)
+			}
 		})
 	}
 }
--- a/beacon-chain/sync/fork_watcher.go
+++ b/beacon-chain/sync/fork_watcher.go
@@ -148,6 +148,7 @@ func (s *Service) deregisterFromPastFork(currentEpoch primitives.Epoch) error {
 	for topic := range topicsToRemove {
 		fullTopic := topic + s.cfg.p2p.Encoding().ProtocolSuffix()
 		s.cfg.p2p.Host().RemoveStreamHandler(protocol.ID(fullTopic))
+		log.WithField("topic", fullTopic).Debug("Removed RPC handler")
 	}

 	// Run through all our current active topics and see
--- a/beacon-chain/sync/initial-sync/BUILD.bazel
+++ b/beacon-chain/sync/initial-sync/BUILD.bazel
@@ -38,6 +38,7 @@ go_library(
        "//consensus-types/primitives:go_default_library",
        "//container/leaky-bucket:go_default_library",
        "//crypto/rand:go_default_library",
+        "//encoding/bytesutil:go_default_library",
        "//math:go_default_library",
        "//monitoring/tracing/trace:go_default_library",
        "//proto/prysm/v1alpha1:go_default_library",
--- a/beacon-chain/sync/initial-sync/blocks_fetcher.go
+++ b/beacon-chain/sync/initial-sync/blocks_fetcher.go
@@ -2,6 +2,7 @@ package initialsync

 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"sort"
 	"strings"
@@ -24,6 +25,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	leakybucket "github.com/prysmaticlabs/prysm/v5/container/leaky-bucket"
 	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	p2ppb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -67,6 +69,8 @@ var (
 // Period to calculate expected limit for a single peer.
 var blockLimiterPeriod = 30 * time.Second

+type isBannedBlock func(root [32]byte) bool
+
 // blocksFetcherConfig is a config to setup the block fetcher.
 type blocksFetcherConfig struct {
 	clock                    *startup.Clock
@@ -101,6 +105,7 @@ type blocksFetcher struct {
 	capacityWeight  float64       // how remaining capacity affects peer selection
 	mode            syncMode      // allows to use fetcher in different sync scenarios
 	quit            chan struct{} // termination notifier
+	isBannedBlock   isBannedBlock
 }

 // peerLock restricts fetcher actions on per peer basis. Currently, used for rate limiting.
@@ -126,6 +131,13 @@ type fetchRequestResponse struct {
 	err   error
 }

+// set in init()
+var holeskyBadRoot [32]byte
+
+func isHoleskyBannedBlock(root [32]byte) bool {
+	return root == holeskyBadRoot
+}
+
 // newBlocksFetcher creates ready to use fetcher.
 func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetcher {
 	blockBatchLimit := maxBatchLimit()
@@ -160,6 +172,7 @@ func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetc
 		capacityWeight:  capacityWeight,
 		mode:            cfg.mode,
 		quit:            make(chan struct{}),
+		isBannedBlock:   isHoleskyBannedBlock,
 	}
 }

@@ -357,6 +370,13 @@ func (f *blocksFetcher) fetchBlocksFromPeer(
 			log.WithField("peer", p).WithError(err).Debug("invalid BeaconBlocksByRange response")
 			continue
 		}
+		if f.isBannedBlock != nil {
+			for _, b := range robs {
+				if f.isBannedBlock(b.Block.Root()) {
+					return nil, p, prysmsync.ErrInvalidFetchedData
+				}
+			}
+		}
 		return robs, p, err
 	}
 	return nil, "", errNoPeersAvailable
@@ -727,3 +747,11 @@ func dedupPeers(peers []peer.ID) []peer.ID {
 	}
 	return newPeerList
 }
+
+func init() {
+	bytes, err := hex.DecodeString("2db899881ed8546476d0b92c6aa9110bea9a4cd0dbeb5519eb0ea69575f1f359")
+	if err != nil {
+		panic(err)
+	}
+	holeskyBadRoot = bytesutil.ToBytes32(bytes)
+}
--- a/beacon-chain/sync/initial-sync/round_robin.go
+++ b/beacon-chain/sync/initial-sync/round_robin.go
@@ -125,6 +125,7 @@ func (s *Service) syncToNonFinalizedEpoch(ctx context.Context, genesis time.Time
 	if err != nil {
 		return err
 	}
+
 	for data := range queue.fetchedData {
 		s.processFetchedDataRegSync(ctx, genesis, s.cfg.Chain.HeadSlot(), data)
 	}
@@ -169,6 +170,7 @@ func (s *Service) processFetchedDataRegSync(
 		"firstSlot":        data.bwb[0].Block.Block().Slot(),
 		"firstUnprocessed": bwb[0].Block.Block().Slot(),
 	}
+
 	for _, b := range bwb {
 		if err := avs.Persist(s.clock.CurrentSlot(), b.Blobs...); err != nil {
 			log.WithError(err).WithFields(batchFields).WithFields(syncFields(b.Block)).Warn("Batch failure due to BlobSidecar issues")
--- a/beacon-chain/sync/rpc.go
+++ b/beacon-chain/sync/rpc.go
@@ -303,6 +303,7 @@ func (s *Service) registerRPC(baseTopic string, handle rpcHandler) {
 			}
 		}
 	})
+	log.Debug("Registered new RPC handler")
 }

 func logStreamErrors(err error, topic string) {
--- a/beacon-chain/sync/rpc_beacon_blocks_by_range.go
+++ b/beacon-chain/sync/rpc_beacon_blocks_by_range.go
@@ -49,7 +49,12 @@ func (s *Service) beaconBlocksByRangeRPCHandler(ctx context.Context, msg interfa
 	}
 	available := s.validateRangeAvailability(rp)
 	if !available {
-		log.Debug("error in validating range availability")
+		log.WithFields(logrus.Fields{
+			"startSlot": rp.start,
+			"endSlot":   rp.end,
+			"size":      rp.size,
+			"current":   s.cfg.clock.CurrentSlot(),
+		}).Debug("error in validating range availability")
 		s.writeErrorResponseToStream(responseCodeResourceUnavailable, p2ptypes.ErrResourceUnavailable.Error(), stream)
 		tracing.AnnotateError(span, err)
 		return nil
--- a/beacon-chain/sync/rpc_send_request.go
+++ b/beacon-chain/sync/rpc_send_request.go
@@ -361,7 +361,7 @@ func readChunkedBlobSidecar(stream network.Stream, encoding encoder.NetworkEncod

 	v, found := ctxMap[bytesutil.ToBytes4(ctxb)]
 	if !found {
-		return b, errors.Wrapf(errBlobUnmarshal, fmt.Sprintf("unrecognized fork digest %#x", ctxb))
+		return b, errors.Wrapf(errBlobUnmarshal, "unrecognized fork digest %#x", ctxb)
 	}
 	// Only deneb and electra are supported at this time, because we lack a fork-spanning interface/union type for blobs.
 	// In electra, there's no changes to blob type.
--- a/beacon-chain/sync/rpc_status.go
+++ b/beacon-chain/sync/rpc_status.go
@@ -295,7 +295,7 @@ func (s *Service) validateStatusMessage(ctx context.Context, msg *pb.Status) err
 		return err
 	}
 	if !bytes.Equal(forkDigest[:], msg.ForkDigest) {
-		return p2ptypes.ErrWrongForkDigestVersion
+		return fmt.Errorf("mismatch fork digest: expected %#x, got %#x: %w", forkDigest[:], msg.ForkDigest, p2ptypes.ErrWrongForkDigestVersion)
 	}
 	genesis := s.cfg.clock.GenesisTime()
 	cp := s.cfg.chain.FinalizedCheckpt()
--- a/beacon-chain/sync/service.go
+++ b/beacon-chain/sync/service.go
@@ -6,6 +6,7 @@ package sync

 import (
 	"context"
+	"encoding/hex"
 	"sync"
 	"time"

@@ -49,6 +50,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )

+// hack to prevent bad holesky block importation
+var badHoleskyRoot [32]byte
+
 var _ runtime.Service = (*Service)(nil)

 const (
@@ -382,3 +386,13 @@ type Checker interface {
 	Status() error
 	Resync() error
 }
+
+func init() {
+	hexStr := "2db899881ed8546476d0b92c6aa9110bea9a4cd0dbeb5519eb0ea69575f1f359"
+	bytes, err := hex.DecodeString(hexStr)
+	if err != nil {
+		log.WithError(err).Error("Could not decode hex string")
+		return
+	}
+	badHoleskyRoot = [32]byte(bytes)
+}
--- a/beacon-chain/sync/validate_beacon_blocks.go
+++ b/beacon-chain/sync/validate_beacon_blocks.go
@@ -400,6 +400,9 @@ func (s *Service) setSeenBlockIndexSlot(slot primitives.Slot, proposerIdx primit

 // Returns true if the block is marked as a bad block.
 func (s *Service) hasBadBlock(root [32]byte) bool {
+	if root == badHoleskyRoot {
+		return true
+	}
 	s.badBlockLock.RLock()
 	defer s.badBlockLock.RUnlock()
 	_, seen := s.badBlockCache.Get(string(root[:]))
--- a/changelog/bastin_lightclient-bootstrap-ssz.md
+++ b/changelog/bastin_lightclient-bootstrap-ssz.md
@@ -1,3 +0,0 @@
-### Added
-
- Add test cases for the eth_lightclient_bootstrap API SSZ support. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14824)
--- a/changelog/dB2510_beacondbpruning.md
+++ b/changelog/dB2510_beacondbpruning.md
@@ -1,3 +0,0 @@
-### Added
-
- Add Beacon DB pruning service to prune historical data older than MIN_EPOCHS_FOR_BLOCK_REQUESTS (roughly equivalent to the weak subjectivity period)
--- a/changelog/dB2510_processslotspan.md
+++ b/changelog/dB2510_processslotspan.md
@@ -1,3 +0,0 @@
-### Changed
-
- Removes existing validator.processSlot span and adds validator.processSlot span to slotCtx.
--- a/changelog/hidewrong_use_time.DateTime.md
+++ b/changelog/hidewrong_use_time.DateTime.md
@@ -1,2 +0,0 @@
-### Changed
- Refactor `2006-01-02 15:04:05` to `time.DateTime`
--- a/changelog/james-prysm_builder-electra.md
+++ b/changelog/james-prysm_builder-electra.md
@@ -1,3 +0,0 @@
-### Added
-
- Builder API endpoint to support Electra
--- a/changelog/james-prysm_cleanup-payload-conversions.md
+++ b/changelog/james-prysm_cleanup-payload-conversions.md
@@ -0,0 +1,7 @@
+### Ignored
+
+- code cleanup on payload types and payload conversions
+
+### Fixed
+
+- fixed gocognit in block conversions between json and proto types
--- a/changelog/james-prysm_deprecate-apis-for-electra.md
+++ b/changelog/james-prysm_deprecate-apis-for-electra.md
@@ -0,0 +1,3 @@
+### Changed
+
+- deprecate beacon api endpoints based on [3.0.0 release](https://github.com/ethereum/beacon-APIs/pull/506) for electra
--- a/changelog/james-prysm_e2e-scenario-fork-fix.md
+++ b/changelog/james-prysm_e2e-scenario-fork-fix.md
@@ -1,3 +0,0 @@
-### Fixed
-
- added conditional evaluators to fix scenario e2e tests
--- a/changelog/james-prysm_electra-blobs-api.md
+++ b/changelog/james-prysm_electra-blobs-api.md
@@ -1,7 +0,0 @@
-### Added
-
- Updated blob sidecar api endpoint for Electra
-
-### Fixed
-
- Fix handling unfound block at slot
--- a/changelog/james-prysm_electra-e2e.md
+++ b/changelog/james-prysm_electra-e2e.md
@@ -0,0 +1,7 @@
+### Added
+
+- enable E2E for minimal and mainnet tests
+
+### Changed
+
+- updates geth to 1.15.0
--- a/changelog/james-prysm_electra-eth1voting.md
+++ b/changelog/james-prysm_electra-eth1voting.md
@@ -1,3 +0,0 @@
-### Added
-
- check to stop eth1 voting after electra and eth1 deposits stop
--- a/changelog/james-prysm_fix-block-api-electra.md
+++ b/changelog/james-prysm_fix-block-api-electra.md
@@ -1,3 +0,0 @@
-### Fixed
-
- fix block api endpoint to handle blocks with the same structure but on different forks (i.e. fulu and electra)
--- a/changelog/james-prysm_fix-builder-post-header.md
+++ b/changelog/james-prysm_fix-builder-post-header.md
@@ -0,0 +1,3 @@
+### Fixed
+
+- adding in content type and accept headers for builder API call on registration
--- a/changelog/james-prysm_handle-pbgeneric-error.md
+++ b/changelog/james-prysm_handle-pbgeneric-error.md
@@ -1,3 +0,0 @@
-### Fixed
-
- fix panic with type cast on pbgenericblock()
--- a/changelog/james-prysm_improve-execution-request-errors.md
+++ b/changelog/james-prysm_improve-execution-request-errors.md
@@ -0,0 +1,3 @@
+### Changed
+
+- execution requests errors on ssz length have been improved
--- a/changelog/james-prysm_nil-check-to-consensus.md
+++ b/changelog/james-prysm_nil-check-to-consensus.md
@@ -1,3 +0,0 @@
-### Fixed
-
- add more nil checks on ToConsensus functions for added safety
--- a/changelog/james-prysm_proposer-settings-readability.md
+++ b/changelog/james-prysm_proposer-settings-readability.md
@@ -1,3 +0,0 @@
-### Changed
-
- improving readability on proposer settings loader
--- a/changelog/james-prysm_remote-signer-electra.md
+++ b/changelog/james-prysm_remote-signer-electra.md
@@ -1,3 +0,0 @@
-### Added
-
- Remote signer electra fork support.
--- a/changelog/james-prysm_web3signer-electra-e2e.md
+++ b/changelog/james-prysm_web3signer-electra-e2e.md
@@ -0,0 +1,3 @@
+### Added
+
+- enable web3signer E2E for electra 
--- a/changelog/kasey_blobs-by-epoch.md
+++ b/changelog/kasey_blobs-by-epoch.md
@@ -1,2 +0,0 @@
-### Added
- New option to select an alternate blob storage layout. Rather than a flat directory with a subdir for each block root, a multi-level scheme is used to organize blobs by epoch/slot/root, enabling leaner syscalls, indexing and pruning.
--- a/changelog/kasey_changelog-tool.md
+++ b/changelog/kasey_changelog-tool.md
@@ -1,55 +0,0 @@
-### Added
-
- Added an error field to log `Finished building block`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14696)
- Implemented a new `EmptyExecutionPayloadHeader` function. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14713)
- Added proper gas limit check for header from the builder. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14707)
- `Finished building block`: Display error only if not nil. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14722)
- Added light client feature flag check to RPC handlers. [PR](https://github.com/prysmaticlabs/prysm/pull/14736)
- Added support to update target and max blob count to different values per hard fork config. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14678)
- Log before blob filesystem cache warm-up. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14735)
- New design for the attestation pool. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14324)
- Add field param placeholder for Electra blob target and max to pass spec tests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14733)
- Light client: Add better error handling. [PR](https://github.com/prysmaticlabs/prysm/pull/14749)
- Add EIP-7691: Blob throughput increase. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14750)
- Trace IDONTWANT Messages in Pubsub. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14778)
- Add Fulu fork boilerplate. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14771)
- DB optimization for saving light client bootstraps (save unique sync committees only)
- Separate type for unaggregated network attestations. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14659)
-
-
-### Changed
-
- Process light client finality updates only for new finalized epochs instead of doing it for every block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14713)
- Refactor subnets subscriptions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14711)
- Refactor RPC handlers subscriptions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14732)
- Go deps upgrade, from `ioutil` to `io`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14737)
- Move successfully registered validator(s) on builder log to debug. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14735)
- Update some test files to use `crypto/rand` instead of `math/rand`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14747)
- Re-organize the content of the `*.proto` files (No functional change). [[PR]](https://github.com/prysmaticlabs/prysm/pull/14755)
- SSZ files generation: Remove the `// Hash: ...` header.[[PR]](https://github.com/prysmaticlabs/prysm/pull/14760)
- Updated Electra spec definition for `process_epoch`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14768)
- Update our `go-libp2p-pubsub` dependency. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14770)
- Re-organize the content of files to ease the creation of a new fork boilerplate. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14761)
- Updated spec definition electra `process_registry_updates`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14767)
- Fixed Metadata errors for peers connected via QUIC. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14776)
- Updated spec definitions for `process_slashings` in godocs. Simplified `ProcessSlashings` API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14766)
- Update spec tests to v1.5.0-beta.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14788)
- Process light client finality updates only for new finalized epochs instead of doing it for every block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14718)
- Update blobs by rpc topics from V2 to V1. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14785)
-
-### Fixed
-
- Added check to prevent nil pointer deference or out of bounds array access when validating the BLSToExecutionChange on an impossibly nil validator. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14705)
- EIP-7691: Ensure new blobs subnets are subscribed on epoch in advance. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14759)
- Fix kzg commitment inclusion proof depth minimal value. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14787)
-
-### Removed
-
- Cleanup ProcessSlashings method to remove unnecessary argument. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14762)
- Remove `/proto/eth/v2` directory. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14765)
-
-### Security
-
- go version upgrade to 1.22.10 for CVE CVE-2024-34156. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14729)
- Update golang.org/x/crypto to v0.31.0 to address CVE-2024-45337. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14777)
- Update golang.org/x/net to v0.33.0 to address CVE-2024-45338. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14780)
--- a/changelog/kasey_refactor-checkpoint-download.md
+++ b/changelog/kasey_refactor-checkpoint-download.md
@@ -1,2 +0,0 @@
-### Changed
- DownloadFinalizedData has moved from the api/client package to beacon-chain/sync/checkpoint
--- a/changelog/kasey_stabilize-unclog.md
+++ b/changelog/kasey_stabilize-unclog.md
@@ -1,13 +0,0 @@
-### Changed
-
- Updated geth to 1.14~. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14351)
- E2e tests start from bellatrix. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14351)
-
-### Removed
-
- Remove `/memsize/` pprof endpoint as it will no longer be supported in go 1.23. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14351)
-
-### Ignored
-
- switches unclog from using a flaky github artifact to using a stable release asset.
- Adds changelog entries that were missing from the branch switching prysm over to unclog.
--- a/changelog/kasey_unclog-v0-1-3.md
+++ b/changelog/kasey_unclog-v0-1-3.md
@@ -1,2 +0,0 @@
-### Changed
- Version pinning unclog after making some ux improvements.
--- a/changelog/kasey_warn-hist-state-rep.md
+++ b/changelog/kasey_warn-hist-state-rep.md
@@ -1,2 +0,0 @@
-### Added
- WARN log message on node startup advising of the upcoming deprecation of the --enable-historical-state-representation feature flag.
--- a/changelog/kasey_windows-layout-fix.md
+++ b/changelog/kasey_windows-layout-fix.md
@@ -0,0 +1,2 @@
+### Fixed
+- Fixed bug that breaks new blob storage layout code on Windows, caused by accidental use of platform-dependent path parsing package.
--- a/changelog/manu_blob_subnets_node_filter.md
+++ b/changelog/manu_blob_subnets_node_filter.md
@@ -1,3 +0,0 @@
-### Fixed
-
- `nodeFilter`: Implement `filterPeerForBlobSubnet` to avoid error logs.
--- a/changelog/manu_fix_dependencies_doc.md
+++ b/changelog/manu_fix_dependencies_doc.md
@@ -0,0 +1,2 @@
+### Fixed
+- Fixed the `bazel run //:gazelle` command in `DEPENDENCIES.md`.
--- a/changelog/manu_fulu_fork.md
+++ b/changelog/manu_fulu_fork.md
@@ -1,3 +0,0 @@
-### Fixed
-
- `UpgradeToFulu`: Respect the specification.
--- a/changelog/manu_fulu_to_blinded.md
+++ b/changelog/manu_fulu_to_blinded.md
@@ -1,3 +0,0 @@
-### Fixed
-
- `ToBlinded`: Use Fulu struct for Fulu (instead of Electra)
--- a/changelog/manu_remove_fulu_state_block.md
+++ b/changelog/manu_remove_fulu_state_block.md
@@ -0,0 +1,3 @@
+### Removed
+
+- Remove Fulu state and block
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
nisdas	fd41691178	Revert Fallback Sync	2025-02-27 12:11:12 +08:00
nisdas	5916c6e625	Fix Attester Slashing Validation In Electra	2025-02-26 15:09:59 +08:00
terence tsao	0312cb223a	Move blockRoot == badHoleskyRoot earlier	2025-02-25 13:53:24 -08:00
terence tsao	68cf7a59f2	Update BUILD.bazel	2025-02-25 12:46:40 -08:00
Kasey Kirkham	537ddb1a24	reject bad root in receive block(batch)	2025-02-25 14:44:18 -06:00
Kasey Kirkham	7afaa6994b	hardcode root to remove cache eviction possibility	2025-02-25 14:37:50 -06:00
terence tsao	defb3ab87b	Revert terence's downscore change	2025-02-25 11:45:56 -08:00
terence tsao	81dce25c98	Gazelle	2025-02-25 11:41:28 -08:00
Kasey Kirkham	5c409b90bc	hack to downscore peers with bad holesky root	2025-02-25 13:40:33 -06:00
terence tsao	aa47661602	Downscore	2025-02-25 11:29:53 -08:00
potuz	7259a2b983	blacklist on batches too	2025-02-25 16:16:53 -03:00
terence tsao	e9f511ac00	Update bootnodes	2025-02-25 08:39:17 -08:00
potuz	34a68715b8	blacklist bad block	2025-02-25 11:40:35 -03:00
nisdas	c33e0575ab	do not resync	2025-02-25 17:32:16 +08:00
Preston Van Loon	09499a732f	gosec: Fix violations of G301 (#14980 ) * gosec: Fix violations of G301 * Changelog fragment	2025-02-24 15:13:53 +00:00
Preston Van Loon	2ee015452c	Use go-cmp and protocmp for assertion diff printing (#14978 ) Fix assertion tests after switching to cmp Changelog fragment	2025-02-23 21:06:07 +00:00
terence	ffc1bf8bbe	Add more verbosity to validate range message (#14975 )	2025-02-21 19:54:40 +00:00
Preston Van Loon	014dbd5c3a	Lint: Fix violations of non-constant format string in call (#14974 ) * Fix violations of non-constant format string in call * Changelog fragment	2025-02-21 19:46:19 +00:00
Preston Van Loon	9bceaa59d2	tracing: Add otel tracer transport to all http clients (#14972 ) * Fixed otelhttp client setups. Note: This may not be the best solution as the http client is defined in many places. There should be a canoncial http client with the proper setup. * Changelog fragment * go mod tidy and gazelle	2025-02-21 19:39:53 +00:00
Preston Van Loon	832ebb3f39	Lint: Fix violations of S1009: should omit nil check; len() for nil slices is defined as zero (#14973 ) * Fix violations of S1009: should omit nil check; len() for nil slices is defined as zero * Changelog fragment	2025-02-21 19:39:33 +00:00
james-prysm	8345c271cc	Code Cleanup: payload conversions and fixing gocognit ignores (#14953 ) * created new converstions_execution files moving the from and to consensus functions for execution related items, also created a placeholder for block_execution with the intent of adding execution types there * moving execution types from block.go to block_execution.go * migrating more types and logic * adding all the to consensus functions for payloads * changelog * linting * updating unit tests for conversions * fixing linting * forgot to fix test * updating name based on feedback	2025-02-21 16:12:01 +00:00
terence	56208aa84d	Add more verbosity to fork digest mismatch (#14968 )	2025-02-21 03:36:31 +00:00
james-prysm	b866a2c744	setting rest endpoints as deprecated for electra (#14967 )	2025-02-20 18:20:51 +00:00
Nishant Das	a77234e637	Test Execution Deposit Requests in E2E (#14964 ) * Test Deposit Requests * Remove extra epochs * Clean up Panic * Fix Slashing Config * Fix Slashing Test --------- Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com>	2025-02-20 14:54:45 +00:00
james-prysm	e0e7354708	improving the error messages for execution request deserialization (#14962 ) * improving the error messages for execution request deserialization * changelog	2025-02-20 14:31:02 +00:00
james-prysm	0f86a16915	builder: api calls should have appropriate headers (#14961 ) * adding correct headers when posting for validator registration on builder api * changelog	2025-02-20 14:27:14 +00:00
Radosław Kapka	972c22b02f	`SingleAttestation` support in the monitor service (#14965 ) * `SingleAttestation` support in the monitor service * changelog <3	2025-02-20 11:26:51 +00:00
Manu NALEPA	93c27340e4	Tracked validator TTL (#14957 ) * `TrackedValidatorsCache`: Implement a 1-hour TTL by uding `go-cache`. * `TrackedValidatorsCache`: Add the `ItemCount` method. * `TrackedValidatorsCache`: Add the `Indices` method. * Add changelog. * `TrackedValidatorsCache`: Add prometheus metrics. * Update beacon-chain/cache/tracked_validators.go Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com> --------- Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com>	2025-02-19 18:04:13 +00:00
Manu NALEPA	c3edb32558	`ServiceRegistry.StartAll`: Remove redundant log. (#14958 )	2025-02-19 17:12:32 +00:00
Sammy Rosso	3baaa732df	Add get pending partial withdrawals (#14949 ) * add pending partial withdrawals endpoint * changelog * missing new line * fix changelog * removing unneeded header * using generic instead of redundant functions --------- Co-authored-by: james-prysm <james@prysmaticlabs.com>	2025-02-19 12:34:48 +00:00
Nishant Das	8ceb7e76ea	Log execution requests (#14956 )	2025-02-19 10:19:04 +00:00
terence	4d5dddd302	Add request hash to header for builder: executable data to block (#14955 ) * Add request hash to header for builder: executable data to block * go fmt	2025-02-19 05:18:18 +00:00
Sammy Rosso	55efccb07f	Add get pending deposits endpoint (#14941 ) * Add GetPendingDeposits endpoint * add comment * add changelog * gaz * Radek' review * move JSON object params * gaz * Radek' nits xD * James' review	2025-02-18 16:16:20 +00:00
Radosław Kapka	961d8e1481	Don't use MaxCover for Electra on-chain aggregates (#14925 ) * Don't use MaxCover for Electra on-chain aggregates * changelog <3	2025-02-18 14:44:18 +00:00
Nishant Das	d396a9931e	Add in Multiclient E2E For Electra (#14946 ) * Add in Multiclient E2E * Fix Execution Engine * Update testing/endtoend/endtoend_test.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update testing/endtoend/endtoend_test.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> --------- Co-authored-by: Radosław Kapka <rkapka@wp.pl>	2025-02-18 10:32:58 +00:00
james-prysm	e3f8f121f4	web3signer electra for e2e (#14936 ) * changes needed to support web3signer running on electra for e2e * updating web3signer version and fixing missed configs and test alignment	2025-02-18 01:36:19 +00:00
fuyangpengqi	80f29e9eda	refactor: use a more straightforward return value (#14942 ) Signed-off-by: fuyangpengqi <995764973@qq.com>	2025-02-17 19:18:15 +00:00
Nishant Das	8995d8133a	Fix Deposit Activation Evaluator (#14938 ) * Fix evaluator * fix deposit activation	2025-02-17 13:43:23 +00:00
Preston Van Loon	31044206b8	tracing: Replace deprecated jaeger exporter with otelhttp exporter (#14928 ) * Update go.opentelemetry.io/otel to v1.34.0 * Update otel exporter to replace deprecated jaeger exporter * Changelog * Use WithEndpointURL * Clarify potential breaking change	2025-02-15 17:26:57 +00:00
Manu NALEPA	3a1702e56f	Fixed the `bazel run //:gazelle` command in `DEPENDENCIES.md`. (#14934 )	2025-02-14 15:00:10 +00:00
Nishant Das	501ec74a48	Fix Deposit Evaluator in E2E (#14933 ) * fix evaluator in electra * remove function * Fix evaluator --------- Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com>	2025-02-14 14:59:51 +00:00
Potuz	c248fe0bb3	Add logs for RPC handlers registered/removed at forks (#14932 )	2025-02-14 13:01:01 +00:00
Manu NALEPA	215fbcb2e4	Remove Fulu block and state. (#14905 ) * Remove Fulu block and state. * Add missing tests. * Alias `ProtobufBeaconStateFulu` to `ProtobufBeaconStateElectra`	2025-02-14 10:48:24 +00:00
kasey	e39f44b529	fix path parsing bug on windows (#14931 ) Co-authored-by: Kasey Kirkham <kasey@users.noreply.github.com>	2025-02-14 06:10:58 +00:00
Nishant Das	9eff6ae476	Update Blst to v3.14.0 (#14921 ) * updateBlst * changelog	2025-02-13 14:31:19 +00:00
Nishant Das	3eec5a5cb6	Fix Engine Capabilites Check (#14924 ) * Fix Capabilities Check * Changelog	2025-02-13 13:37:05 +00:00
Preston Van Loon	66878deb2c	Update changelog for v5.3.0 release (#14918 ) * Prysm v5.3.0 changelog update * Add v5.3.0 preamble * Remove experimental feature from suggestions * Changelog fragment	2025-02-12 22:36:34 +00:00
james-prysm	0b6e1711e4	Electra e2e minimal (updates geth to 1.15.0) (#14842 ) * wip electra e2e * add Deneb state to `validatorsParticipating` * Run bazel * add Electra state to `validatorsParticipating` * fixing some e2e issues * more evaluator fixes and changelog * adding in special condition to pass electra epoch participation * fixing typo * missed updating forks for e2e tests * reverting change current release fork * missed updating e2e config for test * updating to latest devnet 5 to fix unit tests * go mod tidy * fixing branch, temporary will need to update geth version later * update to goethereum v1.15.0 * changing changelog to reflect update in geth dependency * fixing test failures * adding fix for range request limit during transition period between forks * enabling validator rest for Electra * rolling back error message * adding fixed change logs * fixing dependencies based on nishant's comments, deps.bzl should be updated not workspace * partially reverting incorrect change * removing fixes from change log, handled in separate prs * removing comment * updating update fraction field to the corrected spec value from prague * Update testing/endtoend/evaluators/fork.go Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com> --------- Co-authored-by: rkapka <radoslaw.kapka@gmail.com> Co-authored-by: terence tsao <terence@prysmaticlabs.com> Co-authored-by: Nishant Das <nishdas93@gmail.com> Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com>	2025-02-12 15:58:06 +00:00