Update CHANGELOG.md

.bazelrc

@@ -22,7 +22,6 @@ coverage --define=coverage_enabled=1
 build --workspace_status_command=./hack/workspace_status.sh
 
 build --define blst_disabled=false
-build --compilation_mode=opt
 run --define blst_disabled=false
 
 build:blst_disabled --define blst_disabled=true

.github/workflows/go.yml

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

.golangci.yml

@@ -6,7 +6,7 @@ run:
     - proto
     - tools/analyzers
   timeout: 10m
-  go: '1.22.6'
+  go: '1.22.3'
 
 linters:
   enable-all: true
@@ -73,7 +73,6 @@ linters:
     - promlinter
     - protogetter
     - revive
-    - spancheck
     - staticcheck
     - stylecheck
     - tagalign

.policy.yml

@@ -26,6 +26,7 @@ approval_rules:
       only_changed_files:
         paths:
           - "*pb.go"
+          - "*pb.gw.go"
           - "*.bazel"
     options:
       ignore_commits_by:
@@ -68,6 +69,7 @@ approval_rules:
       changed_files:
         ignore:
           - "*pb.go"
+          - "*pb.gw.go"
           - "*.bazel"
     options:
       ignore_commits_by:

BUILD.bazel

@@ -55,6 +55,13 @@ alias(
     visibility = ["//visibility:public"],
 )
 
+# Protobuf gRPC gateway compiler
+alias(
+    name = "grpc_gateway_proto_compiler",
+    actual = "@com_github_grpc_ecosystem_grpc_gateway_v2//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
+    visibility = ["//visibility:public"],
+)
+
 gometalinter(
     name = "gometalinter",
     config = "//:.gometalinter.json",

CONTRIBUTING.md

@@ -6,8 +6,7 @@ Excited by our work and want to get involved in building out our sharding releas
 
 You can explore our [Open Issues](https://github.com/prysmaticlabs/prysm/issues) in-the works for our different releases. Feel free to fork our repo and start creating PR’s after assigning yourself to an issue of interest. We are always chatting on [Discord](https://discord.gg/CTYGPUJ) drop us a line there if you want to get more involved or have any questions on our implementation!
 
-> [!IMPORTANT] 
-> Please, **do not send pull requests for trivial changes**, such as typos, these will be rejected. These types of pull requests incur a cost to reviewers and do not provide much value to the project. If you are unsure, please open an issue first to discuss the change.
+Please, do not send pull requests for trivial changes, such as typos, these will be rejected. These types of pull requests incur a cost to reviewers and do not provide much value to the project. If you are unsure, please open an issue first to discuss the change.
 
 ## Contribution Steps
 

WORKSPACE

@@ -101,9 +101,9 @@ http_archive(
 
 http_archive(
     name = "aspect_bazel_lib",
-    sha256 = "a272d79bb0ac6b6965aa199b1f84333413452e87f043b53eca7f347a23a478e8",
-    strip_prefix = "bazel-lib-2.9.3",
-    url = "https://github.com/bazel-contrib/bazel-lib/releases/download/v2.9.3/bazel-lib-v2.9.3.tar.gz",
+    sha256 = "f5ea76682b209cc0bd90d0f5a3b26d2f7a6a2885f0c5f615e72913f4805dbb0d",
+    strip_prefix = "bazel-lib-2.5.0",
+    url = "https://github.com/aspect-build/bazel-lib/releases/download/v2.5.0/bazel-lib-v2.5.0.tar.gz",
 )
 
 load("@aspect_bazel_lib//lib:repositories.bzl", "aspect_bazel_lib_dependencies", "aspect_bazel_lib_register_toolchains")
@@ -165,7 +165,7 @@ load("@rules_oci//oci:pull.bzl", "oci_pull")
 oci_pull(
     name = "linux_debian11_multiarch_base",  # Debian bullseye
     digest = "sha256:b82f113425c5b5c714151aaacd8039bc141821cdcd3c65202d42bdf9c43ae60b",  # 2023-12-12
-    image = "gcr.io/prysmaticlabs/distroless/cc-debian11",
+    image = "gcr.io/distroless/cc-debian11",
     platforms = [
         "linux/amd64",
         "linux/arm64/v8",
@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.8"
+consensus_spec_version = "v1.5.0-alpha.5"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-BsGIbEyJuYrzhShGl0tHhR4lP5Qwno8R3k8a6YBR/DA=",
+    integrity = "sha256-R9vG5HEL5eGMOAmbkKfJ2jfelNqL5V0xBUPiXOiGM6U=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-DkdvhPP2KiqUOpwFXQIFDCWCwsUDIC/xhTBD+TZevm0=",
+    integrity = "sha256-AEIiEOlf1XuxoRMCsN+kgJMo4LrS05+biTA1p/7Ro00=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-vkZqV0HB8A2Uc56C1Us/p5G57iaHL+zw2No93Xt6M/4=",
+    integrity = "sha256-LH/Xr20yrJRYnbpjRGupMWTIOWt3cpxZJWXgThwVDsk=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-D/HPAW61lKqjoWwl7N0XvhdX+67dCEFAy8JxVzqBGtU=",
+    integrity = "sha256-mlytz4MPjKh0DwV7FMiAtnRbJw9B6o78/x66/vmnYc8=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -342,22 +342,6 @@ filegroup(
     url = "https://github.com/eth-clients/holesky/archive/874c199423ccd180607320c38cbaca05d9a1573a.tar.gz",  # 2024-06-18
 )
 
-http_archive(
-    name = "sepolia_testnet",
-    build_file_content = """
-filegroup(
-    name = "configs",
-    srcs = [
-        "metadata/config.yaml",
-    ],
-    visibility = ["//visibility:public"],
-)
-""",
-    integrity = "sha256-cY/UgpCcYEhQf7JefD65FI8tn/A+rAvKhcm2/qiVdqY=",
-    strip_prefix = "sepolia-f2c219a93c4491cee3d90c18f2f8e82aed850eab",
-    url = "https://github.com/eth-clients/sepolia/archive/f2c219a93c4491cee3d90c18f2f8e82aed850eab.tar.gz",  # 2024-09-19
-)
-
 http_archive(
     name = "com_google_protobuf",
     sha256 = "9bd87b8280ef720d3240514f884e56a712f2218f0d693b48050c836028940a42",

api/client/builder/BUILD.bazel

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

api/client/builder/client.go

@@ -19,11 +19,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 const (
@@ -146,7 +146,7 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 
 	u := c.baseURL.ResolveReference(&url.URL{Path: path})
 
-	span.SetAttributes(trace.StringAttribute("url", u.String()),
+	span.AddAttributes(trace.StringAttribute("url", u.String()),
 		trace.StringAttribute("method", method))
 
 	req, err := http.NewRequestWithContext(ctx, method, u.String(), body)
@@ -259,7 +259,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error {
 	ctx, span := trace.StartSpan(ctx, "builder.client.RegisterValidator")
 	defer span.End()
-	span.SetAttributes(trace.Int64Attribute("num_reqs", int64(len(svr))))
+	span.AddAttributes(trace.Int64Attribute("num_reqs", int64(len(svr))))
 
 	if len(svr) == 0 {
 		err := errors.Wrap(errMalformedRequest, "empty validator registration list")
@@ -278,11 +278,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 	}
 
 	_, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body))
-	if err != nil {
-		return err
-	}
-	log.WithField("num_registrations", len(svr)).Info("successfully registered validator(s) on builder")
-	return nil
+	return err
 }
 
 var errResponseVersionMismatch = errors.New("builder API response uses a different version than requested in " + api.VersionHeader + " header")

api/client/event/event_stream.go

@@ -93,7 +93,6 @@ func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
 			EventType: EventConnectionError,
 			Data:      []byte(errors.Wrap(err, client.ErrConnectionIssue.Error()).Error()),
 		}
-		return
 	}
 
 	defer func() {

api/client/event/event_stream_test.go

@@ -40,7 +40,7 @@ func TestNewEventStream(t *testing.T) {
 
 func TestEventStream(t *testing.T) {
 	mux := http.NewServeMux()
-	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, _ *http.Request) {
+	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
 		flusher, ok := w.(http.Flusher)
 		require.Equal(t, true, ok)
 		for i := 1; i <= 3; i++ {
@@ -79,23 +79,3 @@ func TestEventStream(t *testing.T) {
 		}
 	}
 }
-
-func TestEventStreamRequestError(t *testing.T) {
-	topics := []string{"head"}
-	eventsChannel := make(chan *Event, 1)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// use valid url that will result in failed request with nil body
-	stream, err := NewEventStream(ctx, http.DefaultClient, "http://badhost:1234", topics)
-	require.NoError(t, err)
-
-	// error will happen when request is made, should be received over events channel
-	go stream.Subscribe(eventsChannel)
-
-	event := <-eventsChannel
-	if event.EventType != EventConnectionError {
-		t.Errorf("Expected event type %q, got %q", EventConnectionError, event.EventType)
-	}
-
-}

api/gateway/BUILD.bazel

@@ -0,0 +1,43 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "gateway.go",
+        "log.go",
+        "modifiers.go",
+        "options.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/api/gateway",
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//validator:__subpackages__",
+    ],
+    deps = [
+        "//api/server/middleware:go_default_library",
+        "//runtime:go_default_library",
+        "@com_github_gorilla_mux//:go_default_library",
+        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_google_grpc//connectivity:go_default_library",
+        "@org_golang_google_grpc//credentials:go_default_library",
+        "@org_golang_google_grpc//credentials/insecure:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["gateway_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//cmd/beacon-chain/flags:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "@com_github_gorilla_mux//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@com_github_urfave_cli_v2//:go_default_library",
+    ],
+)

api/gateway/gateway.go

@@ -0,0 +1,212 @@
+// Package gateway defines a grpc-gateway server that serves HTTP-JSON traffic and acts a proxy between HTTP and gRPC.
+package gateway
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/gorilla/mux"
+	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
+	"github.com/prysmaticlabs/prysm/v5/runtime"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+var _ runtime.Service = (*Gateway)(nil)
+
+// PbMux serves grpc-gateway requests for selected patterns using registered protobuf handlers.
+type PbMux struct {
+	Registrations []PbHandlerRegistration // Protobuf registrations to be registered in Mux.
+	Patterns      []string                // URL patterns that will be handled by Mux.
+	Mux           *gwruntime.ServeMux     // The router that will be used for grpc-gateway requests.
+}
+
+// PbHandlerRegistration is a function that registers a protobuf handler.
+type PbHandlerRegistration func(context.Context, *gwruntime.ServeMux, *grpc.ClientConn) error
+
+// MuxHandler is a function that implements the mux handler functionality.
+type MuxHandler func(
+	h http.HandlerFunc,
+	w http.ResponseWriter,
+	req *http.Request,
+)
+
+// Config parameters for setting up the gateway service.
+type config struct {
+	maxCallRecvMsgSize uint64
+	remoteCert         string
+	gatewayAddr        string
+	remoteAddr         string
+	allowedOrigins     []string
+	muxHandler         MuxHandler
+	pbHandlers         []*PbMux
+	router             *mux.Router
+	timeout            time.Duration
+}
+
+// Gateway is the gRPC gateway to serve HTTP JSON traffic as a proxy and forward it to the gRPC server.
+type Gateway struct {
+	cfg          *config
+	conn         *grpc.ClientConn
+	server       *http.Server
+	cancel       context.CancelFunc
+	ctx          context.Context
+	startFailure error
+}
+
+// New returns a new instance of the Gateway.
+func New(ctx context.Context, opts ...Option) (*Gateway, error) {
+	g := &Gateway{
+		ctx: ctx,
+		cfg: &config{},
+	}
+	for _, opt := range opts {
+		if err := opt(g); err != nil {
+			return nil, err
+		}
+	}
+	if g.cfg.router == nil {
+		g.cfg.router = mux.NewRouter()
+	}
+	return g, nil
+}
+
+// Start the gateway service.
+func (g *Gateway) Start() {
+	ctx, cancel := context.WithCancel(g.ctx)
+	g.cancel = cancel
+
+	conn, err := g.dial(ctx, "tcp", g.cfg.remoteAddr)
+	if err != nil {
+		log.WithError(err).Error("Failed to connect to gRPC server")
+		g.startFailure = err
+		return
+	}
+	g.conn = conn
+
+	for _, h := range g.cfg.pbHandlers {
+		for _, r := range h.Registrations {
+			if err := r(ctx, h.Mux, g.conn); err != nil {
+				log.WithError(err).Error("Failed to register handler")
+				g.startFailure = err
+				return
+			}
+		}
+		for _, p := range h.Patterns {
+			g.cfg.router.PathPrefix(p).Handler(h.Mux)
+		}
+	}
+
+	corsMux := middleware.CorsHandler(g.cfg.allowedOrigins).Middleware(g.cfg.router)
+
+	if g.cfg.muxHandler != nil {
+		g.cfg.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			g.cfg.muxHandler(corsMux.ServeHTTP, w, r)
+		})
+	}
+
+	g.server = &http.Server{
+		Addr:              g.cfg.gatewayAddr,
+		Handler:           corsMux,
+		ReadHeaderTimeout: time.Second,
+	}
+
+	go func() {
+		log.WithField("address", g.cfg.gatewayAddr).Info("Starting gRPC gateway")
+		if err := g.server.ListenAndServe(); err != http.ErrServerClosed {
+			log.WithError(err).Error("Failed to start gRPC gateway")
+			g.startFailure = err
+			return
+		}
+	}()
+}
+
+// Status of grpc gateway. Returns an error if this service is unhealthy.
+func (g *Gateway) Status() error {
+	if g.startFailure != nil {
+		return g.startFailure
+	}
+	if s := g.conn.GetState(); s != connectivity.Ready {
+		return fmt.Errorf("grpc server is %s", s)
+	}
+	return nil
+}
+
+// Stop the gateway with a graceful shutdown.
+func (g *Gateway) Stop() error {
+	if g.server != nil {
+		shutdownCtx, shutdownCancel := context.WithTimeout(g.ctx, 2*time.Second)
+		defer shutdownCancel()
+		if err := g.server.Shutdown(shutdownCtx); err != nil {
+			if errors.Is(err, context.DeadlineExceeded) {
+				log.Warn("Existing connections terminated")
+			} else {
+				log.WithError(err).Error("Failed to gracefully shut down server")
+			}
+		}
+	}
+	if g.cancel != nil {
+		g.cancel()
+	}
+	return nil
+}
+
+// dial the gRPC server.
+func (g *Gateway) dial(ctx context.Context, network, addr string) (*grpc.ClientConn, error) {
+	switch network {
+	case "tcp":
+		return g.dialTCP(ctx, addr)
+	case "unix":
+		return g.dialUnix(ctx, addr)
+	default:
+		return nil, fmt.Errorf("unsupported network type %q", network)
+	}
+}
+
+// dialTCP creates a client connection via TCP.
+// "addr" must be a valid TCP address with a port number.
+func (g *Gateway) dialTCP(ctx context.Context, addr string) (*grpc.ClientConn, error) {
+	var security grpc.DialOption
+	if len(g.cfg.remoteCert) > 0 {
+		creds, err := credentials.NewClientTLSFromFile(g.cfg.remoteCert, "")
+		if err != nil {
+			return nil, err
+		}
+		security = grpc.WithTransportCredentials(creds)
+	} else {
+		// Use insecure credentials when there's no remote cert provided.
+		security = grpc.WithTransportCredentials(insecure.NewCredentials())
+	}
+	opts := []grpc.DialOption{
+		security,
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
+	}
+	return grpc.DialContext(ctx, addr, opts...)
+}
+
+// dialUnix creates a client connection via a unix domain socket.
+// "addr" must be a valid path to the socket.
+func (g *Gateway) dialUnix(ctx context.Context, addr string) (*grpc.ClientConn, error) {
+	d := func(addr string, timeout time.Duration) (net.Conn, error) {
+		return net.DialTimeout("unix", addr, timeout)
+	}
+	f := func(ctx context.Context, addr string) (net.Conn, error) {
+		if deadline, ok := ctx.Deadline(); ok {
+			return d(addr, time.Until(deadline))
+		}
+		return d(addr, 0)
+	}
+	opts := []grpc.DialOption{
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithContextDialer(f),
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
+	}
+	return grpc.DialContext(ctx, addr, opts...)
+}

api/gateway/gateway_test.go

@@ -0,0 +1,107 @@
+package gateway
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
+	"github.com/prysmaticlabs/prysm/v5/testing/assert"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/urfave/cli/v2"
+)
+
+func TestGateway_Customized(t *testing.T) {
+	r := mux.NewRouter()
+	cert := "cert"
+	origins := []string{"origin"}
+	size := uint64(100)
+
+	opts := []Option{
+		WithRouter(r),
+		WithRemoteCert(cert),
+		WithAllowedOrigins(origins),
+		WithMaxCallRecvMsgSize(size),
+		WithMuxHandler(func(
+			_ http.HandlerFunc,
+			_ http.ResponseWriter,
+			_ *http.Request,
+		) {
+		}),
+	}
+
+	g, err := New(context.Background(), opts...)
+	require.NoError(t, err)
+
+	assert.Equal(t, r, g.cfg.router)
+	assert.Equal(t, cert, g.cfg.remoteCert)
+	require.Equal(t, 1, len(g.cfg.allowedOrigins))
+	assert.Equal(t, origins[0], g.cfg.allowedOrigins[0])
+	assert.Equal(t, size, g.cfg.maxCallRecvMsgSize)
+}
+
+func TestGateway_StartStop(t *testing.T) {
+	hook := logTest.NewGlobal()
+
+	app := cli.App{}
+	set := flag.NewFlagSet("test", 0)
+	ctx := cli.NewContext(&app, set, nil)
+
+	gatewayPort := ctx.Int(flags.GRPCGatewayPort.Name)
+	gatewayHost := ctx.String(flags.GRPCGatewayHost.Name)
+	rpcHost := ctx.String(flags.RPCHost.Name)
+	selfAddress := fmt.Sprintf("%s:%d", rpcHost, ctx.Int(flags.RPCPort.Name))
+	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
+
+	opts := []Option{
+		WithGatewayAddr(gatewayAddress),
+		WithRemoteAddr(selfAddress),
+		WithMuxHandler(func(
+			_ http.HandlerFunc,
+			_ http.ResponseWriter,
+			_ *http.Request,
+		) {
+		}),
+	}
+
+	g, err := New(context.Background(), opts...)
+	require.NoError(t, err)
+
+	g.Start()
+	go func() {
+		require.LogsContain(t, hook, "Starting gRPC gateway")
+		require.LogsDoNotContain(t, hook, "Starting API middleware")
+	}()
+	err = g.Stop()
+	require.NoError(t, err)
+}
+
+func TestGateway_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
+	app := cli.App{}
+	set := flag.NewFlagSet("test", 0)
+	ctx := cli.NewContext(&app, set, nil)
+
+	gatewayPort := ctx.Int(flags.GRPCGatewayPort.Name)
+	gatewayHost := ctx.String(flags.GRPCGatewayHost.Name)
+	rpcHost := ctx.String(flags.RPCHost.Name)
+	selfAddress := fmt.Sprintf("%s:%d", rpcHost, ctx.Int(flags.RPCPort.Name))
+	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
+
+	opts := []Option{
+		WithGatewayAddr(gatewayAddress),
+		WithRemoteAddr(selfAddress),
+	}
+
+	g, err := New(context.Background(), opts...)
+	require.NoError(t, err)
+
+	writer := httptest.NewRecorder()
+	g.cfg.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
+	assert.Equal(t, http.StatusNotFound, writer.Code)
+}

api/gateway/log.go

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

api/gateway/modifiers.go

@@ -0,0 +1,30 @@
+package gateway
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"google.golang.org/protobuf/proto"
+)
+
+func HttpResponseModifier(ctx context.Context, w http.ResponseWriter, _ proto.Message) error {
+	md, ok := gwruntime.ServerMetadataFromContext(ctx)
+	if !ok {
+		return nil
+	}
+	// set http status code
+	if vals := md.HeaderMD.Get("x-http-code"); len(vals) > 0 {
+		code, err := strconv.Atoi(vals[0])
+		if err != nil {
+			return err
+		}
+		// delete the headers to not expose any grpc-metadata in http response
+		delete(md.HeaderMD, "x-http-code")
+		delete(w.Header(), "Grpc-Metadata-X-Http-Code")
+		w.WriteHeader(code)
+	}
+
+	return nil
+}

api/gateway/options.go

@@ -0,0 +1,79 @@
+package gateway
+
+import (
+	"time"
+
+	"github.com/gorilla/mux"
+	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+)
+
+type Option func(g *Gateway) error
+
+func WithPbHandlers(handlers []*PbMux) Option {
+	return func(g *Gateway) error {
+		g.cfg.pbHandlers = handlers
+		return nil
+	}
+}
+
+func WithMuxHandler(m MuxHandler) Option {
+	return func(g *Gateway) error {
+		g.cfg.muxHandler = m
+		return nil
+	}
+}
+
+func WithGatewayAddr(addr string) Option {
+	return func(g *Gateway) error {
+		g.cfg.gatewayAddr = addr
+		return nil
+	}
+}
+
+func WithRemoteAddr(addr string) Option {
+	return func(g *Gateway) error {
+		g.cfg.remoteAddr = addr
+		return nil
+	}
+}
+
+// WithRouter allows adding a custom mux router to the gateway.
+func WithRouter(r *mux.Router) Option {
+	return func(g *Gateway) error {
+		g.cfg.router = r
+		return nil
+	}
+}
+
+// WithAllowedOrigins allows adding a set of allowed origins to the gateway.
+func WithAllowedOrigins(origins []string) Option {
+	return func(g *Gateway) error {
+		g.cfg.allowedOrigins = origins
+		return nil
+	}
+}
+
+// WithRemoteCert allows adding a custom certificate to the gateway,
+func WithRemoteCert(cert string) Option {
+	return func(g *Gateway) error {
+		g.cfg.remoteCert = cert
+		return nil
+	}
+}
+
+// WithMaxCallRecvMsgSize allows specifying the maximum allowed gRPC message size.
+func WithMaxCallRecvMsgSize(size uint64) Option {
+	return func(g *Gateway) error {
+		g.cfg.maxCallRecvMsgSize = size
+		return nil
+	}
+}
+
+// WithTimeout allows changing the timeout value for API calls.
+func WithTimeout(seconds uint64) Option {
+	return func(g *Gateway) error {
+		g.cfg.timeout = time.Second * time.Duration(seconds)
+		gwruntime.DefaultContextTimeout = time.Second * time.Duration(seconds)
+		return nil
+	}
+}

api/grpc/BUILD.bazel

@@ -22,7 +22,9 @@ go_test(
     deps = [
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
     ],
 )

api/grpc/grpcutils.go

@@ -2,6 +2,8 @@ package grpc
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"strings"
 	"time"
 
@@ -79,3 +81,16 @@ func AppendHeaders(parent context.Context, headers []string) context.Context {
 	}
 	return parent
 }
+
+// AppendCustomErrorHeader sets a CustomErrorMetadataKey gRPC header on the passed in context,
+// using the passed in error data as the header's value. The data is serialized as JSON.
+func AppendCustomErrorHeader(ctx context.Context, errorData interface{}) error {
+	j, err := json.Marshal(errorData)
+	if err != nil {
+		return fmt.Errorf("could not marshal error data into JSON: %w", err)
+	}
+	if err := grpc.SetHeader(ctx, metadata.Pairs(CustomErrorMetadataKey, string(j))); err != nil {
+		return fmt.Errorf("could not set custom error header: %w", err)
+	}
+	return nil
+}

api/grpc/grpcutils_test.go

@@ -2,11 +2,15 @@ package grpc
 
 import (
 	"context"
+	"encoding/json"
+	"strings"
 	"testing"
 
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
+	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 )
 
@@ -58,3 +62,17 @@ func TestAppendHeaders(t *testing.T) {
 		assert.Equal(t, "value=1", md.Get("first")[0])
 	})
 }
+
+func TestAppendCustomErrorHeader(t *testing.T) {
+	stream := &runtime.ServerTransportStream{}
+	ctx := grpc.NewContextWithServerTransportStream(context.Background(), stream)
+	data := &customErrorData{Message: "foo"}
+	require.NoError(t, AppendCustomErrorHeader(ctx, data))
+	// The stream used in test setup sets the metadata key in lowercase.
+	value, ok := stream.Header()[strings.ToLower(CustomErrorMetadataKey)]
+	require.Equal(t, true, ok, "Failed to retrieve custom error metadata value")
+	expected, err := json.Marshal(data)
+	require.NoError(t, err)
+	assert.Equal(t, string(expected), value[0])
+
+}

api/headers.go

@@ -1,7 +1,5 @@
 package api
 
-import "net/http"
-
 const (
 	VersionHeader                 = "Eth-Consensus-Version"
 	ExecutionPayloadBlindedHeader = "Eth-Execution-Payload-Blinded"
@@ -12,9 +10,3 @@ const (
 	EventStreamMediaType          = "text/event-stream"
 	KeepAlive                     = "keep-alive"
 )
-
-// SetSSEHeaders sets the headers needed for a server-sent event response.
-func SetSSEHeaders(w http.ResponseWriter) {
-	w.Header().Set("Content-Type", EventStreamMediaType)
-	w.Header().Set("Connection", KeepAlive)
-}

api/server/httprest/BUILD.bazel

@@ -1,31 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "log.go",
-        "options.go",
-        "server.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v5/api/server/httprest",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api/server/middleware:go_default_library",
-        "//runtime:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["server_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//cmd/beacon-chain/flags:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@com_github_urfave_cli_v2//:go_default_library",
-    ],
-)

api/server/httprest/log.go

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

api/server/httprest/options.go

@@ -1,44 +0,0 @@
-package httprest
-
-import (
-	"time"
-
-	"net/http"
-
-	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
-)
-
-// Option is a http rest server functional parameter type.
-type Option func(g *Server) error
-
-// WithMiddlewares sets the list of middlewares to be applied on routes.
-func WithMiddlewares(mw []middleware.Middleware) Option {
-	return func(g *Server) error {
-		g.cfg.middlewares = mw
-		return nil
-	}
-}
-
-// WithHTTPAddr sets the full address ( host and port ) of the server.
-func WithHTTPAddr(addr string) Option {
-	return func(g *Server) error {
-		g.cfg.httpAddr = addr
-		return nil
-	}
-}
-
-// WithRouter sets the internal router of the server, this is required.
-func WithRouter(r *http.ServeMux) Option {
-	return func(g *Server) error {
-		g.cfg.router = r
-		return nil
-	}
-}
-
-// WithTimeout allows changing the timeout value for API calls.
-func WithTimeout(duration time.Duration) Option {
-	return func(g *Server) error {
-		g.cfg.timeout = duration
-		return nil
-	}
-}

api/server/httprest/server.go

@@ -1,101 +0,0 @@
-package httprest
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
-	"github.com/prysmaticlabs/prysm/v5/runtime"
-)
-
-var _ runtime.Service = (*Server)(nil)
-
-// Config parameters for setting up the http-rest service.
-type config struct {
-	httpAddr    string
-	middlewares []middleware.Middleware
-	router      http.Handler
-	timeout     time.Duration
-}
-
-// Server serves HTTP traffic.
-type Server struct {
-	cfg          *config
-	server       *http.Server
-	cancel       context.CancelFunc
-	ctx          context.Context
-	startFailure error
-}
-
-// New returns a new instance of the Server.
-func New(ctx context.Context, opts ...Option) (*Server, error) {
-	g := &Server{
-		ctx: ctx,
-		cfg: &config{},
-	}
-	for _, opt := range opts {
-		if err := opt(g); err != nil {
-			return nil, err
-		}
-	}
-	if g.cfg.router == nil {
-		return nil, errors.New("router option not configured")
-	}
-	var handler http.Handler
-	defaultReadHeaderTimeout := time.Second
-	handler = middleware.MiddlewareChain(g.cfg.router, g.cfg.middlewares)
-	if g.cfg.timeout > 0*time.Second {
-		defaultReadHeaderTimeout = g.cfg.timeout
-		handler = http.TimeoutHandler(handler, g.cfg.timeout, "request timed out")
-	}
-	g.server = &http.Server{
-		Addr:              g.cfg.httpAddr,
-		Handler:           handler,
-		ReadHeaderTimeout: defaultReadHeaderTimeout,
-	}
-
-	return g, nil
-}
-
-// Start the http rest service.
-func (g *Server) Start() {
-	g.ctx, g.cancel = context.WithCancel(g.ctx)
-
-	go func() {
-		log.WithField("address", g.cfg.httpAddr).Info("Starting HTTP server")
-		if err := g.server.ListenAndServe(); err != http.ErrServerClosed {
-			log.WithError(err).Error("Failed to start HTTP server")
-			g.startFailure = err
-			return
-		}
-	}()
-}
-
-// Status of the HTTP server. Returns an error if this service is unhealthy.
-func (g *Server) Status() error {
-	if g.startFailure != nil {
-		return g.startFailure
-	}
-	return nil
-}
-
-// Stop the HTTP server with a graceful shutdown.
-func (g *Server) Stop() error {
-	if g.server != nil {
-		shutdownCtx, shutdownCancel := context.WithTimeout(g.ctx, 2*time.Second)
-		defer shutdownCancel()
-		if err := g.server.Shutdown(shutdownCtx); err != nil {
-			if errors.Is(err, context.DeadlineExceeded) {
-				log.Warn("Existing connections terminated")
-			} else {
-				log.WithError(err).Error("Failed to gracefully shut down server")
-			}
-		}
-	}
-	if g.cancel != nil {
-		g.cancel()
-	}
-	return nil
-}

api/server/httprest/server_test.go

@@ -1,71 +0,0 @@
-package httprest
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-	"github.com/urfave/cli/v2"
-)
-
-func TestServer_StartStop(t *testing.T) {
-	hook := logTest.NewGlobal()
-
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ctx := cli.NewContext(&app, set, nil)
-
-	port := ctx.Int(flags.HTTPServerPort.Name)
-	portStr := fmt.Sprintf("%d", port) // Convert port to string
-	host := ctx.String(flags.HTTPServerHost.Name)
-	address := net.JoinHostPort(host, portStr)
-	handler := http.NewServeMux()
-	opts := []Option{
-		WithHTTPAddr(address),
-		WithRouter(handler),
-	}
-
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
-
-	g.Start()
-	go func() {
-		require.LogsContain(t, hook, "Starting HTTP server")
-		require.LogsDoNotContain(t, hook, "Starting API middleware")
-	}()
-	err = g.Stop()
-	require.NoError(t, err)
-}
-
-func TestServer_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ctx := cli.NewContext(&app, set, nil)
-
-	handler := http.NewServeMux()
-	port := ctx.Int(flags.HTTPServerPort.Name)
-	portStr := fmt.Sprintf("%d", port) // Convert port to string
-	host := ctx.String(flags.HTTPServerHost.Name)
-	address := net.JoinHostPort(host, portStr)
-
-	opts := []Option{
-		WithHTTPAddr(address),
-		WithRouter(handler),
-	}
-
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
-
-	writer := httptest.NewRecorder()
-	g.cfg.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
-	assert.Equal(t, http.StatusNotFound, writer.Code)
-}

api/server/middleware/BUILD.bazel

@@ -8,7 +8,10 @@ go_library(
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/server/middleware",
     visibility = ["//visibility:public"],
-    deps = ["@com_github_rs_cors//:go_default_library"],
+    deps = [
+        "@com_github_gorilla_mux//:go_default_library",
+        "@com_github_rs_cors//:go_default_library",
+    ],
 )
 
 go_test(

api/server/middleware/middleware.go

@@ -5,11 +5,10 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/gorilla/mux"
 	"github.com/rs/cors"
 )
 
-type Middleware func(http.Handler) http.Handler
-
 // NormalizeQueryValuesHandler normalizes an input query of "key=value1,value2,value3" to "key=value1&key=value2&key=value3"
 func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -22,7 +21,7 @@ func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
 }
 
 // CorsHandler sets the cors settings on api endpoints
-func CorsHandler(allowOrigins []string) Middleware {
+func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
 	c := cors.New(cors.Options{
 		AllowedOrigins:   allowOrigins,
 		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
@@ -35,7 +34,7 @@ func CorsHandler(allowOrigins []string) Middleware {
 }
 
 // ContentTypeHandler checks request for the appropriate media types otherwise returning a http.StatusUnsupportedMediaType error
-func ContentTypeHandler(acceptedMediaTypes []string) Middleware {
+func ContentTypeHandler(acceptedMediaTypes []string) mux.MiddlewareFunc {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			// skip the GET request
@@ -68,7 +67,7 @@ func ContentTypeHandler(acceptedMediaTypes []string) Middleware {
 }
 
 // AcceptHeaderHandler checks if the client's response preference is handled
-func AcceptHeaderHandler(serverAcceptedTypes []string) Middleware {
+func AcceptHeaderHandler(serverAcceptedTypes []string) mux.MiddlewareFunc {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			acceptHeader := r.Header.Get("Accept")
@@ -111,15 +110,3 @@ func AcceptHeaderHandler(serverAcceptedTypes []string) Middleware {
 		})
 	}
 }
-
-func MiddlewareChain(h http.Handler, mw []Middleware) http.Handler {
-	if len(mw) < 1 {
-		return h
-	}
-
-	wrapped := h
-	for i := len(mw) - 1; i >= 0; i-- {
-		wrapped = mw[i](wrapped)
-	}
-	return wrapped
-}

api/server/structs/BUILD.bazel

@@ -5,9 +5,7 @@ go_library(
     srcs = [
         "block.go",
         "conversions.go",
-        "conversions_blob.go",
         "conversions_block.go",
-        "conversions_lightclient.go",
         "conversions_state.go",
         "endpoints_beacon.go",
         "endpoints_blob.go",
@@ -35,9 +33,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
-        "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
-        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

api/server/structs/block.go

@@ -365,7 +365,6 @@ type BeaconBlockBodyElectra struct {
 	ExecutionPayload      *ExecutionPayloadElectra      `json:"execution_payload"`
 	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
 	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
-	ExecutionRequests     *ExecutionRequests            `json:"execution_requests"`
 }
 
 type BlindedBeaconBlockElectra struct {
@@ -404,7 +403,6 @@ type BlindedBeaconBlockBodyElectra struct {
 	ExecutionPayloadHeader *ExecutionPayloadHeaderElectra `json:"execution_payload_header"`
 	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
 	BlobKzgCommitments     []string                       `json:"blob_kzg_commitments"`
-	ExecutionRequests      *ExecutionRequests             `json:"execution_requests"`
 }
 
 type SignedBeaconBlockHeaderContainer struct {
@@ -516,8 +514,6 @@ type ExecutionPayloadDeneb struct {
 	ExcessBlobGas string        `json:"excess_blob_gas"`
 }
 
-type ExecutionPayloadElectra = ExecutionPayloadDeneb
-
 type ExecutionPayloadHeaderDeneb struct {
 	ParentHash       string `json:"parent_hash"`
 	FeeRecipient     string `json:"fee_recipient"`
@@ -538,10 +534,48 @@ type ExecutionPayloadHeaderDeneb struct {
 	ExcessBlobGas    string `json:"excess_blob_gas"`
 }
 
-type ExecutionPayloadHeaderElectra = ExecutionPayloadHeaderDeneb
-
-type ExecutionRequests struct {
-	Deposits       []*DepositRequest       `json:"deposits"`
-	Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
-	Consolidations []*ConsolidationRequest `json:"consolidations"`
+type ExecutionPayloadElectra struct {
+	ParentHash            string                  `json:"parent_hash"`
+	FeeRecipient          string                  `json:"fee_recipient"`
+	StateRoot             string                  `json:"state_root"`
+	ReceiptsRoot          string                  `json:"receipts_root"`
+	LogsBloom             string                  `json:"logs_bloom"`
+	PrevRandao            string                  `json:"prev_randao"`
+	BlockNumber           string                  `json:"block_number"`
+	GasLimit              string                  `json:"gas_limit"`
+	GasUsed               string                  `json:"gas_used"`
+	Timestamp             string                  `json:"timestamp"`
+	ExtraData             string                  `json:"extra_data"`
+	BaseFeePerGas         string                  `json:"base_fee_per_gas"`
+	BlockHash             string                  `json:"block_hash"`
+	Transactions          []string                `json:"transactions"`
+	Withdrawals           []*Withdrawal           `json:"withdrawals"`
+	BlobGasUsed           string                  `json:"blob_gas_used"`
+	ExcessBlobGas         string                  `json:"excess_blob_gas"`
+	DepositRequests       []*DepositRequest       `json:"deposit_requests"`
+	WithdrawalRequests    []*WithdrawalRequest    `json:"withdrawal_requests"`
+	ConsolidationRequests []*ConsolidationRequest `json:"consolidation_requests"`
+}
+
+type ExecutionPayloadHeaderElectra struct {
+	ParentHash                string `json:"parent_hash"`
+	FeeRecipient              string `json:"fee_recipient"`
+	StateRoot                 string `json:"state_root"`
+	ReceiptsRoot              string `json:"receipts_root"`
+	LogsBloom                 string `json:"logs_bloom"`
+	PrevRandao                string `json:"prev_randao"`
+	BlockNumber               string `json:"block_number"`
+	GasLimit                  string `json:"gas_limit"`
+	GasUsed                   string `json:"gas_used"`
+	Timestamp                 string `json:"timestamp"`
+	ExtraData                 string `json:"extra_data"`
+	BaseFeePerGas             string `json:"base_fee_per_gas"`
+	BlockHash                 string `json:"block_hash"`
+	TransactionsRoot          string `json:"transactions_root"`
+	WithdrawalsRoot           string `json:"withdrawals_root"`
+	BlobGasUsed               string `json:"blob_gas_used"`
+	ExcessBlobGas             string `json:"excess_blob_gas"`
+	DepositRequestsRoot       string `json:"deposit_requests_root"`
+	WithdrawalRequestsRoot    string `json:"withdrawal_requests_root"`
+	ConsolidationRequestsRoot string `json:"consolidation_requests_root"`
 }

api/server/structs/conversions.go

@@ -15,7 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -1476,15 +1475,12 @@ func DepositSnapshotFromConsensus(ds *eth.DepositSnapshot) *DepositSnapshot {
 	}
 }
 
-func PendingDepositsFromConsensus(ds []*eth.PendingDeposit) []*PendingDeposit {
-	deposits := make([]*PendingDeposit, len(ds))
+func PendingBalanceDepositsFromConsensus(ds []*eth.PendingBalanceDeposit) []*PendingBalanceDeposit {
+	deposits := make([]*PendingBalanceDeposit, len(ds))
 	for i, d := range ds {
-		deposits[i] = &PendingDeposit{
-			Pubkey:                hexutil.Encode(d.PublicKey),
-			WithdrawalCredentials: hexutil.Encode(d.WithdrawalCredentials),
-			Amount:                fmt.Sprintf("%d", d.Amount),
-			Signature:             hexutil.Encode(d.Signature),
-			Slot:                  fmt.Sprintf("%d", d.Slot),
+		deposits[i] = &PendingBalanceDeposit{
+			Index:  fmt.Sprintf("%d", d.Index),
+			Amount: fmt.Sprintf("%d", d.Amount),
 		}
 	}
 	return deposits
@@ -1512,37 +1508,3 @@ func PendingConsolidationsFromConsensus(cs []*eth.PendingConsolidation) []*Pendi
 	}
 	return consolidations
 }
-
-func HeadEventFromV1(event *ethv1.EventHead) *HeadEvent {
-	return &HeadEvent{
-		Slot:                      fmt.Sprintf("%d", event.Slot),
-		Block:                     hexutil.Encode(event.Block),
-		State:                     hexutil.Encode(event.State),
-		EpochTransition:           event.EpochTransition,
-		ExecutionOptimistic:       event.ExecutionOptimistic,
-		PreviousDutyDependentRoot: hexutil.Encode(event.PreviousDutyDependentRoot),
-		CurrentDutyDependentRoot:  hexutil.Encode(event.CurrentDutyDependentRoot),
-	}
-}
-
-func FinalizedCheckpointEventFromV1(event *ethv1.EventFinalizedCheckpoint) *FinalizedCheckpointEvent {
-	return &FinalizedCheckpointEvent{
-		Block:               hexutil.Encode(event.Block),
-		State:               hexutil.Encode(event.State),
-		Epoch:               fmt.Sprintf("%d", event.Epoch),
-		ExecutionOptimistic: event.ExecutionOptimistic,
-	}
-}
-
-func EventChainReorgFromV1(event *ethv1.EventChainReorg) *ChainReorgEvent {
-	return &ChainReorgEvent{
-		Slot:                fmt.Sprintf("%d", event.Slot),
-		Depth:               fmt.Sprintf("%d", event.Depth),
-		OldHeadBlock:        hexutil.Encode(event.OldHeadBlock),
-		NewHeadBlock:        hexutil.Encode(event.NewHeadBlock),
-		OldHeadState:        hexutil.Encode(event.OldHeadState),
-		NewHeadState:        hexutil.Encode(event.NewHeadState),
-		Epoch:               fmt.Sprintf("%d", event.Epoch),
-		ExecutionOptimistic: event.ExecutionOptimistic,
-	}
-}

api/server/structs/conversions_blob.go

@@ -1,61 +0,0 @@
-package structs
-
-import (
-	"strconv"
-
-	"github.com/prysmaticlabs/prysm/v5/api/server"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-)
-
-func (sc *Sidecar) ToConsensus() (*eth.BlobSidecar, error) {
-	if sc == nil {
-		return nil, errNilValue
-	}
-
-	index, err := strconv.ParseUint(sc.Index, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Index")
-	}
-
-	blob, err := bytesutil.DecodeHexWithLength(sc.Blob, 131072)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Blob")
-	}
-
-	kzgCommitment, err := bytesutil.DecodeHexWithLength(sc.KzgCommitment, 48)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "KzgCommitment")
-	}
-
-	kzgProof, err := bytesutil.DecodeHexWithLength(sc.KzgProof, 48)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "KzgProof")
-	}
-
-	header, err := sc.SignedBeaconBlockHeader.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SignedBeaconBlockHeader")
-	}
-
-	// decode the commitment inclusion proof
-	var commitmentInclusionProof [][]byte
-	for _, proof := range sc.CommitmentInclusionProof {
-		proofBytes, err := bytesutil.DecodeHexWithLength(proof, 32)
-		if err != nil {
-			return nil, server.NewDecodeError(err, "CommitmentInclusionProof")
-		}
-		commitmentInclusionProof = append(commitmentInclusionProof, proofBytes)
-	}
-
-	bsc := &eth.BlobSidecar{
-		Index:                    index,
-		Blob:                     blob,
-		KzgCommitment:            kzgCommitment,
-		KzgProof:                 kzgProof,
-		SignedBlockHeader:        header,
-		CommitmentInclusionProof: commitmentInclusionProof,
-	}
-
-	return bsc, nil
-}

api/server/structs/conversions_block.go

@@ -20,9 +20,6 @@ import (
 var ErrUnsupportedConversion = errors.New("Could not determine api struct type to use for value")
 
 func (h *SignedBeaconBlockHeader) ToConsensus() (*eth.SignedBeaconBlockHeader, error) {
-	if h == nil {
-		return nil, errNilValue
-	}
 	msg, err := h.Message.ToConsensus()
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Message")
@@ -39,9 +36,6 @@ func (h *SignedBeaconBlockHeader) ToConsensus() (*eth.SignedBeaconBlockHeader, e
 }
 
 func (h *BeaconBlockHeader) ToConsensus() (*eth.BeaconBlockHeader, error) {
-	if h == nil {
-		return nil, errNilValue
-	}
 	s, err := strconv.ParseUint(h.Slot, 10, 64)
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Slot")
@@ -2094,31 +2088,27 @@ func (b *BeaconBlockElectra) ToConsensus() (*eth.BeaconBlockElectra, error) {
 		return nil, server.NewDecodeError(err, "Body.ExecutionPayload.ExcessBlobGas")
 	}
 
-	if b.Body.ExecutionRequests == nil {
-		return nil, server.NewDecodeError(errors.New("nil execution requests"), "Body.ExequtionRequests")
-	}
-
-	depositRequests := make([]*enginev1.DepositRequest, len(b.Body.ExecutionRequests.Deposits))
-	for i, d := range b.Body.ExecutionRequests.Deposits {
+	depositRequests := make([]*enginev1.DepositRequest, len(b.Body.ExecutionPayload.DepositRequests))
+	for i, d := range b.Body.ExecutionPayload.DepositRequests {
 		depositRequests[i], err = d.ToConsensus()
 		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Deposits[%d]", i))
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionPayload.DepositRequests[%d]", i))
 		}
 	}
 
-	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(b.Body.ExecutionRequests.Withdrawals))
-	for i, w := range b.Body.ExecutionRequests.Withdrawals {
+	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(b.Body.ExecutionPayload.WithdrawalRequests))
+	for i, w := range b.Body.ExecutionPayload.WithdrawalRequests {
 		withdrawalRequests[i], err = w.ToConsensus()
 		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Withdrawals[%d]", i))
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionPayload.WithdrawalRequests[%d]", i))
 		}
 	}
 
-	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(b.Body.ExecutionRequests.Consolidations))
-	for i, c := range b.Body.ExecutionRequests.Consolidations {
+	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(b.Body.ExecutionPayload.ConsolidationRequests))
+	for i, c := range b.Body.ExecutionPayload.ConsolidationRequests {
 		consolidationRequests[i], err = c.ToConsensus()
 		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Consolidations[%d]", i))
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionPayload.ConsolidationRequests[%d]", i))
 		}
 	}
 
@@ -2161,31 +2151,29 @@ func (b *BeaconBlockElectra) ToConsensus() (*eth.BeaconBlockElectra, error) {
 				SyncCommitteeSignature: syncCommitteeSig,
 			},
 			ExecutionPayload: &enginev1.ExecutionPayloadElectra{
-				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,
+				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,
+				DepositRequests:       depositRequests,
+				WithdrawalRequests:    withdrawalRequests,
+				ConsolidationRequests: consolidationRequests,
 			},
 			BlsToExecutionChanges: blsChanges,
 			BlobKzgCommitments:    blobKzgCommitments,
-			ExecutionRequests: &enginev1.ExecutionRequests{
-				Deposits:       depositRequests,
-				Withdrawals:    withdrawalRequests,
-				Consolidations: consolidationRequests,
-			},
 		},
 	}, nil
 }
@@ -2395,31 +2383,17 @@ func (b *BlindedBeaconBlockElectra) ToConsensus() (*eth.BlindedBeaconBlockElectr
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Body.ExecutionPayload.ExcessBlobGas")
 	}
-	if b.Body.ExecutionRequests == nil {
-		return nil, server.NewDecodeError(errors.New("nil execution requests"), "Body.ExecutionRequests")
+	payloadDepositRequestsRoot, err := bytesutil.DecodeHexWithLength(b.Body.ExecutionPayloadHeader.DepositRequestsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Body.ExecutionPayloadHeader.DepositRequestsRoot")
 	}
-	depositRequests := make([]*enginev1.DepositRequest, len(b.Body.ExecutionRequests.Deposits))
-	for i, d := range b.Body.ExecutionRequests.Deposits {
-		depositRequests[i], err = d.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Deposits[%d]", i))
-		}
+	payloadWithdrawalRequestsRoot, err := bytesutil.DecodeHexWithLength(b.Body.ExecutionPayloadHeader.WithdrawalRequestsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Body.ExecutionPayloadHeader.WithdrawalRequestsRoot")
 	}
-
-	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(b.Body.ExecutionRequests.Withdrawals))
-	for i, w := range b.Body.ExecutionRequests.Withdrawals {
-		withdrawalRequests[i], err = w.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Withdrawals[%d]", i))
-		}
-	}
-
-	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(b.Body.ExecutionRequests.Consolidations))
-	for i, c := range b.Body.ExecutionRequests.Consolidations {
-		consolidationRequests[i], err = c.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Consolidations[%d]", i))
-		}
+	payloadConsolidationRequestsRoot, err := bytesutil.DecodeHexWithLength(b.Body.ExecutionPayloadHeader.ConsolidationRequestsRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Body.ExecutionPayloadHeader.ConsolidationRequestsRoot")
 	}
 
 	blsChanges, err := SignedBLSChangesToConsensus(b.Body.BLSToExecutionChanges)
@@ -2462,31 +2436,29 @@ func (b *BlindedBeaconBlockElectra) ToConsensus() (*eth.BlindedBeaconBlockElectr
 				SyncCommitteeSignature: syncCommitteeSig,
 			},
 			ExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderElectra{
-				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,
+				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,
+				DepositRequestsRoot:       payloadDepositRequestsRoot,
+				WithdrawalRequestsRoot:    payloadWithdrawalRequestsRoot,
+				ConsolidationRequestsRoot: payloadConsolidationRequestsRoot,
 			},
 			BlsToExecutionChanges: blsChanges,
 			BlobKzgCommitments:    blobKzgCommitments,
-			ExecutionRequests: &enginev1.ExecutionRequests{
-				Deposits:       depositRequests,
-				Withdrawals:    withdrawalRequests,
-				Consolidations: consolidationRequests,
-			},
 		},
 	}, nil
 }
@@ -2554,8 +2526,6 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockDenebFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockDeneb:
 		return SignedBeaconBlockDenebFromConsensus(pbStruct)
-	case *eth.SignedBlindedBeaconBlockElectra:
-		return SignedBlindedBeaconBlockElectraFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockElectra:
 		return SignedBeaconBlockElectraFromConsensus(pbStruct)
 	default:
@@ -2993,19 +2963,10 @@ func BlindedBeaconBlockElectraFromConsensus(b *eth.BlindedBeaconBlockElectra) (*
 			ExecutionPayloadHeader: payload,
 			BLSToExecutionChanges:  SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
 			BlobKzgCommitments:     blobKzgCommitments,
-			ExecutionRequests:      ExecutionRequestsFromConsensus(b.Body.ExecutionRequests),
 		},
 	}, nil
 }
 
-func ExecutionRequestsFromConsensus(er *enginev1.ExecutionRequests) *ExecutionRequests {
-	return &ExecutionRequests{
-		Deposits:       DepositRequestsFromConsensus(er.Deposits),
-		Withdrawals:    WithdrawalRequestsFromConsensus(er.Withdrawals),
-		Consolidations: ConsolidationRequestsFromConsensus(er.Consolidations),
-	}
-}
-
 func SignedBlindedBeaconBlockElectraFromConsensus(b *eth.SignedBlindedBeaconBlockElectra) (*SignedBlindedBeaconBlockElectra, error) {
 	block, err := BlindedBeaconBlockElectraFromConsensus(b.Message)
 	if err != nil {
@@ -3048,7 +3009,6 @@ func BeaconBlockElectraFromConsensus(b *eth.BeaconBlockElectra) (*BeaconBlockEle
 			ExecutionPayload:      payload,
 			BLSToExecutionChanges: SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
 			BlobKzgCommitments:    blobKzgCommitments,
-			ExecutionRequests:     ExecutionRequestsFromConsensus(b.Body.ExecutionRequests),
 		},
 	}, nil
 }
@@ -3152,7 +3112,39 @@ func ExecutionPayloadDenebFromConsensus(payload *enginev1.ExecutionPayloadDeneb)
 	}, nil
 }
 
-var ExecutionPayloadElectraFromConsensus = ExecutionPayloadDenebFromConsensus
+func ExecutionPayloadElectraFromConsensus(payload *enginev1.ExecutionPayloadElectra) (*ExecutionPayloadElectra, 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 &ExecutionPayloadElectra{
+		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),
+		DepositRequests:       DepositRequestsFromConsensus(payload.DepositRequests),
+		WithdrawalRequests:    WithdrawalRequestsFromConsensus(payload.WithdrawalRequests),
+		ConsolidationRequests: ConsolidationRequestsFromConsensus(payload.ConsolidationRequests),
+	}, nil
+}
 
 func ExecutionPayloadHeaderFromConsensus(payload *enginev1.ExecutionPayloadHeader) (*ExecutionPayloadHeader, error) {
 	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
@@ -3230,4 +3222,32 @@ func ExecutionPayloadHeaderDenebFromConsensus(payload *enginev1.ExecutionPayload
 	}, nil
 }
 
-var ExecutionPayloadHeaderElectraFromConsensus = ExecutionPayloadHeaderDenebFromConsensus
+func ExecutionPayloadHeaderElectraFromConsensus(payload *enginev1.ExecutionPayloadHeaderElectra) (*ExecutionPayloadHeaderElectra, error) {
+	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ExecutionPayloadHeaderElectra{
+		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),
+		DepositRequestsRoot:       hexutil.Encode(payload.DepositRequestsRoot),
+		WithdrawalRequestsRoot:    hexutil.Encode(payload.WithdrawalRequestsRoot),
+		ConsolidationRequestsRoot: hexutil.Encode(payload.ConsolidationRequestsRoot),
+	}, nil
+}

api/server/structs/conversions_lightclient.go

@@ -1,127 +0,0 @@
-package structs
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	v1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v5/proto/migration"
-)
-
-func LightClientUpdateFromConsensus(update *v2.LightClientUpdate) (*LightClientUpdate, error) {
-	attestedHeader, err := lightClientHeaderContainerToJSON(update.AttestedHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal attested light client header")
-	}
-	finalizedHeader, err := lightClientHeaderContainerToJSON(update.FinalizedHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal finalized light client header")
-	}
-
-	return &LightClientUpdate{
-		AttestedHeader:          attestedHeader,
-		NextSyncCommittee:       SyncCommitteeFromConsensus(migration.V2SyncCommitteeToV1Alpha1(update.NextSyncCommittee)),
-		NextSyncCommitteeBranch: branchToJSON(update.NextSyncCommitteeBranch),
-		FinalizedHeader:         finalizedHeader,
-		FinalityBranch:          branchToJSON(update.FinalityBranch),
-		SyncAggregate:           syncAggregateToJSON(update.SyncAggregate),
-		SignatureSlot:           strconv.FormatUint(uint64(update.SignatureSlot), 10),
-	}, nil
-}
-
-func LightClientFinalityUpdateFromConsensus(update *v2.LightClientFinalityUpdate) (*LightClientFinalityUpdate, error) {
-	attestedHeader, err := lightClientHeaderContainerToJSON(update.AttestedHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal attested light client header")
-	}
-	finalizedHeader, err := lightClientHeaderContainerToJSON(update.FinalizedHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal finalized light client header")
-	}
-
-	return &LightClientFinalityUpdate{
-		AttestedHeader:  attestedHeader,
-		FinalizedHeader: finalizedHeader,
-		FinalityBranch:  branchToJSON(update.FinalityBranch),
-		SyncAggregate:   syncAggregateToJSON(update.SyncAggregate),
-		SignatureSlot:   strconv.FormatUint(uint64(update.SignatureSlot), 10),
-	}, nil
-}
-
-func LightClientOptimisticUpdateFromConsensus(update *v2.LightClientOptimisticUpdate) (*LightClientOptimisticUpdate, error) {
-	attestedHeader, err := lightClientHeaderContainerToJSON(update.AttestedHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal attested light client header")
-	}
-
-	return &LightClientOptimisticUpdate{
-		AttestedHeader: attestedHeader,
-		SyncAggregate:  syncAggregateToJSON(update.SyncAggregate),
-		SignatureSlot:  strconv.FormatUint(uint64(update.SignatureSlot), 10),
-	}, nil
-}
-
-func branchToJSON(branchBytes [][]byte) []string {
-	if branchBytes == nil {
-		return nil
-	}
-	branch := make([]string, len(branchBytes))
-	for i, root := range branchBytes {
-		branch[i] = hexutil.Encode(root)
-	}
-	return branch
-}
-
-func syncAggregateToJSON(input *v1.SyncAggregate) *SyncAggregate {
-	return &SyncAggregate{
-		SyncCommitteeBits:      hexutil.Encode(input.SyncCommitteeBits),
-		SyncCommitteeSignature: hexutil.Encode(input.SyncCommitteeSignature),
-	}
-}
-
-func lightClientHeaderContainerToJSON(container *v2.LightClientHeaderContainer) (json.RawMessage, error) {
-	// In the case that a finalizedHeader is nil.
-	if container == nil {
-		return nil, nil
-	}
-
-	beacon, err := container.GetBeacon()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get beacon block header")
-	}
-
-	var header any
-
-	switch t := (container.Header).(type) {
-	case *v2.LightClientHeaderContainer_HeaderAltair:
-		header = &LightClientHeader{Beacon: BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(beacon))}
-	case *v2.LightClientHeaderContainer_HeaderCapella:
-		execution, err := ExecutionPayloadHeaderCapellaFromConsensus(t.HeaderCapella.Execution)
-		if err != nil {
-			return nil, err
-		}
-		header = &LightClientHeaderCapella{
-			Beacon:          BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(beacon)),
-			Execution:       execution,
-			ExecutionBranch: branchToJSON(t.HeaderCapella.ExecutionBranch),
-		}
-	case *v2.LightClientHeaderContainer_HeaderDeneb:
-		execution, err := ExecutionPayloadHeaderDenebFromConsensus(t.HeaderDeneb.Execution)
-		if err != nil {
-			return nil, err
-		}
-		header = &LightClientHeaderDeneb{
-			Beacon:          BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(beacon)),
-			Execution:       execution,
-			ExecutionBranch: branchToJSON(t.HeaderDeneb.ExecutionBranch),
-		}
-	default:
-		return nil, fmt.Errorf("unsupported header type %T", t)
-	}
-
-	return json.Marshal(header)
-}

api/server/structs/conversions_state.go

@@ -674,7 +674,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 	if err != nil {
 		return nil, err
 	}
-	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
+	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
 	if !ok {
 		return nil, errPayloadHeaderNotFound
 	}
@@ -722,7 +722,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 	if err != nil {
 		return nil, err
 	}
-	pbd, err := st.PendingDeposits()
+	pbd, err := st.PendingBalanceDeposits()
 	if err != nil {
 		return nil, err
 	}
@@ -770,7 +770,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
 		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
 		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
-		PendingDeposits:               PendingDepositsFromConsensus(pbd),
+		PendingBalanceDeposits:        PendingBalanceDepositsFromConsensus(pbd),
 		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
 		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
 	}, nil

api/server/structs/endpoints_beacon.go

@@ -21,12 +21,11 @@ type GetCommitteesResponse struct {
 }
 
 type ListAttestationsResponse struct {
-	Version string          `json:"version,omitempty"`
-	Data    json.RawMessage `json:"data"`
+	Data []*Attestation `json:"data"`
 }
 
 type SubmitAttestationsRequest struct {
-	Data json.RawMessage `json:"data"`
+	Data []*Attestation `json:"data"`
 }
 
 type ListVoluntaryExitsResponse struct {
@@ -134,13 +133,6 @@ type GetBlockAttestationsResponse struct {
 	Data                []*Attestation `json:"data"`
 }
 
-type GetBlockAttestationsV2Response struct {
-	Version             string          `json:"version"`
-	ExecutionOptimistic bool            `json:"execution_optimistic"`
-	Finalized           bool            `json:"finalized"`
-	Data                json.RawMessage `json:"data"` // Accepts both `Attestation` and `AttestationElectra` types
-}
-
 type GetStateRootResponse struct {
 	ExecutionOptimistic bool       `json:"execution_optimistic"`
 	Finalized           bool       `json:"finalized"`
@@ -177,8 +169,7 @@ type BLSToExecutionChangesPoolResponse struct {
 }
 
 type GetAttesterSlashingsResponse struct {
-	Version string          `json:"version,omitempty"`
-	Data    json.RawMessage `json:"data"` // Accepts both `[]*AttesterSlashing` and `[]*AttesterSlashingElectra` types
+	Data []*AttesterSlashing `json:"data"`
 }
 
 type GetProposerSlashingsResponse struct {

api/server/structs/endpoints_blob.go

@@ -12,12 +12,3 @@ type Sidecar struct {
 	KzgProof                 string                   `json:"kzg_proof"`
 	CommitmentInclusionProof []string                 `json:"kzg_commitment_inclusion_proof"`
 }
-
-type BlobSidecars struct {
-	Sidecars []*Sidecar `json:"sidecars"`
-}
-
-type PublishBlobsRequest struct {
-	BlobSidecars *BlobSidecars `json:"blob_sidecars"`
-	BlockRoot    string        `json:"block_root"`
-}

api/server/structs/endpoints_events.go

@@ -96,7 +96,21 @@ type LightClientFinalityUpdateEvent struct {
 	Data    *LightClientFinalityUpdate `json:"data"`
 }
 
+type LightClientFinalityUpdate struct {
+	AttestedHeader  *BeaconBlockHeader `json:"attested_header"`
+	FinalizedHeader *BeaconBlockHeader `json:"finalized_header"`
+	FinalityBranch  []string           `json:"finality_branch"`
+	SyncAggregate   *SyncAggregate     `json:"sync_aggregate"`
+	SignatureSlot   string             `json:"signature_slot"`
+}
+
 type LightClientOptimisticUpdateEvent struct {
 	Version string                       `json:"version"`
 	Data    *LightClientOptimisticUpdate `json:"data"`
 }
+
+type LightClientOptimisticUpdate struct {
+	AttestedHeader *BeaconBlockHeader `json:"attested_header"`
+	SyncAggregate  *SyncAggregate     `json:"sync_aggregate"`
+	SignatureSlot  string             `json:"signature_slot"`
+}

api/server/structs/endpoints_lightclient.go

@@ -1,73 +1,35 @@
 package structs
 
-import "encoding/json"
-
 type LightClientHeader struct {
 	Beacon *BeaconBlockHeader `json:"beacon"`
 }
 
-type LightClientHeaderCapella struct {
-	Beacon          *BeaconBlockHeader             `json:"beacon"`
-	Execution       *ExecutionPayloadHeaderCapella `json:"execution"`
-	ExecutionBranch []string                       `json:"execution_branch"`
-}
-
-type LightClientHeaderDeneb struct {
-	Beacon          *BeaconBlockHeader           `json:"beacon"`
-	Execution       *ExecutionPayloadHeaderDeneb `json:"execution"`
-	ExecutionBranch []string                     `json:"execution_branch"`
-}
-
-type LightClientBootstrap struct {
-	Header                     json.RawMessage `json:"header"`
-	CurrentSyncCommittee       *SyncCommittee  `json:"current_sync_committee"`
-	CurrentSyncCommitteeBranch []string        `json:"current_sync_committee_branch"`
-}
-
-type LightClientUpdate struct {
-	AttestedHeader          json.RawMessage `json:"attested_header"`
-	NextSyncCommittee       *SyncCommittee  `json:"next_sync_committee,omitempty"`
-	FinalizedHeader         json.RawMessage `json:"finalized_header,omitempty"`
-	SyncAggregate           *SyncAggregate  `json:"sync_aggregate"`
-	NextSyncCommitteeBranch []string        `json:"next_sync_committee_branch,omitempty"`
-	FinalityBranch          []string        `json:"finality_branch,omitempty"`
-	SignatureSlot           string          `json:"signature_slot"`
-}
-
-type LightClientFinalityUpdate struct {
-	AttestedHeader  json.RawMessage `json:"attested_header"`
-	FinalizedHeader json.RawMessage `json:"finalized_header"`
-	FinalityBranch  []string        `json:"finality_branch"`
-	SyncAggregate   *SyncAggregate  `json:"sync_aggregate"`
-	SignatureSlot   string          `json:"signature_slot"`
-}
-
-type LightClientOptimisticUpdate struct {
-	AttestedHeader json.RawMessage `json:"attested_header"`
-	SyncAggregate  *SyncAggregate  `json:"sync_aggregate"`
-	SignatureSlot  string          `json:"signature_slot"`
-}
-
 type LightClientBootstrapResponse struct {
 	Version string                `json:"version"`
 	Data    *LightClientBootstrap `json:"data"`
 }
 
-type LightClientUpdateResponse struct {
+type LightClientBootstrap struct {
+	Header                     *LightClientHeader `json:"header"`
+	CurrentSyncCommittee       *SyncCommittee     `json:"current_sync_committee"`
+	CurrentSyncCommitteeBranch []string           `json:"current_sync_committee_branch"`
+}
+
+type LightClientUpdate struct {
+	AttestedHeader          *BeaconBlockHeader `json:"attested_header"`
+	NextSyncCommittee       *SyncCommittee     `json:"next_sync_committee,omitempty"`
+	FinalizedHeader         *BeaconBlockHeader `json:"finalized_header,omitempty"`
+	SyncAggregate           *SyncAggregate     `json:"sync_aggregate"`
+	NextSyncCommitteeBranch []string           `json:"next_sync_committee_branch,omitempty"`
+	FinalityBranch          []string           `json:"finality_branch,omitempty"`
+	SignatureSlot           string             `json:"signature_slot"`
+}
+
+type LightClientUpdateWithVersion struct {
 	Version string             `json:"version"`
 	Data    *LightClientUpdate `json:"data"`
 }
 
-type LightClientFinalityUpdateResponse struct {
-	Version string                     `json:"version"`
-	Data    *LightClientFinalityUpdate `json:"data"`
-}
-
-type LightClientOptimisticUpdateResponse struct {
-	Version string                       `json:"version"`
-	Data    *LightClientOptimisticUpdate `json:"data"`
-}
-
 type LightClientUpdatesByRangeResponse struct {
-	Updates []*LightClientUpdateResponse `json:"updates"`
+	Updates []*LightClientUpdateWithVersion `json:"updates"`
 }

api/server/structs/endpoints_validator.go

@@ -7,8 +7,7 @@ import (
 )
 
 type AggregateAttestationResponse struct {
-	Version string          `json:"version,omitempty"`
-	Data    json.RawMessage `json:"data"`
+	Data *Attestation `json:"data"`
 }
 
 type SubmitContributionAndProofsRequest struct {
@@ -16,7 +15,7 @@ type SubmitContributionAndProofsRequest struct {
 }
 
 type SubmitAggregateAndProofsRequest struct {
-	Data []json.RawMessage `json:"data"`
+	Data []*SignedAggregateAttestationAndProof `json:"data"`
 }
 
 type SubmitSyncCommitteeSubscriptionsRequest struct {

api/server/structs/other.go

@@ -257,12 +257,9 @@ type ConsolidationRequest struct {
 	TargetPubkey  string `json:"target_pubkey"`
 }
 
-type PendingDeposit struct {
-	Pubkey                string `json:"pubkey"`
-	WithdrawalCredentials string `json:"withdrawal_credentials"`
-	Amount                string `json:"amount"`
-	Signature             string `json:"signature"`
-	Slot                  string `json:"slot"`
+type PendingBalanceDeposit struct {
+	Index  string `json:"index"`
+	Amount string `json:"amount"`
 }
 
 type PendingPartialWithdrawal struct {

api/server/structs/state.go

@@ -176,7 +176,7 @@ type BeaconStateElectra struct {
 	EarliestExitEpoch             string                         `json:"earliest_exit_epoch"`
 	ConsolidationBalanceToConsume string                         `json:"consolidation_balance_to_consume"`
 	EarliestConsolidationEpoch    string                         `json:"earliest_consolidation_epoch"`
-	PendingDeposits               []*PendingDeposit              `json:"pending_deposits"`
+	PendingBalanceDeposits        []*PendingBalanceDeposit       `json:"pending_balance_deposits"`
 	PendingPartialWithdrawals     []*PendingPartialWithdrawal    `json:"pending_partial_withdrawals"`
 	PendingConsolidations         []*PendingConsolidation        `json:"pending_consolidations"`
 }

async/event/BUILD.bazel

@@ -4,25 +4,26 @@ go_library(
     name = "go_default_library",
     srcs = [
         "feed.go",
-        "interface.go",
         "subscription.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/async/event",
     visibility = ["//visibility:public"],
-    deps = [
-        "//time/mclock:go_default_library",
-        "@com_github_ethereum_go_ethereum//event:go_default_library",
-    ],
+    deps = ["//time/mclock:go_default_library"],
 )
 
 go_test(
     name = "go_default_test",
     size = "small",
     srcs = [
+        "example_feed_test.go",
         "example_scope_test.go",
         "example_subscription_test.go",
+        "feed_test.go",
         "subscription_test.go",
     ],
     embed = [":go_default_library"],
-    deps = ["//testing/require:go_default_library"],
+    deps = [
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
 )

async/event/example_feed_test.go

@@ -0,0 +1,73 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package event_test
+
+import (
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/async/event"
+)
+
+func ExampleFeed_acknowledgedEvents() {
+	// This example shows how the return value of Send can be used for request/reply
+	// interaction between event consumers and producers.
+	var feed event.Feed
+	type ackedEvent struct {
+		i   int
+		ack chan<- struct{}
+	}
+
+	// Consumers wait for events on the feed and acknowledge processing.
+	done := make(chan struct{})
+	defer close(done)
+	for i := 0; i < 3; i++ {
+		ch := make(chan ackedEvent, 100)
+		sub := feed.Subscribe(ch)
+		go func() {
+			defer sub.Unsubscribe()
+			for {
+				select {
+				case ev := <-ch:
+					fmt.Println(ev.i) // "process" the event
+					ev.ack <- struct{}{}
+				case <-done:
+					return
+				}
+			}
+		}()
+	}
+
+	// The producer sends values of type ackedEvent with increasing values of i.
+	// It waits for all consumers to acknowledge before sending the next event.
+	for i := 0; i < 3; i++ {
+		acksignal := make(chan struct{})
+		n := feed.Send(ackedEvent{i, acksignal})
+		for ack := 0; ack < n; ack++ {
+			<-acksignal
+		}
+	}
+	// Output:
+	// 0
+	// 0
+	// 0
+	// 1
+	// 1
+	// 1
+	// 2
+	// 2
+	// 2
+}

async/event/feed.go

@@ -14,12 +14,241 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
+// Package event contains an event feed implementation for process communication.
 package event
 
 import (
-	geth_event "github.com/ethereum/go-ethereum/event"
+	"errors"
+	"reflect"
+	"slices"
+	"sync"
 )
 
-// Feed is a re-export of the go-ethereum event feed.
-type Feed = geth_event.Feed
-type Subscription = geth_event.Subscription
+var errBadChannel = errors.New("event: Subscribe argument does not have sendable channel type")
+
+// Feed implements one-to-many subscriptions where the carrier of events is a channel.
+// Values sent to a Feed are delivered to all subscribed channels simultaneously.
+//
+// Feeds can only be used with a single type. The type is determined by the first Send or
+// Subscribe operation. Subsequent calls to these methods panic if the type does not
+// match.
+//
+// The zero value is ready to use.
+type Feed struct {
+	once      sync.Once        // ensures that init only runs once
+	sendLock  chan struct{}    // sendLock has a one-element buffer and is empty when held.It protects sendCases.
+	removeSub chan interface{} // interrupts Send
+	sendCases caseList         // the active set of select cases used by Send
+
+	// The inbox holds newly subscribed channels until they are added to sendCases.
+	mu    sync.Mutex
+	inbox caseList
+	etype reflect.Type
+}
+
+// This is the index of the first actual subscription channel in sendCases.
+// sendCases[0] is a SelectRecv case for the removeSub channel.
+const firstSubSendCase = 1
+
+type feedTypeError struct {
+	got, want reflect.Type
+	op        string
+}
+
+func (e feedTypeError) Error() string {
+	return "event: wrong type in " + e.op + " got " + e.got.String() + ", want " + e.want.String()
+}
+
+func (f *Feed) init() {
+	f.removeSub = make(chan interface{})
+	f.sendLock = make(chan struct{}, 1)
+	f.sendLock <- struct{}{}
+	f.sendCases = caseList{{Chan: reflect.ValueOf(f.removeSub), Dir: reflect.SelectRecv}}
+}
+
+// Subscribe adds a channel to the feed. Future sends will be delivered on the channel
+// until the subscription is canceled. All channels added must have the same element type.
+//
+// The channel should have ample buffer space to avoid blocking other subscribers.
+// Slow subscribers are not dropped.
+func (f *Feed) Subscribe(channel interface{}) Subscription {
+	f.once.Do(f.init)
+
+	chanval := reflect.ValueOf(channel)
+	chantyp := chanval.Type()
+	if chantyp.Kind() != reflect.Chan || chantyp.ChanDir()&reflect.SendDir == 0 {
+		panic(errBadChannel)
+	}
+	sub := &feedSub{feed: f, channel: chanval, err: make(chan error, 1)}
+
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if !f.typecheck(chantyp.Elem()) {
+		panic(feedTypeError{op: "Subscribe", got: chantyp, want: reflect.ChanOf(reflect.SendDir, f.etype)})
+	}
+	// Add the select case to the inbox.
+	// The next Send will add it to f.sendCases.
+	cas := reflect.SelectCase{Dir: reflect.SelectSend, Chan: chanval}
+	f.inbox = append(f.inbox, cas)
+	return sub
+}
+
+// note: callers must hold f.mu
+func (f *Feed) typecheck(typ reflect.Type) bool {
+	if f.etype == nil {
+		f.etype = typ
+		return true
+	}
+	// In the event the feed's type is an actual interface, we
+	// perform an interface conformance check here.
+	if f.etype.Kind() == reflect.Interface && typ.Implements(f.etype) {
+		return true
+	}
+	return f.etype == typ
+}
+
+func (f *Feed) remove(sub *feedSub) {
+	// Delete from inbox first, which covers channels
+	// that have not been added to f.sendCases yet.
+	ch := sub.channel.Interface()
+	f.mu.Lock()
+	index := f.inbox.find(ch)
+	if index != -1 {
+		f.inbox = f.inbox.delete(index)
+		f.mu.Unlock()
+		return
+	}
+	f.mu.Unlock()
+
+	select {
+	case f.removeSub <- ch:
+		// Send will remove the channel from f.sendCases.
+	case <-f.sendLock:
+		// No Send is in progress, delete the channel now that we have the send lock.
+		f.sendCases = f.sendCases.delete(f.sendCases.find(ch))
+		f.sendLock <- struct{}{}
+	}
+}
+
+// Send delivers to all subscribed channels simultaneously.
+// It returns the number of subscribers that the value was sent to.
+func (f *Feed) Send(value interface{}) (nsent int) {
+	rvalue := reflect.ValueOf(value)
+
+	f.once.Do(f.init)
+	<-f.sendLock
+
+	// Add new cases from the inbox after taking the send lock.
+	f.mu.Lock()
+	f.sendCases = append(f.sendCases, f.inbox...)
+	f.inbox = nil
+
+	if !f.typecheck(rvalue.Type()) {
+		f.sendLock <- struct{}{}
+		f.mu.Unlock()
+		panic(feedTypeError{op: "Send", got: rvalue.Type(), want: f.etype})
+	}
+	f.mu.Unlock()
+
+	// Set the sent value on all channels.
+	for i := firstSubSendCase; i < len(f.sendCases); i++ {
+		f.sendCases[i].Send = rvalue
+	}
+
+	// Send until all channels except removeSub have been chosen. 'cases' tracks a prefix
+	// of sendCases. When a send succeeds, the corresponding case moves to the end of
+	// 'cases' and it shrinks by one element.
+	cases := f.sendCases
+	for {
+		// Fast path: try sending without blocking before adding to the select set.
+		// This should usually succeed if subscribers are fast enough and have free
+		// buffer space.
+		for i := firstSubSendCase; i < len(cases); i++ {
+			if cases[i].Chan.TrySend(rvalue) {
+				nsent++
+				cases = cases.deactivate(i)
+				i--
+			}
+		}
+		if len(cases) == firstSubSendCase {
+			break
+		}
+		// Select on all the receivers, waiting for them to unblock.
+		chosen, recv, _ := reflect.Select(cases)
+		if chosen == 0 /* <-f.removeSub */ {
+			index := f.sendCases.find(recv.Interface())
+			f.sendCases = f.sendCases.delete(index)
+			if index >= 0 && index < len(cases) {
+				// Shrink 'cases' too because the removed case was still active.
+				cases = f.sendCases[:len(cases)-1]
+			}
+		} else {
+			cases = cases.deactivate(chosen)
+			nsent++
+		}
+	}
+
+	// Forget about the sent value and hand off the send lock.
+	for i := firstSubSendCase; i < len(f.sendCases); i++ {
+		f.sendCases[i].Send = reflect.Value{}
+	}
+	f.sendLock <- struct{}{}
+	return nsent
+}
+
+type feedSub struct {
+	feed    *Feed
+	channel reflect.Value
+	errOnce sync.Once
+	err     chan error
+}
+
+// Unsubscribe remove feed subscription.
+func (sub *feedSub) Unsubscribe() {
+	sub.errOnce.Do(func() {
+		sub.feed.remove(sub)
+		close(sub.err)
+	})
+}
+
+// Err returns error channel.
+func (sub *feedSub) Err() <-chan error {
+	return sub.err
+}
+
+type caseList []reflect.SelectCase
+
+// find returns the index of a case containing the given channel.
+func (cs caseList) find(channel interface{}) int {
+	return slices.IndexFunc(cs, func(selectCase reflect.SelectCase) bool {
+		return selectCase.Chan.Interface() == channel
+	})
+}
+
+// delete removes the given case from cs.
+func (cs caseList) delete(index int) caseList {
+	return append(cs[:index], cs[index+1:]...)
+}
+
+// deactivate moves the case at index into the non-accessible portion of the cs slice.
+func (cs caseList) deactivate(index int) caseList {
+	last := len(cs) - 1
+	cs[index], cs[last] = cs[last], cs[index]
+	return cs[:last]
+}
+
+// func (cs caseList) String() string {
+//     s := "["
+//     for i, cas := range cs {
+//             if i != 0 {
+//                     s += ", "
+//             }
+//             switch cas.Dir {
+//             case reflect.SelectSend:
+//                     s += fmt.Sprintf("%v<-", cas.Chan.Interface())
+//             case reflect.SelectRecv:
+//                     s += fmt.Sprintf("<-%v", cas.Chan.Interface())
+//             }
+//     }
+//     return s + "]"
+// }

async/event/feed_test.go

@@ -0,0 +1,509 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/assert"
+)
+
+func TestFeedPanics(t *testing.T) {
+	{
+		var f Feed
+		f.Send(2)
+		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
+		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
+		// Validate it doesn't deadlock.
+		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
+	}
+	{
+		var f Feed
+		ch := make(chan int)
+		f.Subscribe(ch)
+		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
+		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
+	}
+	{
+		var f Feed
+		f.Send(2)
+		want := feedTypeError{op: "Subscribe", got: reflect.TypeOf(make(chan uint64)), want: reflect.TypeOf(make(chan<- int))}
+		assert.NoError(t, checkPanic(want, func() { f.Subscribe(make(chan uint64)) }))
+	}
+	{
+		var f Feed
+		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(make(<-chan int)) }))
+	}
+	{
+		var f Feed
+		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(0) }))
+	}
+}
+
+func checkPanic(want error, fn func()) (err error) {
+	defer func() {
+		panicResult := recover()
+		if panicResult == nil {
+			err = fmt.Errorf("didn't panic")
+		} else if !reflect.DeepEqual(panicResult, want) {
+			err = fmt.Errorf("panicked with wrong error: got %q, want %q", panicResult, want)
+		}
+	}()
+	fn()
+	return nil
+}
+
+func TestFeed(t *testing.T) {
+	var feed Feed
+	var done, subscribed sync.WaitGroup
+	subscriber := func(i int) {
+		defer done.Done()
+
+		subchan := make(chan int)
+		sub := feed.Subscribe(subchan)
+		timeout := time.NewTimer(2 * time.Second)
+		subscribed.Done()
+
+		select {
+		case v := <-subchan:
+			if v != 1 {
+				t.Errorf("%d: received value %d, want 1", i, v)
+			}
+		case <-timeout.C:
+			t.Errorf("%d: receive timeout", i)
+		}
+
+		sub.Unsubscribe()
+		select {
+		case _, ok := <-sub.Err():
+			if ok {
+				t.Errorf("%d: error channel not closed after unsubscribe", i)
+			}
+		case <-timeout.C:
+			t.Errorf("%d: unsubscribe timeout", i)
+		}
+	}
+
+	const n = 1000
+	done.Add(n)
+	subscribed.Add(n)
+	for i := 0; i < n; i++ {
+		go subscriber(i)
+	}
+	subscribed.Wait()
+	if nsent := feed.Send(1); nsent != n {
+		t.Errorf("first send delivered %d times, want %d", nsent, n)
+	}
+	if nsent := feed.Send(2); nsent != 0 {
+		t.Errorf("second send delivered %d times, want 0", nsent)
+	}
+	done.Wait()
+}
+
+func TestFeedSubscribeSameChannel(t *testing.T) {
+	var (
+		feed Feed
+		done sync.WaitGroup
+		ch   = make(chan int)
+		sub1 = feed.Subscribe(ch)
+		sub2 = feed.Subscribe(ch)
+		_    = feed.Subscribe(ch)
+	)
+	expectSends := func(value, n int) {
+		if nsent := feed.Send(value); nsent != n {
+			t.Errorf("send delivered %d times, want %d", nsent, n)
+		}
+		done.Done()
+	}
+	expectRecv := func(wantValue, n int) {
+		for i := 0; i < n; i++ {
+			if v := <-ch; v != wantValue {
+				t.Errorf("received %d, want %d", v, wantValue)
+			}
+		}
+	}
+
+	done.Add(1)
+	go expectSends(1, 3)
+	expectRecv(1, 3)
+	done.Wait()
+
+	sub1.Unsubscribe()
+
+	done.Add(1)
+	go expectSends(2, 2)
+	expectRecv(2, 2)
+	done.Wait()
+
+	sub2.Unsubscribe()
+
+	done.Add(1)
+	go expectSends(3, 1)
+	expectRecv(3, 1)
+	done.Wait()
+}
+
+func TestFeedSubscribeBlockedPost(_ *testing.T) {
+	var (
+		feed   Feed
+		nsends = 2000
+		ch1    = make(chan int)
+		ch2    = make(chan int)
+		wg     sync.WaitGroup
+	)
+	defer wg.Wait()
+
+	feed.Subscribe(ch1)
+	wg.Add(nsends)
+	for i := 0; i < nsends; i++ {
+		go func() {
+			feed.Send(99)
+			wg.Done()
+		}()
+	}
+
+	sub2 := feed.Subscribe(ch2)
+	defer sub2.Unsubscribe()
+
+	// We're done when ch1 has received N times.
+	// The number of receives on ch2 depends on scheduling.
+	for i := 0; i < nsends; {
+		select {
+		case <-ch1:
+			i++
+		case <-ch2:
+		}
+	}
+}
+
+func TestFeedUnsubscribeBlockedPost(_ *testing.T) {
+	var (
+		feed   Feed
+		nsends = 200
+		chans  = make([]chan int, 2000)
+		subs   = make([]Subscription, len(chans))
+		bchan  = make(chan int)
+		bsub   = feed.Subscribe(bchan)
+		wg     sync.WaitGroup
+	)
+	for i := range chans {
+		chans[i] = make(chan int, nsends)
+	}
+
+	// Queue up some Sends. None of these can make progress while bchan isn't read.
+	wg.Add(nsends)
+	for i := 0; i < nsends; i++ {
+		go func() {
+			feed.Send(99)
+			wg.Done()
+		}()
+	}
+	// Subscribe the other channels.
+	for i, ch := range chans {
+		subs[i] = feed.Subscribe(ch)
+	}
+	// Unsubscribe them again.
+	for _, sub := range subs {
+		sub.Unsubscribe()
+	}
+	// Unblock the Sends.
+	bsub.Unsubscribe()
+	wg.Wait()
+}
+
+// Checks that unsubscribing a channel during Send works even if that
+// channel has already been sent on.
+func TestFeedUnsubscribeSentChan(_ *testing.T) {
+	var (
+		feed Feed
+		ch1  = make(chan int)
+		ch2  = make(chan int)
+		sub1 = feed.Subscribe(ch1)
+		sub2 = feed.Subscribe(ch2)
+		wg   sync.WaitGroup
+	)
+	defer sub2.Unsubscribe()
+
+	wg.Add(1)
+	go func() {
+		feed.Send(0)
+		wg.Done()
+	}()
+
+	// Wait for the value on ch1.
+	<-ch1
+	// Unsubscribe ch1, removing it from the send cases.
+	sub1.Unsubscribe()
+
+	// Receive ch2, finishing Send.
+	<-ch2
+	wg.Wait()
+
+	// Send again. This should send to ch2 only, so the wait group will unblock
+	// as soon as a value is received on ch2.
+	wg.Add(1)
+	go func() {
+		feed.Send(0)
+		wg.Done()
+	}()
+	<-ch2
+	wg.Wait()
+}
+
+func TestFeedUnsubscribeFromInbox(t *testing.T) {
+	var (
+		feed Feed
+		ch1  = make(chan int)
+		ch2  = make(chan int)
+		sub1 = feed.Subscribe(ch1)
+		sub2 = feed.Subscribe(ch1)
+		sub3 = feed.Subscribe(ch2)
+	)
+	assert.Equal(t, 3, len(feed.inbox))
+	assert.Equal(t, 1, len(feed.sendCases), "sendCases is non-empty after unsubscribe")
+
+	sub1.Unsubscribe()
+	sub2.Unsubscribe()
+	sub3.Unsubscribe()
+	assert.Equal(t, 0, len(feed.inbox), "Inbox is non-empty after unsubscribe")
+	assert.Equal(t, 1, len(feed.sendCases), "sendCases is non-empty after unsubscribe")
+}
+
+func BenchmarkFeedSend1000(b *testing.B) {
+	var (
+		done  sync.WaitGroup
+		feed  Feed
+		nsubs = 1000
+	)
+	subscriber := func(ch <-chan int) {
+		for i := 0; i < b.N; i++ {
+			<-ch
+		}
+		done.Done()
+	}
+	done.Add(nsubs)
+	for i := 0; i < nsubs; i++ {
+		ch := make(chan int, 200)
+		feed.Subscribe(ch)
+		go subscriber(ch)
+	}
+
+	// The actual benchmark.
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if feed.Send(i) != nsubs {
+			panic("wrong number of sends")
+		}
+	}
+
+	b.StopTimer()
+	done.Wait()
+}
+
+func TestFeed_Send(t *testing.T) {
+	tests := []struct {
+		name        string
+		evFeed      *Feed
+		testSetup   func(fd *Feed, t *testing.T, o interface{})
+		obj         interface{}
+		expectPanic bool
+	}{
+		{
+			name:   "normal struct",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedWithPointer, 1)
+				fd.Subscribe(testChan)
+			},
+			obj: testFeedWithPointer{
+				a: new(uint64),
+				b: new(string),
+			},
+			expectPanic: false,
+		},
+		{
+			name:   "un-implemented interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface, 1)
+				fd.Subscribe(testChan)
+			},
+			obj: testFeedWithPointer{
+				a: new(uint64),
+				b: new(string),
+			},
+			expectPanic: true,
+		},
+		{
+			name:   "semi-implemented interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface, 1)
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed2{
+				a: 0,
+				b: "",
+				c: []byte{'A'},
+			},
+			expectPanic: true,
+		},
+		{
+			name:   "fully-implemented interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface)
+				// Make it unbuffered to allow message to
+				// pass through
+				go func() {
+					a := <-testChan
+					if !reflect.DeepEqual(a, o) {
+						t.Errorf("Got = %v, want = %v", a, o)
+					}
+				}()
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed{
+				a: 0,
+				b: "",
+			},
+			expectPanic: false,
+		},
+		{
+			name:   "fully-implemented interface with additional methods",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface)
+				// Make it unbuffered to allow message to
+				// pass through
+				go func() {
+					a := <-testChan
+					if !reflect.DeepEqual(a, o) {
+						t.Errorf("Got = %v, want = %v", a, o)
+					}
+				}()
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed3{
+				a: 0,
+				b: "",
+				c: []byte{'A'},
+				d: []byte{'B'},
+			},
+			expectPanic: false,
+		},
+		{
+			name:   "concrete types implementing the same interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeed, 1)
+				// Make it unbuffered to allow message to
+				// pass through
+				go func() {
+					a := <-testChan
+					if !reflect.DeepEqual(a, o) {
+						t.Errorf("Got = %v, want = %v", a, o)
+					}
+				}()
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed3{
+				a: 0,
+				b: "",
+				c: []byte{'A'},
+				d: []byte{'B'},
+			},
+			expectPanic: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					if !tt.expectPanic {
+						t.Errorf("panic triggered when unexpected: %v", r)
+					}
+				} else {
+					if tt.expectPanic {
+						t.Error("panic not triggered when expected")
+					}
+				}
+			}()
+			tt.testSetup(tt.evFeed, t, tt.obj)
+			if gotNsent := tt.evFeed.Send(tt.obj); gotNsent != 1 {
+				t.Errorf("Send() = %v, want %v", gotNsent, 1)
+			}
+		})
+	}
+}
+
+// The following objects below are a collection of different
+// struct types to test with.
+type testFeed struct {
+	a uint64
+	b string
+}
+
+func (testFeed) method1() {
+
+}
+
+func (testFeed) method2() {
+
+}
+
+type testFeedWithPointer struct {
+	a *uint64
+	b *string
+}
+
+type testFeed2 struct {
+	a uint64
+	b string
+	c []byte
+}
+
+func (testFeed2) method1() {
+
+}
+
+type testFeed3 struct {
+	a    uint64
+	b    string
+	c, d []byte
+}
+
+func (testFeed3) method1() {
+
+}
+
+func (testFeed3) method2() {
+
+}
+
+func (testFeed3) method3() {
+
+}
+
+type testFeedIface interface {
+	method1()
+	method2()
+}

async/event/interface.go

@@ -1,8 +0,0 @@
-package event
-
-// SubscriberSender is an abstract representation of an *event.Feed
-// to use in describing types that accept or return an *event.Feed.
-type SubscriberSender interface {
-	Subscribe(channel interface{}) Subscription
-	Send(value interface{}) (nsent int)
-}

async/event/subscription.go

@@ -28,6 +28,25 @@ import (
 // request backoff time.
 const waitQuotient = 10
 
+// Subscription represents a stream of events. The carrier of the events is typically a
+// channel, but isn't part of the interface.
+//
+// Subscriptions can fail while established. Failures are reported through an error
+// channel. It receives a value if there is an issue with the subscription (e.g. the
+// network connection delivering the events has been closed). Only one value will ever be
+// sent.
+//
+// The error channel is closed when the subscription ends successfully (i.e. when the
+// source of events is closed). It is also closed when Unsubscribe is called.
+//
+// The Unsubscribe method cancels the sending of events. You must call Unsubscribe in all
+// cases to ensure that resources related to the subscription are released. It can be
+// called any number of times.
+type Subscription interface {
+	Err() <-chan error // returns the error channel
+	Unsubscribe()      // cancels sending of events, closing the error channel
+}
+
 // NewSubscription runs a producer function as a subscription in a new goroutine. The
 // channel given to the producer is closed when Unsubscribe is called. If fn returns an
 // error, it is sent on the subscription's error channel.

beacon-chain/blockchain/BUILD.bazel

@@ -25,7 +25,6 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
-        "receive_data_column.go",
         "service.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
@@ -49,7 +48,6 @@ go_library(
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -83,7 +81,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
@@ -99,6 +96,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )
@@ -159,7 +157,6 @@ go_test(
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
-        "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -12,14 +12,13 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/forkchoice"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -45,7 +44,7 @@ type ForkchoiceFetcher interface {
 	UpdateHead(context.Context, primitives.Slot)
 	HighestReceivedBlockSlot() primitives.Slot
 	ReceivedBlocksLastEpoch() (uint64, error)
-	InsertNode(context.Context, state.BeaconState, consensus_blocks.ROBlock) error
+	InsertNode(context.Context, state.BeaconState, [32]byte) error
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
 	NewSlot(context.Context, primitives.Slot) error
 	ProposerBoost() [32]byte
@@ -204,7 +203,7 @@ func (s *Service) HeadState(ctx context.Context) (state.BeaconState, error) {
 	defer s.headLock.RUnlock()
 
 	ok := s.hasHeadState()
-	span.SetAttributes(trace.BoolAttribute("cache_hit", ok))
+	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
 
 	if ok {
 		return s.headState(ctx), nil
@@ -226,7 +225,7 @@ func (s *Service) HeadStateReadOnly(ctx context.Context) (state.ReadOnlyBeaconSt
 	defer s.headLock.RUnlock()
 
 	ok := s.hasHeadState()
-	span.SetAttributes(trace.BoolAttribute("cache_hit", ok))
+	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
 
 	if ok {
 		return s.headStateReadOnly(ctx), nil
@@ -243,7 +242,7 @@ func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch primitives.Ep
 	if !s.hasHeadState() {
 		return []primitives.ValidatorIndex{}, nil
 	}
-	return helpers.ActiveValidatorIndices(ctx, s.headStateReadOnly(ctx), epoch)
+	return helpers.ActiveValidatorIndices(ctx, s.headState(ctx), epoch)
 }
 
 // HeadGenesisValidatorsRoot returns genesis validators root of the head state.

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/forkchoice"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
@@ -45,10 +44,10 @@ func (s *Service) ReceivedBlocksLastEpoch() (uint64, error) {
 }
 
 // InsertNode is a wrapper for node insertion which is self locked
-func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, block consensus_blocks.ROBlock) error {
+func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, root [32]byte) error {
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, block)
+	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
 }
 
 // ForkChoiceDump returns the corresponding value from forkchoice

beacon-chain/blockchain/chain_info_test.go

@@ -13,7 +13,6 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
@@ -39,7 +38,7 @@ func prepareForkchoiceState(
 	payloadHash [32]byte,
 	justified *ethpb.Checkpoint,
 	finalized *ethpb.Checkpoint,
-) (state.BeaconState, consensus_blocks.ROBlock, error) {
+) (state.BeaconState, [32]byte, error) {
 	blockHeader := &ethpb.BeaconBlockHeader{
 		ParentRoot: parentRoot[:],
 	}
@@ -60,26 +59,7 @@ func prepareForkchoiceState(
 
 	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
 	st, err := state_native.InitializeFromProtoBellatrix(base)
-	if err != nil {
-		return nil, consensus_blocks.ROBlock{}, err
-	}
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot:       slot,
-			ParentRoot: parentRoot[:],
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &enginev1.ExecutionPayload{
-					BlockHash: payloadHash[:],
-				},
-			},
-		},
-	}
-	signed, err := blocks.NewSignedBeaconBlock(blk)
-	if err != nil {
-		return nil, consensus_blocks.ROBlock{}, err
-	}
-	roblock, err := consensus_blocks.NewROBlockWithRoot(signed, blockRoot)
-	return st, roblock, err
+	return st, blockRoot, err
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
@@ -142,9 +122,9 @@ func TestUnrealizedJustifiedBlockHash(t *testing.T) {
 	service := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: []byte{'j'}}
 	ofc := &ethpb.Checkpoint{Root: []byte{'f'}}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	service.cfg.ForkChoiceStore.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) { return []uint64{}, nil })
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{Epoch: 6, Root: [32]byte{'j'}}))
 
@@ -336,24 +316,24 @@ func TestService_ChainHeads(t *testing.T) {
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	roots, slots := c.ChainHeads()
 	require.Equal(t, 3, len(roots))
@@ -433,12 +413,12 @@ func TestService_IsOptimistic(t *testing.T) {
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
@@ -469,12 +449,12 @@ func TestService_IsOptimisticForRoot(t *testing.T) {
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
 	require.NoError(t, err)

beacon-chain/blockchain/error.go

@@ -33,7 +33,6 @@ var (
 )
 
 var errMaxBlobsExceeded = errors.New("Expected commitments in block exceeds MAX_BLOBS_PER_BLOCK")
-var errMaxDataColumnsExceeded = errors.New("Expected data columns for node exceeds NUMBER_OF_COLUMNS")
 
 // An invalid block is the block that fails state transition based on the core protocol rules.
 // The beacon node shall not be accepting nor building blocks that branch off from an invalid block.

beacon-chain/blockchain/execution_engine.go

@@ -2,15 +2,13 @@ package blockchain
 
 import (
 	"context"
+	"crypto/sha256"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -23,13 +21,15 @@ import (
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
+const blobCommitmentVersionKZG uint8 = 0x01
+
 var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
 
 // notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
@@ -39,7 +39,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	ctx, span := trace.StartSpan(ctx, "blockChain.notifyForkchoiceUpdate")
 	defer span.End()
 
-	if arg.headBlock == nil || arg.headBlock.IsNil() {
+	if arg.headBlock.IsNil() {
 		log.Error("Head block is nil")
 		return nil, nil
 	}
@@ -72,7 +72,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	if arg.attributes == nil {
 		arg.attributes = payloadattribute.EmptyWithVersion(headBlk.Version())
 	}
-	go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), arg)
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, arg.attributes)
 	if err != nil {
 		switch {
@@ -171,38 +170,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	return payloadID, nil
 }
 
-func firePayloadAttributesEvent(ctx context.Context, f event.SubscriberSender, cfg *fcuConfig) {
-	pidx, err := helpers.BeaconProposerIndex(ctx, cfg.headState)
-	if err != nil {
-		log.WithError(err).
-			WithField("head_root", cfg.headRoot[:]).
-			Error("Could not get proposer index for PayloadAttributes event")
-		return
-	}
-	evd := payloadattribute.EventData{
-		ProposerIndex:   pidx,
-		ProposalSlot:    cfg.headState.Slot(),
-		ParentBlockRoot: cfg.headRoot[:],
-		Attributer:      cfg.attributes,
-		HeadRoot:        cfg.headRoot,
-		HeadState:       cfg.headState,
-		HeadBlock:       cfg.headBlock,
-	}
-	if cfg.headBlock != nil && !cfg.headBlock.IsNil() {
-		headPayload, err := cfg.headBlock.Block().Body().Execution()
-		if err != nil {
-			log.WithError(err).Error("Could not get execution payload for head block")
-			return
-		}
-		evd.ParentBlockHash = headPayload.BlockHash()
-		evd.ParentBlockNumber = headPayload.BlockNumber()
-	}
-	f.Send(&feed.Event{
-		Type: statefeed.PayloadAttributes,
-		Data: evd,
-	})
-}
-
 // getPayloadHash returns the payload hash given the block root.
 // if the block is before bellatrix fork epoch, it returns the zero hash.
 func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, error) {
@@ -252,25 +219,17 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 	}
 
 	var lastValidHash []byte
-	var parentRoot *common.Hash
-	var versionedHashes []common.Hash
-	var requests *enginev1.ExecutionRequests
 	if blk.Version() >= version.Deneb {
+		var versionedHashes []common.Hash
 		versionedHashes, err = kzgCommitmentsToVersionedHashes(blk.Block().Body())
 		if err != nil {
 			return false, errors.Wrap(err, "could not get versioned hashes to feed the engine")
 		}
-		prh := common.Hash(blk.Block().ParentRoot())
-		parentRoot = &prh
+		pr := common.Hash(blk.Block().ParentRoot())
+		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr)
+	} else {
+		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, []common.Hash{}, &common.Hash{} /*empty version hashes and root before Deneb*/)
 	}
-	if blk.Version() >= version.Electra {
-		requests, err = blk.Block().Body().ExecutionRequests()
-		if err != nil {
-			return false, errors.Wrap(err, "could not get execution requests")
-		}
-	}
-	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests)
-
 	switch {
 	case err == nil:
 		newPayloadValidNodeCount.Inc()
@@ -443,7 +402,13 @@ func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([
 
 	versionedHashes := make([]common.Hash, len(commitments))
 	for i, commitment := range commitments {
-		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes[i] = ConvertKzgCommitmentToVersionedHash(commitment)
 	}
 	return versionedHashes, nil
 }
+
+func ConvertKzgCommitmentToVersionedHash(commitment []byte) common.Hash {
+	versionedHash := sha256.Sum256(commitment)
+	versionedHash[0] = blobCommitmentVersionKZG
+	return versionedHash
+}

beacon-chain/blockchain/execution_engine_test.go

@@ -1135,14 +1135,9 @@ func TestComputePayloadAttribute(t *testing.T) {
 	// Cache hit, advance state, no fee recipient
 	slot := primitives.Slot(1)
 	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
-	blk := util.NewBeaconBlockBellatrix()
-	signed, err := consensusblocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	roblock, err := consensusblocks.NewROBlockWithRoot(signed, [32]byte{'a'})
-	require.NoError(t, err)
 	cfg := &postBlockProcessConfig{
-		ctx:     ctx,
-		roblock: roblock,
+		ctx:       ctx,
+		blockRoot: [32]byte{'a'},
 	}
 	fcu := &fcuConfig{
 		headState:     st,

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -12,9 +12,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 func (s *Service) isNewHead(r [32]byte) bool {

beacon-chain/blockchain/head.go

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

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "kzg.go",
         "trusted_setup.go",
         "validation.go",
     ],
@@ -13,9 +12,6 @@ go_library(
     deps = [
         "//consensus-types/blocks:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
-        "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )

beacon-chain/blockchain/kzg/kzg.go

@@ -1,109 +0,0 @@
-package kzg
-
-import (
-	"errors"
-
-	ckzg4844 "github.com/ethereum/c-kzg-4844/v2/bindings/go"
-	"github.com/ethereum/go-ethereum/crypto/kzg4844"
-)
-
-// BytesPerBlob is the number of bytes in a single blob.
-const BytesPerBlob = ckzg4844.BytesPerBlob
-
-// Blob represents a serialized chunk of data.
-type Blob [BytesPerBlob]byte
-
-// BytesPerCell is the number of bytes in a single cell.
-const BytesPerCell = ckzg4844.BytesPerCell
-
-// Cell represents a chunk of an encoded Blob.
-type Cell [BytesPerCell]byte
-
-// Commitment represent a KZG commitment to a Blob.
-type Commitment [48]byte
-
-// Proof represents a KZG proof that attests to the validity of a Blob or parts of it.
-type Proof [48]byte
-
-// Bytes48 is a 48-byte array.
-type Bytes48 = ckzg4844.Bytes48
-
-// Bytes32 is a 32-byte array.
-type Bytes32 = ckzg4844.Bytes32
-
-// CellsAndProofs represents the Cells and Proofs corresponding to
-// a single blob.
-type CellsAndProofs struct {
-	Cells  []Cell
-	Proofs []Proof
-}
-
-func BlobToKZGCommitment(blob *Blob) (Commitment, error) {
-	comm, err := kzg4844.BlobToCommitment(kzg4844.Blob(*blob))
-	if err != nil {
-		return Commitment{}, err
-	}
-	return Commitment(comm), nil
-}
-
-func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) {
-	proof, err := kzg4844.ComputeBlobProof(kzg4844.Blob(*blob), kzg4844.Commitment(commitment))
-	if err != nil {
-		return [48]byte{}, err
-	}
-	return Proof(proof), nil
-}
-
-func ComputeCellsAndKZGProofs(blob *Blob) (CellsAndProofs, error) {
-	ckzgBlob := (*ckzg4844.Blob)(blob)
-	ckzgCells, ckzgProofs, err := ckzg4844.ComputeCellsAndKZGProofs(ckzgBlob)
-	if err != nil {
-		return CellsAndProofs{}, err
-	}
-
-	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
-}
-
-func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, cells []Cell, proofsBytes []Bytes48) (bool, error) {
-	// Convert `Cell` type to `ckzg4844.Cell`
-	ckzgCells := make([]ckzg4844.Cell, len(cells))
-	for i := range cells {
-		ckzgCells[i] = ckzg4844.Cell(cells[i])
-	}
-
-	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, ckzgCells, proofsBytes)
-}
-
-func RecoverCellsAndKZGProofs(cellIndices []uint64, partialCells []Cell) (CellsAndProofs, error) {
-	// Convert `Cell` type to `ckzg4844.Cell`
-	ckzgPartialCells := make([]ckzg4844.Cell, len(partialCells))
-	for i := range partialCells {
-		ckzgPartialCells[i] = ckzg4844.Cell(partialCells[i])
-	}
-
-	ckzgCells, ckzgProofs, err := ckzg4844.RecoverCellsAndKZGProofs(cellIndices, ckzgPartialCells)
-	if err != nil {
-		return CellsAndProofs{}, err
-	}
-
-	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
-}
-
-// Convert cells/proofs to the CellsAndProofs type defined in this package.
-func makeCellsAndProofs(ckzgCells []ckzg4844.Cell, ckzgProofs []ckzg4844.KZGProof) (CellsAndProofs, error) {
-	if len(ckzgCells) != len(ckzgProofs) {
-		return CellsAndProofs{}, errors.New("different number of cells/proofs")
-	}
-
-	var cells []Cell
-	var proofs []Proof
-	for i := range ckzgCells {
-		cells = append(cells, Cell(ckzgCells[i]))
-		proofs = append(proofs, Proof(ckzgProofs[i]))
-	}
-
-	return CellsAndProofs{
-		Cells:  cells,
-		Proofs: proofs,
-	}, nil
-}

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	CKZG "github.com/ethereum/c-kzg-4844/v2/bindings/go"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 )
 
@@ -14,53 +12,17 @@ var (
 	//go:embed trusted_setup.json
 	embeddedTrustedSetup []byte // 1.2Mb
 	kzgContext           *GoKZG.Context
-	kzgLoaded            bool
 )
 
-type TrustedSetup struct {
-	G1Monomial [GoKZG.ScalarsPerBlob]GoKZG.G1CompressedHexStr `json:"g1_monomial"`
-	G1Lagrange [GoKZG.ScalarsPerBlob]GoKZG.G1CompressedHexStr `json:"g1_lagrange"`
-	G2Monomial [65]GoKZG.G2CompressedHexStr                   `json:"g2_monomial"`
-}
-
 func Start() error {
-	trustedSetup := &TrustedSetup{}
-	err := json.Unmarshal(embeddedTrustedSetup, trustedSetup)
+	parsedSetup := GoKZG.JSONTrustedSetup{}
+	err := json.Unmarshal(embeddedTrustedSetup, &parsedSetup)
 	if err != nil {
 		return errors.Wrap(err, "could not parse trusted setup JSON")
 	}
-	kzgContext, err = GoKZG.NewContext4096(&GoKZG.JSONTrustedSetup{
-		SetupG2:         trustedSetup.G2Monomial[:],
-		SetupG1Lagrange: trustedSetup.G1Lagrange})
+	kzgContext, err = GoKZG.NewContext4096(&parsedSetup)
 	if err != nil {
 		return errors.Wrap(err, "could not initialize go-kzg context")
 	}
-
-	// Length of a G1 point, converted from hex to binary.
-	g1MonomialBytes := make([]byte, len(trustedSetup.G1Monomial)*(len(trustedSetup.G1Monomial[0])-2)/2)
-	for i, g1 := range &trustedSetup.G1Monomial {
-		copy(g1MonomialBytes[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
-	}
-	// Length of a G1 point, converted from hex to binary.
-	g1LagrangeBytes := make([]byte, len(trustedSetup.G1Lagrange)*(len(trustedSetup.G1Lagrange[0])-2)/2)
-	for i, g1 := range &trustedSetup.G1Lagrange {
-		copy(g1LagrangeBytes[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
-	}
-	// Length of a G2 point, converted from hex to binary.
-	g2MonomialBytes := make([]byte, len(trustedSetup.G2Monomial)*(len(trustedSetup.G2Monomial[0])-2)/2)
-	for i, g2 := range &trustedSetup.G2Monomial {
-		copy(g2MonomialBytes[i*(len(g2)-2)/2:], hexutil.MustDecode(g2))
-	}
-	if !kzgLoaded {
-		// TODO: Provide a configuration option for this.
-		var precompute uint = 8
-
-		// Free the current trusted setup before running this method. CKZG
-		// panics if the same setup is run multiple times.
-		if err = CKZG.LoadTrustedSetup(g1MonomialBytes, g1LagrangeBytes, g2MonomialBytes, precompute); err != nil {
-			panic(err)
-		}
-	}
-	kzgLoaded = true
 	return nil
 }

beacon-chain/blockchain/options.go

@@ -118,9 +118,9 @@ func WithBLSToExecPool(p blstoexec.PoolManager) Option {
 }
 
 // WithP2PBroadcaster to broadcast messages after appropriate processing.
-func WithP2PBroadcaster(p p2p.Acceser) Option {
+func WithP2PBroadcaster(p p2p.Broadcaster) Option {
 	return func(s *Service) error {
-		s.cfg.P2P = p
+		s.cfg.P2p = p
 		return nil
 	}
 }

beacon-chain/blockchain/pow_block.go

@@ -46,7 +46,7 @@ func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.ReadOnlyS
 	if err != nil {
 		return err
 	}
-	if payload == nil || payload.IsNil() {
+	if payload.IsNil() {
 		return errors.New("nil execution payload")
 	}
 	ok, err := canUseValidatedTerminalBlockHash(b.Block().Slot(), payload)

beacon-chain/blockchain/process_attestation.go

@@ -7,10 +7,10 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // OnAttestation is called whenever an attestation is received, verifies the attestation is valid and saves

beacon-chain/blockchain/process_attestation_test.go

@@ -32,18 +32,18 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	util.SaveBlock(t, ctx, beaconDB, blkWithoutState)
 
 	cp := &ethpb.Checkpoint{}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	blkWithStateBadAtt := util.NewBeaconBlock()
 	blkWithStateBadAtt.Block.Slot = 1
 	r, err := blkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 	cp = &ethpb.Checkpoint{Root: r[:]}
-	st, roblock, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
+	st, blkRoot, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	util.SaveBlock(t, ctx, beaconDB, blkWithStateBadAtt)
 	BlkWithStateBadAttRoot, err := blkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -92,12 +92,12 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 		{
 			name:      "process nil attestation",
 			a:         nil,
-			wantedErr: "attestation is nil",
+			wantedErr: "attestation can't be nil",
 		},
 		{
 			name:      "process nil field (a.Data) in attestation",
 			a:         &ethpb.Attestation{},
-			wantedErr: "attestation is nil",
+			wantedErr: "attestation's data can't be nil",
 		},
 		{
 			name: "process nil field (a.Target) in attestation",
@@ -139,9 +139,9 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 		ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
 		ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-		state, roblock, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, roblock))
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		require.NoError(t, service.OnAttestation(ctx, att[0], 0))
 	}
 
@@ -318,9 +318,10 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r1[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
-	st, roblock, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, checkpoint, checkpoint)
+	st, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, checkpoint, checkpoint)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, r1))
 	returned, err := service.getAttPreState(ctx, checkpoint)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch.Mul(uint64(checkpoint.Epoch)), returned.Slot(), "Incorrectly returned base state")
@@ -336,9 +337,10 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r2[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
-	st, roblock, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, newCheckpoint, newCheckpoint)
+	st, blkRoot, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, newCheckpoint, newCheckpoint)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, r2))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)
 	require.NoError(t, err)
 	s, err := slots.EpochStart(newCheckpoint.Epoch)

beacon-chain/blockchain/process_block.go

@@ -3,13 +3,13 @@ package blockchain
 import (
 	"context"
 	"fmt"
-	"slices"
 	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
@@ -25,12 +25,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // A custom slot deadline for processing state slots in our cache.
@@ -46,7 +46,8 @@ var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 // process the beacon block after validating the state transition function
 type postBlockProcessConfig struct {
 	ctx            context.Context
-	roblock        consensusblocks.ROBlock
+	signed         interfaces.ReadOnlySignedBeaconBlock
+	blockRoot      [32]byte
 	headRoot       [32]byte
 	postState      state.BeaconState
 	isValidPayload bool
@@ -60,7 +61,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	ctx, span := trace.StartSpan(cfg.ctx, "blockChain.onBlock")
 	defer span.End()
 	cfg.ctx = ctx
-	if err := consensusblocks.BeaconBlockIsNil(cfg.roblock); err != nil {
+	if err := consensusblocks.BeaconBlockIsNil(cfg.signed); err != nil {
 		return invalidBlock{error: err}
 	}
 	startTime := time.Now()
@@ -72,22 +73,19 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	defer s.sendLightClientFeeds(cfg)
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)
-	defer reportAttestationInclusion(cfg.roblock.Block())
+	defer reportAttestationInclusion(cfg.signed.Block())
 
-	err := s.cfg.ForkChoiceStore.InsertNode(ctx, cfg.postState, cfg.roblock)
+	err := s.cfg.ForkChoiceStore.InsertNode(ctx, cfg.postState, cfg.blockRoot)
 	if err != nil {
-		// Do not use parent context in the event it deadlined
-		ctx = trace.NewContext(context.Background(), span)
-		s.rollbackBlock(ctx, cfg.roblock.Root())
-		return errors.Wrapf(err, "could not insert block %d to fork choice store", cfg.roblock.Block().Slot())
+		return errors.Wrapf(err, "could not insert block %d to fork choice store", cfg.signed.Block().Slot())
 	}
-	if err := s.handleBlockAttestations(ctx, cfg.roblock.Block(), cfg.postState); err != nil {
+	if err := s.handleBlockAttestations(ctx, cfg.signed.Block(), cfg.postState); err != nil {
 		return errors.Wrap(err, "could not handle block's attestations")
 	}
 
-	s.InsertSlashingsToForkChoiceStore(ctx, cfg.roblock.Block().Body().AttesterSlashings())
+	s.InsertSlashingsToForkChoiceStore(ctx, cfg.signed.Block().Body().AttesterSlashings())
 	if cfg.isValidPayload {
-		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, cfg.roblock.Root()); err != nil {
+		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, cfg.blockRoot); err != nil {
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
@@ -97,8 +95,8 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		log.WithError(err).Warn("Could not update head")
 	}
 	newBlockHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
-	if cfg.headRoot != cfg.roblock.Root() {
-		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
+	if cfg.headRoot != cfg.blockRoot {
+		s.logNonCanonicalBlockReceived(cfg.blockRoot, cfg.headRoot)
 		return nil
 	}
 	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
@@ -156,7 +154,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	}
 
 	// Fill in missing blocks
-	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0], preState.CurrentJustifiedCheckpoint(), preState.FinalizedCheckpoint()); err != nil {
+	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0].Block(), preState.CurrentJustifiedCheckpoint(), preState.FinalizedCheckpoint()); err != nil {
 		return errors.Wrap(err, "could not fill in missing blocks to forkchoice")
 	}
 
@@ -233,12 +231,10 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 				return err
 			}
 		}
-
-		nodeID := s.cfg.P2P.NodeID()
-		if err := avs.IsDataAvailable(ctx, nodeID, s.CurrentSlot(), b); err != nil {
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), b); err != nil {
 			return errors.Wrapf(err, "could not validate blob data availability at slot %d", b.Block().Slot())
 		}
-		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
+		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
 		pendingNodes[len(blks)-i-1] = args
@@ -283,7 +279,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 		return errors.Wrap(err, "could not insert batch to forkchoice")
 	}
 	// Insert the last block to forkchoice
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastB); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastBR); err != nil {
 		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
 	}
 	// Set their optimistic status
@@ -408,10 +404,6 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 		return errors.Wrapf(err, "could not save block from slot %d", b.Block().Slot())
 	}
 	if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-		log.Warnf("Rolling back insertion of block with root %#x", r)
-		if err := s.cfg.BeaconDB.DeleteBlock(ctx, r); err != nil {
-			log.WithError(err).Errorf("Could not delete block with block root %#x", r)
-		}
 		return errors.Wrap(err, "could not save state")
 	}
 	return nil
@@ -507,7 +499,7 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 	}
 	indices, err := bs.Indices(root)
 	if err != nil {
-		return nil, errors.Wrap(err, "indices")
+		return nil, err
 	}
 	missing := make(map[uint64]struct{}, len(expected))
 	for i := range expected {
@@ -521,40 +513,12 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 	return missing, nil
 }
 
-func missingDataColumns(bs *filesystem.BlobStorage, root [32]byte, expected map[uint64]bool) (map[uint64]bool, error) {
-	if len(expected) == 0 {
-		return nil, nil
-	}
-
-	if len(expected) > int(params.BeaconConfig().NumberOfColumns) {
-		return nil, errMaxDataColumnsExceeded
-	}
-
-	indices, err := bs.ColumnIndices(root)
-	if err != nil {
-		return nil, err
-	}
-
-	missing := make(map[uint64]bool, len(expected))
-	for col := range expected {
-		if !indices[col] {
-			missing[col] = true
-		}
-	}
-
-	return missing, nil
-}
-
 // isDataAvailable blocks until all BlobSidecars committed to in the block are available,
 // or an error or context cancellation occurs. A nil result means that the data availability check is successful.
 // The function will first check the database to see if all sidecars have been persisted. If any
 // sidecars are missing, it will then read from the blobNotifier channel for the given root until the channel is
 // closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
 func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
-	if coreTime.PeerDASIsActive(signed.Block().Slot()) {
-		return s.areDataColumnsAvailable(ctx, root, signed)
-	}
-
 	if signed.Version() < version.Deneb {
 		return nil
 	}
@@ -584,7 +548,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	// get a map of BlobSidecar indices that are not currently available.
 	missing, err := missingIndices(s.blobStorage, root, kzgCommitments)
 	if err != nil {
-		return errors.Wrap(err, "missing indices")
+		return err
 	}
 	// If there are no missing indices, all BlobSidecars are available.
 	if len(missing) == 0 {
@@ -603,13 +567,8 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 			if len(missing) == 0 {
 				return
 			}
-
-			log.WithFields(logrus.Fields{
-				"slot":          signed.Block().Slot(),
-				"root":          fmt.Sprintf("%#x", root),
-				"blobsExpected": expected,
-				"blobsWaiting":  len(missing),
-			}).Error("Still waiting for blobs DA check at slot end.")
+			log.WithFields(daCheckLogFields(root, signed.Block().Slot(), expected, len(missing))).
+				Error("Still waiting for DA check at slot end.")
 		})
 		defer nst.Stop()
 	}
@@ -631,166 +590,12 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	}
 }
 
-// uint64MapToSortedSlice produces a sorted uint64 slice from a map.
-func uint64MapToSortedSlice(input map[uint64]bool) []uint64 {
-	output := make([]uint64, 0, len(input))
-	for idx := range input {
-		output = append(output, idx)
-	}
-	slices.Sort[[]uint64](output)
-	return output
-}
-
-func (s *Service) areDataColumnsAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
-	if signed.Version() < version.Deneb {
-		return nil
-	}
-
-	block := signed.Block()
-	if block == nil {
-		return errors.New("invalid nil beacon block")
-	}
-	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
-	if !params.WithinDAPeriod(slots.ToEpoch(block.Slot()), slots.ToEpoch(s.CurrentSlot())) {
-		return nil
-	}
-
-	body := block.Body()
-	if body == nil {
-		return errors.New("invalid nil beacon block body")
-	}
-
-	kzgCommitments, err := body.BlobKzgCommitments()
-	if err != nil {
-		return errors.Wrap(err, "blob KZG commitments")
-	}
-
-	// If block has not commitments there is nothing to wait for.
-	if len(kzgCommitments) == 0 {
-		return nil
-	}
-
-	// All columns to sample need to be available for the block to be considered available.
-	// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#subnet-sampling
-	nodeID := s.cfg.P2P.NodeID()
-	subnetSamplingSize := peerdas.SubnetSamplingSize()
-
-	colMap, err := peerdas.CustodyColumns(nodeID, subnetSamplingSize)
-	if err != nil {
-		return errors.Wrap(err, "custody columns")
-	}
-
-	// colMap represents the data columnns a node is expected to custody.
-	if len(colMap) == 0 {
-		return nil
-	}
-
-	// Subscribe to newsly data columns stored in the database.
-	rootIndexChan := make(chan filesystem.RootIndexPair)
-	subscription := s.blobStorage.DataColumnFeed.Subscribe(rootIndexChan)
-	defer subscription.Unsubscribe()
-
-	// Get the count of data columns we already have in the store.
-	retrievedDataColumns, err := s.blobStorage.ColumnIndices(root)
-	if err != nil {
-		return errors.Wrap(err, "column indices")
-	}
-
-	retrievedDataColumnsCount := uint64(len(retrievedDataColumns))
-
-	// As soon as we have more than half of the data columns, we can reconstruct the missing ones.
-	// We don't need to wait for the rest of the data columns to declare the block as available.
-	if peerdas.CanSelfReconstruct(retrievedDataColumnsCount) {
-		return nil
-	}
-
-	// Get a map of data column indices that are not currently available.
-	missingMap, err := missingDataColumns(s.blobStorage, root, colMap)
-	if err != nil {
-		return err
-	}
-
-	// If there are no missing indices, all data column sidecars are available.
-	// This is the happy path.
-	if len(missingMap) == 0 {
-		return nil
-	}
-
-	// Log for DA checks that cross over into the next slot; helpful for debugging.
-	nextSlot := slots.BeginsAt(signed.Block().Slot()+1, s.genesisTime)
-	// Avoid logging if DA check is called after next slot start.
-	if nextSlot.After(time.Now()) {
-		nst := time.AfterFunc(time.Until(nextSlot), func() {
-			missingMapCount := uint64(len(missingMap))
-
-			if missingMapCount == 0 {
-				return
-			}
-
-			var (
-				expected interface{} = "all"
-				missing  interface{} = "all"
-			)
-
-			numberOfColumns := params.BeaconConfig().NumberOfColumns
-			colMapCount := uint64(len(colMap))
-
-			if colMapCount < numberOfColumns {
-				expected = uint64MapToSortedSlice(colMap)
-			}
-
-			if missingMapCount < numberOfColumns {
-				missing = uint64MapToSortedSlice(missingMap)
-			}
-
-			log.WithFields(logrus.Fields{
-				"slot":            signed.Block().Slot(),
-				"root":            fmt.Sprintf("%#x", root),
-				"columnsExpected": expected,
-				"columnsWaiting":  missing,
-			}).Error("Some data columns are still unavailable at slot end")
-		})
-
-		defer nst.Stop()
-	}
-
-	for {
-		select {
-		case rootIndex := <-rootIndexChan:
-			if rootIndex.Root != root {
-				// This is not the root we are looking for.
-				continue
-			}
-
-			// This is a data column we are expecting.
-			if _, ok := missingMap[rootIndex.Index]; ok {
-				retrievedDataColumnsCount++
-			}
-
-			// As soon as we have more than half of the data columns, we can reconstruct the missing ones.
-			// We don't need to wait for the rest of the data columns to declare the block as available.
-			if peerdas.CanSelfReconstruct(retrievedDataColumnsCount) {
-				return nil
-			}
-
-			// Remove the index from the missing map.
-			delete(missingMap, rootIndex.Index)
-
-			// Exit if there is no more missing data columns.
-			if len(missingMap) == 0 {
-				return nil
-			}
-		case <-ctx.Done():
-			var missingIndices interface{} = "all"
-			numberOfColumns := params.BeaconConfig().NumberOfColumns
-			missingIndicesCount := uint64(len(missingMap))
-
-			if missingIndicesCount < numberOfColumns {
-				missingIndices = uint64MapToSortedSlice(missingMap)
-			}
-
-			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndices)
-		}
+func daCheckLogFields(root [32]byte, slot primitives.Slot, expected, missing int) logrus.Fields {
+	return logrus.Fields{
+		"slot":          slot,
+		"root":          fmt.Sprintf("%#x", root),
+		"blobsExpected": expected,
+		"blobsWaiting":  missing,
 	}
 }
 
@@ -809,6 +614,9 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if !s.inRegularSync() {
 		return
 	}
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.MissedSlot,
+	})
 	s.headLock.RLock()
 	headRoot := s.headRoot()
 	headState := s.headState(ctx)
@@ -836,13 +644,6 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	attribute := s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
 	// return early if we are not proposing next slot
 	if attribute.IsEmpty() {
-		fcuArgs := &fcuConfig{
-			headState:  headState,
-			headRoot:   headRoot,
-			headBlock:  nil,
-			attributes: attribute,
-		}
-		go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), fcuArgs)
 		return
 	}
 
@@ -877,21 +678,9 @@ func (s *Service) waitForSync() error {
 	}
 }
 
-func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot, parentRoot [32]byte) error {
+func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot [32]byte, parentRoot [32]byte) error {
 	if IsInvalidBlock(err) && InvalidBlockLVH(err) != [32]byte{} {
 		return s.pruneInvalidBlock(ctx, blockRoot, parentRoot, InvalidBlockLVH(err))
 	}
 	return err
 }
-
-// In the event of an issue processing a block we rollback changes done to the db and our caches
-// to always ensure that the node's internal state is consistent.
-func (s *Service) rollbackBlock(ctx context.Context, blockRoot [32]byte) {
-	log.Warnf("Rolling back insertion of block with root %#x due to processing error", blockRoot)
-	if err := s.cfg.StateGen.DeleteStateFromCaches(ctx, blockRoot); err != nil {
-		log.WithError(err).Errorf("Could not delete state from caches with block root %#x", blockRoot)
-	}
-	if err := s.cfg.BeaconDB.DeleteBlock(ctx, blockRoot); err != nil {
-		log.WithError(err).Errorf("Could not delete block with block root %#x", blockRoot)
-	}
-}

beacon-chain/blockchain/process_block_helpers.go

@@ -18,16 +18,15 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.
@@ -43,7 +42,7 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 	if !s.inRegularSync() {
 		return nil
 	}
-	slot := cfg.roblock.Block().Slot()
+	slot := cfg.signed.Block().Slot()
 	if slots.WithinVotingWindow(uint64(s.genesisTime.Unix()), slot) {
 		return nil
 	}
@@ -51,9 +50,9 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 }
 
 func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
-	if cfg.roblock.Root() == cfg.headRoot {
+	if cfg.blockRoot == cfg.headRoot {
 		fcuArgs.headState = cfg.postState
-		fcuArgs.headBlock = cfg.roblock
+		fcuArgs.headBlock = cfg.signed
 		fcuArgs.headRoot = cfg.headRoot
 		fcuArgs.proposingSlot = s.CurrentSlot() + 1
 		return nil
@@ -97,7 +96,7 @@ func (s *Service) fcuArgsNonCanonicalBlock(cfg *postBlockProcessConfig, fcuArgs
 
 // sendStateFeedOnBlock sends an event that a new block has been synced
 func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(cfg.roblock.Root())
+	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(cfg.blockRoot)
 	if err != nil {
 		log.WithError(err).Debug("Could not check if block is optimistic")
 		optimistic = true
@@ -106,9 +105,9 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			Slot:        cfg.roblock.Block().Slot(),
-			BlockRoot:   cfg.roblock.Root(),
-			SignedBlock: cfg.roblock,
+			Slot:        cfg.signed.Block().Slot(),
+			BlockRoot:   cfg.blockRoot,
+			SignedBlock: cfg.signed,
 			Verified:    true,
 			Optimistic:  optimistic,
 		},
@@ -118,7 +117,7 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 // sendLightClientFeeds sends the light client feeds when feature flag is enabled.
 func (s *Service) sendLightClientFeeds(cfg *postBlockProcessConfig) {
 	if features.Get().EnableLightClient {
-		if _, err := s.sendLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
+		if _, err := s.sendLightClientOptimisticUpdate(cfg.ctx, cfg.signed, cfg.postState); err != nil {
 			log.WithError(err).Error("Failed to send light client optimistic update")
 		}
 
@@ -126,7 +125,7 @@ func (s *Service) sendLightClientFeeds(cfg *postBlockProcessConfig) {
 		finalized := s.ForkChoicer().FinalizedCheckpoint()
 
 		// LightClientFinalityUpdate needs super majority
-		s.tryPublishLightClientFinalityUpdate(cfg.ctx, cfg.roblock, finalized, cfg.postState)
+		s.tryPublishLightClientFinalityUpdate(cfg.ctx, cfg.signed, finalized, cfg.postState)
 	}
 }
 
@@ -163,10 +162,6 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	postState state.BeaconState) (int, error) {
 	// Get attested state
 	attestedRoot := signed.Block().ParentRoot()
-	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested block")
-	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get attested state")
@@ -188,7 +183,6 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		postState,
 		signed,
 		attestedState,
-		attestedBlock,
 		finalizedBlock,
 	)
 
@@ -199,7 +193,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	// Return the result
 	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    update,
+		Data:    lightclient.CreateLightClientFinalityUpdate(update),
 	}
 
 	// Send event
@@ -214,10 +208,6 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	postState state.BeaconState) (int, error) {
 	// Get attested state
 	attestedRoot := signed.Block().ParentRoot()
-	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested block")
-	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get attested state")
@@ -228,7 +218,6 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 		postState,
 		signed,
 		attestedState,
-		attestedBlock,
 	)
 
 	if err != nil {
@@ -238,7 +227,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	// Return the result
 	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    update,
+		Data:    lightclient.CreateLightClientOptimisticUpdate(update),
 	}
 
 	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
@@ -253,21 +242,20 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 // before sending FCU to the engine.
 func (s *Service) updateCachesPostBlockProcessing(cfg *postBlockProcessConfig) error {
 	slot := cfg.postState.Slot()
-	root := cfg.roblock.Root()
-	if err := transition.UpdateNextSlotCache(cfg.ctx, root[:], cfg.postState); err != nil {
+	if err := transition.UpdateNextSlotCache(cfg.ctx, cfg.blockRoot[:], cfg.postState); err != nil {
 		return errors.Wrap(err, "could not update next slot state cache")
 	}
 	if !slots.IsEpochEnd(slot) {
 		return nil
 	}
-	return s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, root[:])
+	return s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, cfg.blockRoot[:])
 }
 
 // handleSecondFCUCall handles a second call to FCU when syncing a new block.
 // This is useful when proposing in the next block and we want to defer the
 // computation of the next slot shuffling.
 func (s *Service) handleSecondFCUCall(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
-	if (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) && cfg.headRoot == cfg.roblock.Root() {
+	if (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) && cfg.headRoot == cfg.blockRoot {
 		go s.sendFCUWithAttributes(cfg, fcuArgs)
 	}
 }
@@ -283,7 +271,7 @@ func reportProcessingTime(startTime time.Time) {
 // called on blocks that arrive after the attestation voting window, or in a
 // background routine after syncing early blocks.
 func (s *Service) computePayloadAttributes(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
-	if cfg.roblock.Root() == cfg.headRoot {
+	if cfg.blockRoot == cfg.headRoot {
 		if err := s.updateCachesPostBlockProcessing(cfg); err != nil {
 			return err
 		}
@@ -440,7 +428,7 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot primitives.
 
 // This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
 // This is useful for block tree visualizer and additional vote accounting.
-func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock,
 	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, 0)
 
@@ -450,15 +438,10 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 	if err != nil {
 		return err
 	}
-	// The first block can have a bogus root since the block is not inserted in forkchoice
-	roblock, err := consensus_blocks.NewROBlockWithRoot(signed, [32]byte{})
-	if err != nil {
-		return err
-	}
-	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: blk,
 		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
 	// As long as parent node is not in fork choice store, and parent node is in DB.
-	root := roblock.Block().ParentRoot()
+	root := blk.ParentRoot()
 	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
 		b, err := s.getBlock(ctx, root)
 		if err != nil {
@@ -467,12 +450,8 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 		if b.Block().Slot() <= fSlot {
 			break
 		}
-		roblock, err := consensus_blocks.NewROBlockWithRoot(b, root)
-		if err != nil {
-			return err
-		}
 		root = b.Block().ParentRoot()
-		args := &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
 			JustifiedCheckpoint: jCheckpoint,
 			FinalizedCheckpoint: fCheckpoint}
 		pendingNodes = append(pendingNodes, args)

beacon-chain/blockchain/process_block_test.go

@@ -145,8 +145,9 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fcp2))
+
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -189,7 +190,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fcp2))
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -245,7 +246,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	// Set finalized epoch to 2.
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 2, Root: r64}))
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// There should be 1 node: block 65
@@ -278,7 +279,7 @@ func TestFillForkChoiceMissingBlocks_FinalizedSibling(t *testing.T) {
 	require.NoError(t, err)
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.Equal(t, ErrNotDescendantOfFinalized.Error(), err.Error())
 }
 
@@ -565,9 +566,7 @@ func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, r, [32]byte{}, postState, true}))
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -615,9 +614,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, r, [32]byte{}, postState, true}))
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -643,9 +640,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 
 func TestOnBlock_NilBlock(t *testing.T) {
 	service, tr := minimalTestService(t)
-	signed := &consensusblocks.SignedBeaconBlock{}
-	roblock := consensusblocks.ROBlock{ReadOnlySignedBeaconBlock: signed}
-	err := service.postBlockProcess(&postBlockProcessConfig{tr.ctx, roblock, [32]byte{}, nil, true})
+	err := service.postBlockProcess(&postBlockProcessConfig{tr.ctx, nil, [32]byte{}, [32]byte{}, nil, true})
 	require.Equal(t, true, IsInvalidBlock(err))
 }
 
@@ -693,9 +688,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, r, [32]byte{}, postState, false}))
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1121,9 +1114,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			postState, err := service.validateStateTransition(ctx, preState, wsb1)
 			require.NoError(t, err)
 			lock.Lock()
-			roblock, err := consensusblocks.NewROBlockWithRoot(wsb1, r1)
-			require.NoError(t, err)
-			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb1, r1, [32]byte{}, postState, true}))
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1133,9 +1124,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			postState, err := service.validateStateTransition(ctx, preState, wsb2)
 			require.NoError(t, err)
 			lock.Lock()
-			roblock, err := consensusblocks.NewROBlockWithRoot(wsb2, r2)
-			require.NoError(t, err)
-			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb2, r2, [32]byte{}, postState, true}))
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1145,9 +1134,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			postState, err := service.validateStateTransition(ctx, preState, wsb3)
 			require.NoError(t, err)
 			lock.Lock()
-			roblock, err := consensusblocks.NewROBlockWithRoot(wsb3, r3)
-			require.NoError(t, err)
-			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb3, r3, [32]byte{}, postState, true}))
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1157,9 +1144,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			postState, err := service.validateStateTransition(ctx, preState, wsb4)
 			require.NoError(t, err)
 			lock.Lock()
-			roblock, err := consensusblocks.NewROBlockWithRoot(wsb4, r4)
-			require.NoError(t, err)
-			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb4, r4, [32]byte{}, postState, true}))
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1234,9 +1219,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1254,9 +1237,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 
@@ -1275,9 +1256,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
@@ -1299,9 +1278,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, firstInvalidRoot, wsb, postState))
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, firstInvalidRoot)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, firstInvalidRoot, [32]byte{}, postState, false})
 	require.NoError(t, err)
 	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
@@ -1329,9 +1306,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	postState, err = service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 	// Check that forkchoice's head is the last invalid block imported. The
 	// store's headroot is the previous head (since the invalid block did
@@ -1360,9 +1335,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	postState, err = service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, true})
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
@@ -1424,9 +1397,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1444,9 +1415,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 
@@ -1466,9 +1435,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
@@ -1490,9 +1457,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, firstInvalidRoot, wsb, postState))
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, firstInvalidRoot)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, firstInvalidRoot, [32]byte{}, postState, false})
 	require.NoError(t, err)
 	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
@@ -1520,9 +1485,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, err)
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	require.NoError(t, err)
-	rowsb, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, rowsb)
+	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, wsb, root)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 	// Check that forkchoice's head and store's headroot are the previous head (since the invalid block did
 	// not finish importing and it was never imported to forkchoice). Check
@@ -1550,9 +1513,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	postState, err = service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, true})
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
@@ -1617,9 +1578,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1638,9 +1597,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 
@@ -1659,9 +1616,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, lastValidRoot, wsb, postState))
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, lastValidRoot)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, lastValidRoot, [32]byte{}, postState, false})
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1688,9 +1643,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, invalidRoots[i-13], wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, invalidRoots[i-13])
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, invalidRoots[i-13], [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 	// Check that we have justified the second epoch
@@ -1716,9 +1669,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	require.NoError(t, err)
-	rowsb, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, rowsb)
+	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, wsb, root)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 
 	// Check that forkchoice's head and store's headroot are the previous head (since the invalid block did
@@ -1757,9 +1708,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	postState, err = service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
+	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, true}))
 	// Check that the head is still INVALID and the node is still optimistic
 	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	optimistic, err = service.IsOptimistic(ctx)
@@ -1782,9 +1731,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, true})
 		require.NoError(t, err)
 		st, err = service.cfg.StateGen.StateByRoot(ctx, root)
 		require.NoError(t, err)
@@ -1810,9 +1757,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	postState, err = service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, true})
 	require.NoError(t, err)
 	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
@@ -1868,9 +1813,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1888,9 +1831,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false})
 		require.NoError(t, err)
 	}
 
@@ -1909,9 +1850,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, lastValidRoot, wsb, postState))
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, lastValidRoot)
-	require.NoError(t, err)
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, lastValidRoot, [32]byte{}, postState, false})
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1940,9 +1879,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -1968,9 +1905,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, err)
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	require.NoError(t, err)
-	rowsb, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, rowsb)
+	_, err = service.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, wsb, root)
 	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
 
 	// Check that the headroot/state are not in DB and restart the node
@@ -2060,9 +1995,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
@@ -2126,9 +2059,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		postState, err := service.validateStateTransition(ctx, preState, wsb)
 		require.NoError(t, err)
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-		require.NoError(t, err)
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, root, [32]byte{}, postState, false}))
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
@@ -2278,11 +2209,11 @@ func Test_getFCUArgs(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, [32]byte{'a'})
-	require.NoError(t, err)
+
 	cfg := &postBlockProcessConfig{
 		ctx:            ctx,
-		roblock:        roblock,
+		signed:         wsb,
+		blockRoot:      [32]byte{'a'},
 		postState:      st,
 		isValidPayload: true,
 	}
@@ -2292,143 +2223,11 @@ func Test_getFCUArgs(t *testing.T) {
 	require.ErrorContains(t, "block does not exist", err)
 
 	// canonical branch
-	cfg.headRoot = cfg.roblock.Root()
+	cfg.headRoot = cfg.blockRoot
 	fcuArgs = &fcuConfig{}
 	err = s.getFCUArgs(cfg, fcuArgs)
 	require.NoError(t, err)
-	require.Equal(t, cfg.roblock.Root(), fcuArgs.headRoot)
-}
-
-func TestRollbackBlock(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
-
-	st, keys := util.DeterministicGenesisState(t, 64)
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	require.NoError(t, service.saveGenesisData(ctx, st))
-
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
-
-	st, err = service.HeadState(ctx)
-	require.NoError(t, err)
-	b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	root, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	preState, err := service.getBlockPreState(ctx, wsb.Block())
-	require.NoError(t, err)
-	postState, err := service.validateStateTransition(ctx, preState, wsb)
-	require.NoError(t, err)
-	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-
-	require.Equal(t, true, service.cfg.BeaconDB.HasBlock(ctx, root))
-	hasState, err := service.cfg.StateGen.HasState(ctx, root)
-	require.NoError(t, err)
-	require.Equal(t, true, hasState)
-
-	// Set invalid parent root to trigger forkchoice error.
-	wsb.SetParentRoot([]byte("bad"))
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-
-	// Rollback block insertion into db and caches.
-	require.ErrorContains(t, fmt.Sprintf("could not insert block %d to fork choice store", roblock.Block().Slot()), service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-
-	// The block should no longer exist.
-	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
-	hasState, err = service.cfg.StateGen.HasState(ctx, root)
-	require.NoError(t, err)
-	require.Equal(t, false, hasState)
-}
-
-func TestRollbackBlock_ContextDeadline(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
-
-	st, keys := util.DeterministicGenesisState(t, 64)
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	require.NoError(t, service.saveGenesisData(ctx, st))
-
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}))
-
-	st, err = service.HeadState(ctx)
-	require.NoError(t, err)
-	b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 33)
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	root, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	preState, err := service.getBlockPreState(ctx, wsb.Block())
-	require.NoError(t, err)
-	postState, err := service.validateStateTransition(ctx, preState, wsb)
-	require.NoError(t, err)
-	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-
-	b, err = util.GenerateFullBlock(postState, keys, util.DefaultBlockGenConfig(), 34)
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	root, err = b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	preState, err = service.getBlockPreState(ctx, wsb.Block())
-	require.NoError(t, err)
-	postState, err = service.validateStateTransition(ctx, preState, wsb)
-	require.NoError(t, err)
-	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-
-	require.Equal(t, true, service.cfg.BeaconDB.HasBlock(ctx, root))
-	hasState, err := service.cfg.StateGen.HasState(ctx, root)
-	require.NoError(t, err)
-	require.Equal(t, true, hasState)
-
-	// Set deadlined context when processing the block
-	cancCtx, canc := context.WithCancel(context.Background())
-	canc()
-	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
-	require.NoError(t, err)
-
-	parentRoot = roblock.Block().ParentRoot()
-
-	cj := &ethpb.Checkpoint{}
-	cj.Epoch = 1
-	cj.Root = parentRoot[:]
-	require.NoError(t, postState.SetCurrentJustifiedCheckpoint(cj))
-	require.NoError(t, postState.SetFinalizedCheckpoint(cj))
-
-	// Rollback block insertion into db and caches.
-	require.ErrorContains(t, "context canceled", service.postBlockProcess(&postBlockProcessConfig{cancCtx, roblock, [32]byte{}, postState, false}))
-
-	// The block should no longer exist.
-	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
-	hasState, err = service.cfg.StateGen.HasState(ctx, root)
-	require.NoError(t, err)
-	require.Equal(t, false, hasState)
+	require.Equal(t, cfg.blockRoot, fcuArgs.headRoot)
 }
 
 func fakeCommitments(n int) [][]byte {

beacon-chain/blockchain/receive_attestation.go

@@ -12,11 +12,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // reorgLateBlockCountAttestations is the time until the end of the slot in which we count

beacon-chain/blockchain/receive_attestation_test.go

@@ -10,7 +10,6 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -47,7 +46,7 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r32))
 
-	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32.Root(), params.BeaconConfig().ZeroHash, fc, fc)
+	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32, params.BeaconConfig().ZeroHash, fc, fc)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r33))
 
@@ -55,12 +54,10 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 	a := util.NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = []byte{'c'}
-	r33Root := r33.Root()
-	a.Data.BeaconBlockRoot = r33Root[:]
+	a.Data.BeaconBlockRoot = r33[:]
 	require.ErrorContains(t, wanted, service.VerifyLmdFfgConsistency(context.Background(), a))
 
-	r32Root := r32.Root()
-	a.Data.Target.Root = r32Root[:]
+	a.Data.Target.Root = r32[:]
 	err = service.VerifyLmdFfgConsistency(context.Background(), a)
 	require.NoError(t, err, "Could not verify LMD and FFG votes to be consistent")
 }
@@ -119,9 +116,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
-	roblock, err := consensus_blocks.NewROBlockWithRoot(wsb, tRoot)
-	require.NoError(t, err)
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, tRoot, [32]byte{}, postState, false}))
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
 	require.NoError(t, err)
 	require.Equal(t, 2, fcs.NodeCount())
@@ -181,9 +176,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
-	roblock, err := consensus_blocks.NewROBlockWithRoot(wsb, tRoot)
-	require.NoError(t, err)
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, tRoot, [32]byte{}, postState, false}))
 	require.Equal(t, 2, fcs.NodeCount())
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	require.Equal(t, tRoot, service.head.root)

beacon-chain/blockchain/receive_block.go

@@ -17,18 +17,16 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
 )
 
@@ -53,12 +51,6 @@ type BlobReceiver interface {
 	ReceiveBlob(context.Context, blocks.VerifiedROBlob) error
 }
 
-// DataColumnReceiver interface defines the methods of chain service for receiving new
-// data columns
-type DataColumnReceiver interface {
-	ReceiveDataColumn(blocks.VerifiedRODataColumn) error
-}
-
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -77,7 +69,6 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring already synced block")
 		return nil
 	}
-
 	receivedTime := time.Now()
 	s.blockBeingSynced.set(blockRoot)
 	defer s.blockBeingSynced.unset(blockRoot)
@@ -86,28 +77,20 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
-
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
 	if err != nil {
 		return errors.Wrap(err, "could not get block's prestate")
 	}
 
 	currentCheckpoints := s.saveCurrentCheckpoints(preState)
-	roblock, err := consensus_blocks.NewROBlockWithRoot(blockCopy, blockRoot)
+	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, blockCopy, blockRoot)
 	if err != nil {
 		return err
 	}
-
-	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, roblock)
-	if err != nil {
-		return err
-	}
-
 	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
 	if err != nil {
 		return err
 	}
-
 	// Defragment the state before continuing block processing.
 	s.defragmentState(postState)
 
@@ -119,7 +102,8 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 	args := &postBlockProcessConfig{
 		ctx:            ctx,
-		roblock:        roblock,
+		signed:         blockCopy,
+		blockRoot:      blockRoot,
 		postState:      postState,
 		isValidPayload: isValidPayload,
 	}
@@ -200,7 +184,8 @@ func (s *Service) updateCheckpoints(
 func (s *Service) validateExecutionAndConsensus(
 	ctx context.Context,
 	preState state.BeaconState,
-	block consensusblocks.ROBlock,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
 ) (state.BeaconState, bool, error) {
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	if err != nil {
@@ -219,7 +204,7 @@ func (s *Service) validateExecutionAndConsensus(
 	var isValidPayload bool
 	eg.Go(func() error {
 		var err error
-		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block)
+		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block, blockRoot)
 		if err != nil {
 			return errors.Wrap(err, "could not notify the engine of the new payload")
 		}
@@ -243,14 +228,12 @@ func (s *Service) handleDA(
 		if err != nil {
 			return 0, err
 		}
-
-		nodeID := s.cfg.P2P.NodeID()
-		if err := avs.IsDataAvailable(ctx, nodeID, s.CurrentSlot(), rob); err != nil {
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
 			return 0, errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
 		}
 	} else {
 		if err := s.isDataAvailable(ctx, blockRoot, block); err != nil {
-			return 0, errors.Wrap(err, "is data available")
+			return 0, errors.Wrap(err, "could not validate blob data availability")
 		}
 	}
 	daWaitedTime := time.Since(daStartTime)
@@ -290,6 +273,7 @@ func (s *Service) reportPostBlockProcessing(
 func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {
 	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	go func() {
+		finalizedState.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
 		s.sendNewFinalizedEvent(ctx, finalizedState)
 	}()
 	depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
@@ -366,9 +350,6 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock
 
 // HasBlock returns true if the block of the input root exists in initial sync blocks cache or DB.
 func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
-	if s.BlockBeingSynced(root) {
-		return false
-	}
 	return s.hasBlockInInitSyncOrDB(ctx, root)
 }
 
@@ -572,16 +553,16 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 }
 
 // validateExecutionOnBlock notifies the engine of the incoming block execution payload and returns true if the payload is valid
-func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, block consensusblocks.ROBlock) (bool, error) {
-	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, block)
+func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, signed interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) (bool, error) {
+	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, signed)
 	if err != nil {
 		s.cfg.ForkChoiceStore.Lock()
-		err = s.handleInvalidExecutionError(ctx, err, block.Root(), block.Block().ParentRoot())
+		err = s.handleInvalidExecutionError(ctx, err, blockRoot, signed.Block().ParentRoot())
 		s.cfg.ForkChoiceStore.Unlock()
 		return false, err
 	}
-	if block.Block().Version() < version.Capella && isValidPayload {
-		if err := s.validateMergeTransitionBlock(ctx, ver, header, block); err != nil {
+	if signed.Version() < version.Capella && isValidPayload {
+		if err := s.validateMergeTransitionBlock(ctx, ver, header, signed); err != nil {
 			return isValidPayload, err
 		}
 	}

beacon-chain/blockchain/receive_block_test.go

@@ -278,8 +278,6 @@ func TestService_HasBlock(t *testing.T) {
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.Equal(t, true, s.HasBlock(context.Background(), r))
-	s.blockBeingSynced.set(r)
-	require.Equal(t, false, s.HasBlock(context.Background(), r))
 }
 
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {

beacon-chain/blockchain/receive_data_column.go

@@ -1,14 +0,0 @@
-package blockchain
-
-import (
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-)
-
-func (s *Service) ReceiveDataColumn(ds blocks.VerifiedRODataColumn) error {
-	if err := s.blobStorage.SaveDataColumn(ds); err != nil {
-		return errors.Wrap(err, "save data column")
-	}
-
-	return nil
-}

beacon-chain/blockchain/service.go

@@ -36,14 +36,13 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal
@@ -82,7 +81,7 @@ type config struct {
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
 	BLSToExecPool           blstoexec.PoolManager
-	P2P                     p2p.Acceser
+	P2p                     p2p.Broadcaster
 	MaxRoutines             int
 	StateNotifier           statefeed.Notifier
 	ForkChoiceStore         f.ForkChoicer
@@ -107,17 +106,15 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][fieldparams.NumberOfColumns]bool
+	seenIndex map[[32]byte][fieldparams.MaxBlobsPerBlock]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
 func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
-	// TODO: Separate Data Columns from blobs
-	/*
-		if idx >= fieldparams.MaxBlobsPerBlock {
-			return
-		}*/
+	if idx >= fieldparams.MaxBlobsPerBlock {
+		return
+	}
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
@@ -131,7 +128,7 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.NumberOfColumns)
+		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 
@@ -145,7 +142,7 @@ func (bn *blobNotifierMap) forRoot(root [32]byte) chan uint64 {
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.NumberOfColumns)
+		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -171,7 +168,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
+		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,
@@ -306,15 +303,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint state")
 	}
-	finalizedBlock, err := s.cfg.BeaconDB.Block(s.ctx, fRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint block")
-	}
-	roblock, err := consensus_blocks.NewROBlockWithRoot(finalizedBlock, fRoot)
-	if err != nil {
-		return err
-	}
-	if err := s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, roblock); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, fRoot); err != nil {
 		return errors.Wrap(err, "could not insert finalized block to forkchoice")
 	}
 	if !features.Get().EnableStartOptimistic {
@@ -340,6 +329,8 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
+	saved.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
+
 	return nil
 }
 
@@ -526,11 +517,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	gb, err := consensus_blocks.NewROBlockWithRoot(genesisBlk, genesisBlkRoot)
-	if err != nil {
-		return err
-	}
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, gb); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, genesisBlkRoot); err != nil {
 		log.WithError(err).Fatal("Could not process genesis block for fork choice")
 	}
 	s.cfg.ForkChoiceStore.SetOriginRoot(genesisBlkRoot)

beacon-chain/blockchain/service_test.go

@@ -97,14 +97,13 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		WithAttestationPool(attestations.NewPool()),
 		WithSlashingPool(slashings.NewPool()),
 		WithExitPool(voluntaryexits.NewPool()),
-		WithP2PBroadcaster(&mockAccesser{}),
+		WithP2PBroadcaster(&mockBroadcaster{}),
 		WithStateNotifier(&mockBeaconNode{}),
 		WithForkChoiceStore(fc),
 		WithAttestationService(attService),
 		WithStateGen(stateGen),
 		WithPayloadIDCache(cache.NewPayloadIDCache()),
 		WithClockSynchronizer(startup.NewClockSynchronizer()),
-		WithP2PBroadcaster(&mockAccesser{}),
 	}
 
 	chainService, err := NewService(ctx, opts...)
@@ -377,15 +376,11 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
 	}
 	b := util.NewBeaconBlock()
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
+	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -458,11 +453,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	require.NoError(b, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(b, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-	require.NoError(b, err)
-	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
+	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -588,7 +579,7 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
+		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 

beacon-chain/blockchain/setup_test.go

@@ -19,10 +19,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
-	p2pTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"google.golang.org/protobuf/proto"
@@ -34,7 +32,7 @@ type mockBeaconNode struct {
 }
 
 // StateFeed mocks the same method in the beacon node.
-func (mbn *mockBeaconNode) StateFeed() event.SubscriberSender {
+func (mbn *mockBeaconNode) StateFeed() *event.Feed {
 	mbn.mu.Lock()
 	defer mbn.mu.Unlock()
 	if mbn.stateFeed == nil {
@@ -47,11 +45,6 @@ type mockBroadcaster struct {
 	broadcastCalled bool
 }
 
-type mockAccesser struct {
-	mockBroadcaster
-	p2pTesting.MockPeerManager
-}
-
 func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	mb.broadcastCalled = true
 	return nil
@@ -72,11 +65,6 @@ func (mb *mockBroadcaster) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.B
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumn(_ context.Context, _ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
-	mb.broadcastCalled = true
-	return nil
-}
-
 func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.SignedBLSToExecutionChange) {
 }
 
@@ -134,7 +122,6 @@ func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceReq
 		WithBlobStorage(filesystem.NewEphemeralBlobStorage(t)),
 		WithSyncChecker(mock.MockChecker{}),
 		WithExecutionEngineCaller(&mockExecution.EngineClient{}),
-		WithP2PBroadcaster(&mockAccesser{}),
 	}
 	// append the variadic opts so they override the defaults by being processed afterwards
 	opts = append(defOpts, opts...)

beacon-chain/blockchain/testing/mock.go

@@ -98,44 +98,6 @@ func (s *ChainService) BlockNotifier() blockfeed.Notifier {
 	return s.blockNotifier
 }
 
-type EventFeedWrapper struct {
-	feed       *event.Feed
-	subscribed chan struct{} // this channel is closed once a subscription is made
-}
-
-func (w *EventFeedWrapper) Subscribe(channel interface{}) event.Subscription {
-	select {
-	case <-w.subscribed:
-		break // already closed
-	default:
-		close(w.subscribed)
-	}
-	return w.feed.Subscribe(channel)
-}
-
-func (w *EventFeedWrapper) Send(value interface{}) int {
-	return w.feed.Send(value)
-}
-
-// WaitForSubscription allows test to wait for the feed to have a subscription before beginning to send events.
-func (w *EventFeedWrapper) WaitForSubscription(ctx context.Context) error {
-	select {
-	case <-w.subscribed:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-var _ event.SubscriberSender = &EventFeedWrapper{}
-
-func NewEventFeedWrapper() *EventFeedWrapper {
-	return &EventFeedWrapper{
-		feed:       new(event.Feed),
-		subscribed: make(chan struct{}),
-	}
-}
-
 // MockBlockNotifier mocks the block notifier.
 type MockBlockNotifier struct {
 	feed *event.Feed
@@ -169,7 +131,7 @@ func (msn *MockStateNotifier) ReceivedEvents() []*feed.Event {
 }
 
 // StateFeed returns a state feed.
-func (msn *MockStateNotifier) StateFeed() event.SubscriberSender {
+func (msn *MockStateNotifier) StateFeed() *event.Feed {
 	msn.feedLock.Lock()
 	defer msn.feedLock.Unlock()
 
@@ -197,23 +159,6 @@ func (msn *MockStateNotifier) StateFeed() event.SubscriberSender {
 	return msn.feed
 }
 
-// NewSimpleStateNotifier makes a state feed without the custom mock feed machinery.
-func NewSimpleStateNotifier() *MockStateNotifier {
-	return &MockStateNotifier{feed: new(event.Feed)}
-}
-
-type SimpleNotifier struct {
-	Feed event.SubscriberSender
-}
-
-func (n *SimpleNotifier) StateFeed() event.SubscriberSender {
-	return n.Feed
-}
-
-func (n *SimpleNotifier) OperationFeed() event.SubscriberSender {
-	return n.Feed
-}
-
 // OperationNotifier mocks the same method in the chain service.
 func (s *ChainService) OperationNotifier() opfeed.Notifier {
 	if s.opNotifier == nil {
@@ -228,7 +173,7 @@ type MockOperationNotifier struct {
 }
 
 // OperationFeed returns an operation feed.
-func (mon *MockOperationNotifier) OperationFeed() event.SubscriberSender {
+func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 	if mon.feed == nil {
 		mon.feed = new(event.Feed)
 	}
@@ -567,7 +512,7 @@ func prepareForkchoiceState(
 	payloadHash [32]byte,
 	justified *ethpb.Checkpoint,
 	finalized *ethpb.Checkpoint,
-) (state.BeaconState, blocks.ROBlock, error) {
+) (state.BeaconState, [32]byte, error) {
 	blockHeader := &ethpb.BeaconBlockHeader{
 		ParentRoot: parentRoot[:],
 	}
@@ -588,26 +533,7 @@ func prepareForkchoiceState(
 
 	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
 	st, err := state_native.InitializeFromProtoBellatrix(base)
-	if err != nil {
-		return nil, blocks.ROBlock{}, err
-	}
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot:       slot,
-			ParentRoot: parentRoot[:],
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &enginev1.ExecutionPayload{
-					BlockHash: payloadHash[:],
-				},
-			},
-		},
-	}
-	signed, err := blocks.NewSignedBeaconBlock(blk)
-	if err != nil {
-		return nil, blocks.ROBlock{}, err
-	}
-	roblock, err := blocks.NewROBlockWithRoot(signed, blockRoot)
-	return st, roblock, err
+	return st, blockRoot, err
 }
 
 // CachedHeadRoot mocks the same method in the chain service
@@ -650,9 +576,9 @@ func (s *ChainService) HighestReceivedBlockSlot() primitives.Slot {
 }
 
 // InsertNode mocks the same method in the chain service
-func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, block blocks.ROBlock) error {
+func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, root [32]byte) error {
 	if s.ForkChoiceStore != nil {
-		return s.ForkChoiceStore.InsertNode(ctx, st, block)
+		return s.ForkChoiceStore.InsertNode(ctx, st, root)
 	}
 	return nil
 }
@@ -702,11 +628,6 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 	return nil
 }
 
-// ReceiveDataColumn implements the same method in chain service
-func (*ChainService) ReceiveDataColumn(_ blocks.VerifiedRODataColumn) error {
-	return nil
-}
-
 // TargetRootForEpoch mocks the same method in the chain service
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/builder/BUILD.bazel

@@ -19,7 +19,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -27,6 +26,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/builder/service.go

@@ -14,10 +14,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // ErrNoBuilder is used when builder endpoint is not configured.

beacon-chain/cache/BUILD.bazel

@@ -8,7 +8,6 @@ go_library(
         "attestation_data.go",
         "balance_cache_key.go",
         "checkpoint_state.go",
-        "column_subnet_ids.go",
         "committee.go",
         "committee_disabled.go",  # keep
         "committees.go",
@@ -47,7 +46,6 @@ go_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",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
@@ -58,6 +56,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_k8s_client_go//tools/cache:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/cache/column_subnet_ids.go

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

beacon-chain/cache/common.go

@@ -17,6 +17,6 @@ func trim(queue *cache.FIFO, maxSize uint64) {
 }
 
 // popProcessNoopFunc is a no-op function that never returns an error.
-func popProcessNoopFunc(_ interface{}, _ bool) error {
+func popProcessNoopFunc(_ interface{}) error {
 	return nil
 }

beacon-chain/cache/depositsnapshot/BUILD.bazel

@@ -19,7 +19,6 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -27,6 +26,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_wealdtech_go_bytesutil//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/cache/depositsnapshot/deposit_fetcher.go

@@ -10,10 +10,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
 	"github.com/wealdtech/go-bytesutil"
+	"go.opencensus.io/trace"
 )
 
 var (
@@ -241,7 +241,7 @@ func (c *Cache) InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, bloc
 	c.pendingDeposits = append(c.pendingDeposits,
 		&ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, Index: index, DepositRoot: depositRoot[:]})
 	pendingDepositsCount.Set(float64(len(c.pendingDeposits)))
-	span.SetAttributes(trace.Int64Attribute("count", int64(len(c.pendingDeposits))))
+	span.AddAttributes(trace.Int64Attribute("count", int64(len(c.pendingDeposits))))
 }
 
 // Deposits returns the cached internal deposit tree.
@@ -304,7 +304,7 @@ func (c *Cache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*eth
 		return depositCntrs[i].Index < depositCntrs[j].Index
 	})
 
-	span.SetAttributes(trace.Int64Attribute("count", int64(len(depositCntrs))))
+	span.AddAttributes(trace.Int64Attribute("count", int64(len(depositCntrs))))
 
 	return depositCntrs
 }

beacon-chain/cache/depositsnapshot/deposit_inserter.go

@@ -10,9 +10,9 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 var (

beacon-chain/cache/registration.go

@@ -7,8 +7,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"go.opencensus.io/trace"
 )
 
 // RegistrationCache is used to store the cached results of an Validator Registration request.

beacon-chain/cache/skip_slot_cache.go

@@ -11,7 +11,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	"go.opencensus.io/trace"
 )
 
 var (
@@ -92,17 +92,17 @@ func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (state.BeaconState,
 		delay *= delayFactor
 		delay = math.Min(delay, maxDelay)
 	}
-	span.SetAttributes(trace.BoolAttribute("inProgress", inProgress))
+	span.AddAttributes(trace.BoolAttribute("inProgress", inProgress))
 
 	item, exists := c.cache.Get(r)
 
 	if exists && item != nil {
 		skipSlotCacheHit.Inc()
-		span.SetAttributes(trace.BoolAttribute("hit", true))
+		span.AddAttributes(trace.BoolAttribute("hit", true))
 		return item.(state.BeaconState).Copy(), nil
 	}
 	skipSlotCacheMiss.Inc()
-	span.SetAttributes(trace.BoolAttribute("hit", false))
+	span.AddAttributes(trace.BoolAttribute("hit", false))
 	return nil, nil
 }
 

beacon-chain/core/altair/BUILD.bazel

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

beacon-chain/core/altair/attestation.go

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

beacon-chain/core/altair/deposit.go

@@ -37,7 +37,7 @@ func ProcessDeposits(
 	beaconState state.BeaconState,
 	deposits []*ethpb.Deposit,
 ) (state.BeaconState, error) {
-	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -46,7 +46,7 @@ func ProcessDeposits(
 		if deposit == nil || deposit.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, err = ProcessDeposit(beaconState, deposit, allSignaturesVerified)
+		beaconState, err = ProcessDeposit(beaconState, deposit, batchVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
 		}
@@ -81,7 +81,7 @@ func ProcessDeposits(
 //	  amount=deposit.data.amount,
 //	  signature=deposit.data.signature,
 //	 )
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
 	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
@@ -92,7 +92,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 		return nil, err
 	}
 
-	return ApplyDeposit(beaconState, deposit.Data, allSignaturesVerified)
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
 }
 
 // ApplyDeposit
@@ -115,13 +115,13 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 //	    # Increase balance by deposit amount
 //	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
 //	    increase_balance(state, index, amount)
-func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSignaturesVerified bool) (state.BeaconState, error) {
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
 	pubKey := data.PublicKey
 	amount := data.Amount
 	withdrawalCredentials := data.WithdrawalCredentials
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
-		if !allSignaturesVerified {
+		if verifySignature {
 			valid, err := blocks.IsValidDepositSignature(data)
 			if err != nil {
 				return nil, err
@@ -187,12 +187,11 @@ func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdr
 //	return Validator(
 //	    pubkey=pubkey,
 //	    withdrawal_credentials=withdrawal_credentials,
-//	    effective_balance=effective_balance,
-//	    slashed=False,
 //	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
 //	    activation_epoch=FAR_FUTURE_EPOCH,
 //	    exit_epoch=FAR_FUTURE_EPOCH,
 //	    withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	    effective_balance=effective_balance,
 //	)
 func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
 	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
@@ -203,11 +202,10 @@ func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount
 	return &ethpb.Validator{
 		PublicKey:                  pubKey,
 		WithdrawalCredentials:      withdrawalCredentials,
-		EffectiveBalance:           effectiveBalance,
-		Slashed:                    false,
 		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
 		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
 		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
 		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           effectiveBalance,
 	}
 }

beacon-chain/core/altair/deposit_test.go

@@ -199,7 +199,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessDeposit(beaconState, dep[0], false)
+	newState, err := altair.ProcessDeposit(beaconState, dep[0], true)
 	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
 
 	if newState.Eth1DepositIndex() != 1 {

beacon-chain/core/altair/epoch_precompute.go

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

beacon-chain/core/altair/transition.go

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

beacon-chain/core/blocks/BUILD.bazel

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

beacon-chain/core/blocks/attestation.go

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

beacon-chain/core/blocks/attestation_test.go

@@ -448,7 +448,6 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 			Target: &ethpb.Checkpoint{
 				Epoch: primitives.Epoch(i),
 			},
-			Source: &ethpb.Checkpoint{},
 		}
 	}
 
@@ -490,7 +489,6 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 				Target: &ethpb.Checkpoint{
 					Root: []byte{},
 				},
-				Source: &ethpb.Checkpoint{},
 			},
 			Signature:       sig.Marshal(),
 			AggregationBits: list,

beacon-chain/core/blocks/deposit.go

@@ -55,26 +55,12 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 		return false, err
 	}
 
+	verified := false
 	if err := verifyDepositDataWithDomain(ctx, deposits, domain); err != nil {
 		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
-		return false, nil
+		verified = true
 	}
-	return true, nil
-}
-
-// BatchVerifyPendingDepositsSignatures batch verifies pending deposit signatures.
-func BatchVerifyPendingDepositsSignatures(ctx context.Context, deposits []*ethpb.PendingDeposit) (bool, error) {
-	var err error
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	if err != nil {
-		return false, err
-	}
-
-	if err := verifyPendingDepositDataWithDomain(ctx, deposits, domain); err != nil {
-		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
-		return false, nil
-	}
-	return true, nil
+	return verified, nil
 }
 
 // IsValidDepositSignature returns whether deposit_data is valid
@@ -173,44 +159,3 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
 	}
 	return nil
 }
-
-func verifyPendingDepositDataWithDomain(ctx context.Context, deps []*ethpb.PendingDeposit, domain []byte) error {
-	if len(deps) == 0 {
-		return nil
-	}
-	pks := make([]bls.PublicKey, len(deps))
-	sigs := make([][]byte, len(deps))
-	msgs := make([][32]byte, len(deps))
-	for i, dep := range deps {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		if dep == nil {
-			return errors.New("nil deposit")
-		}
-		dpk, err := bls.PublicKeyFromBytes(dep.PublicKey)
-		if err != nil {
-			return err
-		}
-		pks[i] = dpk
-		sigs[i] = dep.Signature
-		depositMessage := &ethpb.DepositMessage{
-			PublicKey:             dep.PublicKey,
-			WithdrawalCredentials: dep.WithdrawalCredentials,
-			Amount:                dep.Amount,
-		}
-		sr, err := signing.ComputeSigningRoot(depositMessage, domain)
-		if err != nil {
-			return err
-		}
-		msgs[i] = sr
-	}
-	verify, err := bls.VerifyMultipleSignatures(sigs, msgs, pks)
-	if err != nil {
-		return errors.Errorf("could not verify multiple signatures: %v", err)
-	}
-	if !verify {
-		return errors.New("one or more deposit signatures did not verify")
-	}
-	return nil
-}

beacon-chain/core/blocks/deposit_test.go

@@ -17,41 +17,6 @@ import (
 )
 
 func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	require.NoError(t, err)
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             sk.PublicKey().Marshal(),
-			WithdrawalCredentials: make([]byte, 32),
-			Amount:                3000,
-		},
-	}
-	sr, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
-		PublicKey:             deposit.Data.PublicKey,
-		WithdrawalCredentials: deposit.Data.WithdrawalCredentials,
-		Amount:                3000,
-	}, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	deposit.Data.Signature = sig.Marshal()
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	require.NoError(t, err)
-	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
-	require.NoError(t, err)
-	require.Equal(t, true, verified)
-}
-
-func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
 			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
@@ -69,9 +34,9 @@ func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
+	ok, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
-	require.Equal(t, false, verified)
+	require.Equal(t, true, ok)
 }
 
 func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
@@ -128,54 +93,3 @@ func TestIsValidDepositSignature_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, valid)
 }
-
-func TestBatchVerifyPendingDepositsSignatures_Ok(t *testing.T) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	require.NoError(t, err)
-	pendingDeposit := &ethpb.PendingDeposit{
-		PublicKey:             sk.PublicKey().Marshal(),
-		WithdrawalCredentials: make([]byte, 32),
-		Amount:                3000,
-	}
-	sr, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
-		PublicKey:             pendingDeposit.PublicKey,
-		WithdrawalCredentials: pendingDeposit.WithdrawalCredentials,
-		Amount:                3000,
-	}, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	pendingDeposit.Signature = sig.Marshal()
-
-	sk2, err := bls.RandKey()
-	require.NoError(t, err)
-	pendingDeposit2 := &ethpb.PendingDeposit{
-		PublicKey:             sk2.PublicKey().Marshal(),
-		WithdrawalCredentials: make([]byte, 32),
-		Amount:                4000,
-	}
-	sr2, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
-		PublicKey:             pendingDeposit2.PublicKey,
-		WithdrawalCredentials: pendingDeposit2.WithdrawalCredentials,
-		Amount:                4000,
-	}, domain)
-	require.NoError(t, err)
-	sig2 := sk2.Sign(sr2[:])
-	pendingDeposit2.Signature = sig2.Marshal()
-
-	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
-	require.NoError(t, err)
-	require.Equal(t, true, verified)
-}
-
-func TestBatchVerifyPendingDepositsSignatures_InvalidSignature(t *testing.T) {
-	pendingDeposit := &ethpb.PendingDeposit{
-		PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
-		WithdrawalCredentials: make([]byte, 32),
-		Signature:             make([]byte, 96),
-	}
-	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit})
-	require.NoError(t, err)
-	require.Equal(t, false, verified)
-}

beacon-chain/core/blocks/genesis.go

@@ -213,11 +213,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 					},
 					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
 					BlobKzgCommitments:    make([][]byte, 0),
-					ExecutionRequests: &enginev1.ExecutionRequests{
-						Withdrawals:    make([]*enginev1.WithdrawalRequest, 0),
-						Deposits:       make([]*enginev1.DepositRequest, 0),
-						Consolidations: make([]*enginev1.ConsolidationRequest, 0),
-					},
 				},
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],