Switch to compounding when consolidating with source==target

* removing extra container for ssz blob sidecar response

* gaz and changelog

* gaz

* fixing dependencies

* fixing test

* updating values based on feedback"

CHANGELOG.md

@@ -13,6 +13,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Light client support: Implement `ComputeFieldRootsForBlockBody`.
 - Light client support: Add light client database changes.
 - Light client support: Implement capella and deneb changes.
+- Light client support: Implement `BlockToLightClientHeaderXXX` functions upto Deneb
 
 ### Changed
 
@@ -31,13 +32,22 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - `api-timeout` is changed from int flag to duration flag, default value updated.
 - Light client support: abstracted out the light client headers with different versions.
 - `ApplyToEveryValidator` has been changed to prevent misuse bugs, it takes a closure that takes a `ReadOnlyValidator` and returns a raw pointer to a `Validator`. 
+- Removed gorilla mux library and replaced it with net/http updates in go 1.22.
+- Clean up `ProposeBlock` for validator client to reduce cognitive scoring and enable further changes.
+- Updated k8s-io/client-go to v0.30.4 and k8s-io/apimachinery to v0.30.4
+- Migrated tracing library from opencensus to opentelemetry for both the beacon node and validator.
+- Refactored light client code to make it more readable and make future PRs easier.
+- Switch to compounding when consolidating with source==target.
 
 ### Deprecated
 - `--disable-grpc-gateway` flag is deprecated due to grpc gateway removal.
 - `--enable-experimental-state` flag is deprecated. This feature is now on by default. Opt-out with `--disable-experimental-state`.
 
 ### Removed
+
 - removed gRPC Gateway
+- Removed unused blobs bundle cache
+- Removed consolidation signing domain from params. The Electra design changed such that EL handles consolidation signature verification.
 
 ### Fixed
 
@@ -50,6 +60,8 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Core: Fix process effective balance update to safe copy validator for Electra.
 - `== nil` checks before calling `IsNil()` on interfaces to prevent panics.
 - Core: Fixed slash processing causing extra hashing
+- Core: Fixed extra allocations when processing slashings
+- remove unneeded container in blob sidecar ssz response
 
 ### Security
 

api/client/builder/client.go

@@ -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.AddAttributes(trace.StringAttribute("url", u.String()),
+	span.SetAttributes(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.AddAttributes(trace.Int64Attribute("num_reqs", int64(len(svr))))
+	span.SetAttributes(trace.Int64Attribute("num_reqs", int64(len(svr))))
 
 	if len(svr) == 0 {
 		err := errors.Wrap(errMalformedRequest, "empty validator registration list")

api/server/httprest/BUILD.bazel

@@ -10,8 +10,8 @@ go_library(
     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_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -25,7 +25,6 @@ go_test(
         "//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/server/httprest/options.go

@@ -3,12 +3,22 @@ package httprest
 import (
 	"time"
 
-	"github.com/gorilla/mux"
+	"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 {
@@ -18,7 +28,7 @@ func WithHTTPAddr(addr string) Option {
 }
 
 // WithRouter sets the internal router of the server, this is required.
-func WithRouter(r *mux.Router) Option {
+func WithRouter(r *http.ServeMux) Option {
 	return func(g *Server) error {
 		g.cfg.router = r
 		return nil

api/server/httprest/server.go

@@ -5,8 +5,8 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
 	"github.com/prysmaticlabs/prysm/v5/runtime"
 )
 
@@ -14,9 +14,10 @@ var _ runtime.Service = (*Server)(nil)
 
 // Config parameters for setting up the http-rest service.
 type config struct {
-	httpAddr string
-	router   *mux.Router
-	timeout  time.Duration
+	httpAddr    string
+	middlewares []middleware.Middleware
+	router      http.Handler
+	timeout     time.Duration
 }
 
 // Server serves HTTP traffic.
@@ -44,11 +45,10 @@ func New(ctx context.Context, opts ...Option) (*Server, error) {
 	}
 	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(g.cfg.router, g.cfg.timeout, "request timed out")
-	} else {
-		handler = g.cfg.router
+		handler = http.TimeoutHandler(handler, g.cfg.timeout, "request timed out")
 	}
 	g.server = &http.Server{
 		Addr:              g.cfg.httpAddr,

api/server/httprest/server_test.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"net"
 	"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"
@@ -25,12 +25,13 @@ func TestServer_StartStop(t *testing.T) {
 	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 := fmt.Sprintf("%s:%d", host, port)
-
+	address := net.JoinHostPort(host, portStr)
+	handler := http.NewServeMux()
 	opts := []Option{
 		WithHTTPAddr(address),
-		WithRouter(mux.NewRouter()),
+		WithRouter(handler),
 	}
 
 	g, err := New(context.Background(), opts...)
@@ -50,13 +51,15 @@ func TestServer_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
 	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 := fmt.Sprintf("%s:%d", host, port)
+	address := net.JoinHostPort(host, portStr)
 
 	opts := []Option{
 		WithHTTPAddr(address),
-		WithRouter(mux.NewRouter()),
+		WithRouter(handler),
 	}
 
 	g, err := New(context.Background(), opts...)

api/server/middleware/BUILD.bazel

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

api/server/middleware/middleware.go

@@ -5,10 +5,11 @@ 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) {
@@ -21,7 +22,7 @@ func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
 }
 
 // CorsHandler sets the cors settings on api endpoints
-func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
+func CorsHandler(allowOrigins []string) Middleware {
 	c := cors.New(cors.Options{
 		AllowedOrigins:   allowOrigins,
 		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
@@ -34,7 +35,7 @@ func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
 }
 
 // ContentTypeHandler checks request for the appropriate media types otherwise returning a http.StatusUnsupportedMediaType error
-func ContentTypeHandler(acceptedMediaTypes []string) mux.MiddlewareFunc {
+func ContentTypeHandler(acceptedMediaTypes []string) Middleware {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			// skip the GET request
@@ -67,7 +68,7 @@ func ContentTypeHandler(acceptedMediaTypes []string) mux.MiddlewareFunc {
 }
 
 // AcceptHeaderHandler checks if the client's response preference is handled
-func AcceptHeaderHandler(serverAcceptedTypes []string) mux.MiddlewareFunc {
+func AcceptHeaderHandler(serverAcceptedTypes []string) Middleware {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			acceptHeader := r.Header.Get("Accept")
@@ -110,3 +111,15 @@ func AcceptHeaderHandler(serverAcceptedTypes []string) mux.MiddlewareFunc {
 		})
 	}
 }
+
+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

@@ -34,6 +34,9 @@ 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/conversions_lightclient.go

@@ -1,3 +1,122 @@
 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) {
+	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/endpoints_events.go

@@ -96,21 +96,7 @@ 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

@@ -24,11 +24,6 @@ type LightClientBootstrap struct {
 	CurrentSyncCommitteeBranch []string        `json:"current_sync_committee_branch"`
 }
 
-type LightClientBootstrapResponse struct {
-	Version string                `json:"version"`
-	Data    *LightClientBootstrap `json:"data"`
-}
-
 type LightClientUpdate struct {
 	AttestedHeader          json.RawMessage `json:"attested_header"`
 	NextSyncCommittee       *SyncCommittee  `json:"next_sync_committee,omitempty"`
@@ -39,11 +34,40 @@ type LightClientUpdate struct {
 	SignatureSlot           string          `json:"signature_slot"`
 }
 
-type LightClientUpdateWithVersion struct {
+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 {
 	Version string             `json:"version"`
 	Data    *LightClientUpdate `json:"data"`
 }
 
-type LightClientUpdatesByRangeResponse struct {
-	Updates []*LightClientUpdateWithVersion `json:"updates"`
+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"`
 }

beacon-chain/blockchain/BUILD.bazel

@@ -97,7 +97,6 @@ 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",
     ],
 )

beacon-chain/blockchain/chain_info.go

@@ -203,7 +203,7 @@ func (s *Service) HeadState(ctx context.Context) (state.BeaconState, error) {
 	defer s.headLock.RUnlock()
 
 	ok := s.hasHeadState()
-	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
+	span.SetAttributes(trace.BoolAttribute("cache_hit", ok))
 
 	if ok {
 		return s.headState(ctx), nil
@@ -225,7 +225,7 @@ func (s *Service) HeadStateReadOnly(ctx context.Context) (state.ReadOnlyBeaconSt
 	defer s.headLock.RUnlock()
 
 	ok := s.hasHeadState()
-	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
+	span.SetAttributes(trace.BoolAttribute("cache_hit", ok))
 
 	if ok {
 		return s.headStateReadOnly(ctx), nil

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/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_block_helpers.go

@@ -193,7 +193,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	// Return the result
 	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    lightclient.CreateLightClientFinalityUpdate(update),
+		Data:    update,
 	}
 
 	// Send event
@@ -227,7 +227,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	// Return the result
 	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    lightclient.CreateLightClientOptimisticUpdate(update),
+		Data:    update,
 	}
 
 	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{

beacon-chain/builder/BUILD.bazel

@@ -19,6 +19,7 @@ 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",
@@ -26,7 +27,6 @@ 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

@@ -46,6 +46,7 @@ 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",
@@ -56,7 +57,6 @@ 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/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{}) error {
+func popProcessNoopFunc(_ interface{}, _ bool) error {
 	return nil
 }

beacon-chain/cache/depositsnapshot/BUILD.bazel

@@ -19,6 +19,7 @@ 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",
@@ -26,7 +27,6 @@ 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.AddAttributes(trace.Int64Attribute("count", int64(len(c.pendingDeposits))))
+	span.SetAttributes(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.AddAttributes(trace.Int64Attribute("count", int64(len(depositCntrs))))
+	span.SetAttributes(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"
-	"go.opencensus.io/trace"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/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.AddAttributes(trace.BoolAttribute("inProgress", inProgress))
+	span.SetAttributes(trace.BoolAttribute("inProgress", inProgress))
 
 	item, exists := c.cache.Get(r)
 
 	if exists && item != nil {
 		skipSlotCacheHit.Inc()
-		span.AddAttributes(trace.BoolAttribute("hit", true))
+		span.SetAttributes(trace.BoolAttribute("hit", true))
 		return item.(state.BeaconState).Copy(), nil
 	}
 	skipSlotCacheMiss.Inc()
-	span.AddAttributes(trace.BoolAttribute("hit", false))
+	span.SetAttributes(trace.BoolAttribute("hit", false))
 	return nil, nil
 }
 

beacon-chain/core/electra/BUILD.bazel

@@ -34,13 +34,13 @@ go_library(
         "//contracts/deposit:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil: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/electra/consolidations.go

@@ -11,10 +11,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"go.opencensus.io/trace"
 )
 
 // ProcessPendingConsolidations implements the spec definition below. This method makes mutating
@@ -32,8 +32,6 @@ import (
 //	        if source_validator.withdrawable_epoch > get_current_epoch(state):
 //	            break
 //
-//	        # Churn any target excess active balance of target and raise its max
-//	        switch_to_compounding_validator(state, pending_consolidation.target_index)
 //	        # Move active balance to target. Excess balance is withdrawable.
 //	        active_balance = get_active_balance(state, pending_consolidation.source_index)
 //	        decrease_balance(state, pending_consolidation.source_index, active_balance)
@@ -70,10 +68,6 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			break
 		}
 
-		if err := SwitchToCompoundingValidator(st, pc.TargetIndex); err != nil {
-			return err
-		}
-
 		activeBalance, err := st.ActiveBalanceAtIndex(pc.SourceIndex)
 		if err != nil {
 			return err
@@ -101,6 +95,16 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    state: BeaconState,
 //	    consolidation_request: ConsolidationRequest
 //	) -> None:
+//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
+//	        validator_pubkeys = [v.pubkey for v in state.validators]
+//	        request_source_pubkey = consolidation_request.source_pubkey
+//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	        switch_to_compounding_validator(state, source_index)
+//	        return
+//
+//	    # Verify that source != target, so a consolidation cannot be used as an exit.
+//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
+//	        return
 //	    # If the pending consolidations queue is full, consolidation requests are ignored
 //	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
 //	        return
@@ -121,10 +125,6 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    source_validator = state.validators[source_index]
 //	    target_validator = state.validators[target_index]
 //
-//	    # Verify that source != target, so a consolidation cannot be used as an exit.
-//	    if source_index == target_index:
-//	        return
-//
 //	    # Verify source withdrawal credentials
 //	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
 //	    is_correct_source_address = (
@@ -160,6 +160,10 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	        source_index=source_index,
 //	        target_index=target_index
 //	    ))
+//
+//	    # Churn any target excess active balance of target and raise its max
+//	    if has_eth1_withdrawal_credential(target_validator):
+//	        switch_to_compounding_validator(state, target_index)
 func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
 	if len(reqs) == 0 || st == nil {
 		return nil
@@ -182,25 +186,41 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if ctx.Err() != nil {
 			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
 		}
+		canSwitch, err := IsValidSwitchToCompoundingRequest(ctx, st, cr)
+		if err != nil {
+			return fmt.Errorf("failed to validate consolidation request: %w", err)
+		}
+		if canSwitch {
+			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+			if !ok {
+				return errors.New("could not find validator in registry")
+			}
+			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
+				return fmt.Errorf("failed to switch to compounding validator: %w", err)
+			}
+			return nil
+		}
+		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
+		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
+		if sourcePubkey == targetPubkey {
+			continue
+		}
+
 		if npc, err := st.NumPendingConsolidations(); err != nil {
 			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
 		} else if npc >= pcLimit {
 			return nil
 		}
 
-		srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
 		if !ok {
 			continue
 		}
-		tgtIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.TargetPubkey))
+		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
 		if !ok {
 			continue
 		}
 
-		if srcIdx == tgtIdx {
-			continue
-		}
-
 		srcV, err := st.ValidatorAtIndex(srcIdx)
 		if err != nil {
 			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
@@ -248,7 +268,94 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
 			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
 		}
+
+		if helpers.HasETH1WithdrawalCredential(tgtV) {
+			if err := SwitchToCompoundingValidator(st, tgtIdx); err != nil {
+				return fmt.Errorf("failed to switch to compounding validator: %w", err)
+			}
+		}
 	}
 
 	return nil
 }
+
+// IsValidSwitchToCompoundingRequest returns true if the given consolidation request is valid for switching to compounding.
+//
+// Spec code:
+//
+// def is_valid_switch_to_compounding_request(
+//
+//	state: BeaconState,
+//	consolidation_request: ConsolidationRequest
+//
+// ) -> bool:
+//
+//	# Switch to compounding requires source and target be equal
+//	if consolidation_request.source_pubkey != consolidation_request.target_pubkey:
+//	    return False
+//
+//	# Verify pubkey exists
+//	source_pubkey = consolidation_request.source_pubkey
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//	if source_pubkey not in validator_pubkeys:
+//	    return False
+//
+//	source_validator = state.validators[ValidatorIndex(validator_pubkeys.index(source_pubkey))]
+//
+//	# Verify request has been authorized
+//	if source_validator.withdrawal_credentials[12:] != consolidation_request.source_address:
+//	    return False
+//
+//	# Verify source withdrawal credentials
+//	if not has_eth1_withdrawal_credential(source_validator):
+//	    return False
+//
+//	# Verify the source is active
+//	current_epoch = get_current_epoch(state)
+//	if not is_active_validator(source_validator, current_epoch):
+//	    return False
+//
+//	# Verify exit for source have not been initiated
+//	if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	    return False
+//
+//	return True
+func IsValidSwitchToCompoundingRequest(ctx context.Context, st state.BeaconState, req *enginev1.ConsolidationRequest) (bool, error) {
+	if req.SourcePubkey == nil || req.TargetPubkey == nil {
+		return false, errors.New("nil source or target pubkey")
+	}
+
+	sourcePubKey := bytesutil.ToBytes48(req.SourcePubkey)
+	targetPubKey := bytesutil.ToBytes48(req.TargetPubkey)
+	if sourcePubKey != targetPubKey {
+		return false, nil
+	}
+
+	srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubKey)
+	if !ok {
+		return false, nil
+	}
+	srcV, err := st.ValidatorAtIndex(srcIdx)
+	if err != nil {
+		return false, err
+	}
+	sourceAddress := req.SourceAddress
+	withdrawalCreds := srcV.WithdrawalCredentials
+	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
+		return false, nil
+	}
+
+	if !helpers.HasETH1WithdrawalCredential(srcV) {
+		return false, nil
+	}
+
+	curEpoch := slots.ToEpoch(st.Slot())
+	if !helpers.IsActiveValidator(srcV, curEpoch) {
+		return false, nil
+	}
+
+	if srcV.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+		return false, nil
+	}
+	return true, nil
+}

beacon-chain/core/electra/deposits.go

@@ -13,12 +13,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/contracts/deposit"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	log "github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 )
 
 // ProcessDeposits is one of the operations performed on each processed
@@ -109,13 +109,6 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 //	# Increase balance by deposit amount
 //	index = ValidatorIndex(validator_pubkeys.index(pubkey))
 //	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [Modified in Electra:EIP-7251]
-//	# Check if valid deposit switch to compounding credentials
-//
-// if ( is_compounding_withdrawal_credential(withdrawal_credentials) and has_eth1_withdrawal_credential(state.validators[index])
-//
-//	 and is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature)
-//	):
-//	 switch_to_compounding_validator(state, index)
 func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
 	pubKey := data.PublicKey
 	amount := data.Amount
@@ -139,24 +132,6 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verif
 		if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
 			return nil, err
 		}
-		val, err := beaconState.ValidatorAtIndex(index)
-		if err != nil {
-			return nil, err
-		}
-		if helpers.IsCompoundingWithdrawalCredential(withdrawalCredentials) && helpers.HasETH1WithdrawalCredential(val) {
-			if verifySignature {
-				valid, err := IsValidDepositSignature(data)
-				if err != nil {
-					return nil, errors.Wrap(err, "could not verify deposit signature")
-				}
-				if !valid {
-					return beaconState, nil
-				}
-			}
-			if err := SwitchToCompoundingValidator(beaconState, index); err != nil {
-				return nil, errors.Wrap(err, "could not switch to compound validator")
-			}
-		}
 	}
 	return beaconState, nil
 }

beacon-chain/core/electra/transition.go

@@ -12,7 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"go.opencensus.io/trace"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 )
 
 // Re-exports for methods that haven't changed in Electra.

beacon-chain/core/electra/validator.go

@@ -3,7 +3,6 @@ package electra
 import (
 	"errors"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -78,12 +77,10 @@ func ValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte) *ethpb.Va
 // SwitchToCompoundingValidator
 //
 // Spec definition:
-//
 //	 def switch_to_compounding_validator(state: BeaconState, index: ValidatorIndex) -> None:
 //		validator = state.validators[index]
-//		if has_eth1_withdrawal_credential(validator):
-//		    validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
-//		    queue_excess_active_balance(state, index)
+//		validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
+//		queue_excess_active_balance(state, index)
 func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	v, err := s.ValidatorAtIndex(idx)
 	if err != nil {
@@ -92,14 +89,12 @@ func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorI
 	if len(v.WithdrawalCredentials) == 0 {
 		return errors.New("validator has no withdrawal credentials")
 	}
-	if helpers.HasETH1WithdrawalCredential(v) {
-		v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-		if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
-			return err
-		}
-		return QueueExcessActiveBalance(s, idx)
+
+	v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
+		return err
 	}
-	return nil
+	return QueueExcessActiveBalance(s, idx)
 }
 
 // QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending balance deposit.

beacon-chain/core/electra/withdrawals.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"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	log "github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 )
 
 // ProcessWithdrawalRequests processes the validator withdrawals from the provided execution payload

beacon-chain/core/epoch/epoch_processing.go

@@ -177,18 +177,27 @@ func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.Be
 	// below equally.
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
 	minSlashing := math.Min(totalSlashing*slashingMultiplier, totalBalance)
-	err = st.ApplyToEveryValidator(func(idx int, val state.ReadOnlyValidator) (newVal *ethpb.Validator, err error) {
+	bals := st.Balances()
+	changed := false
+	err = st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		correctEpoch := (currentEpoch + exitLength/2) == val.WithdrawableEpoch()
 		if val.Slashed() && correctEpoch {
 			penaltyNumerator := val.EffectiveBalance() / increment * minSlashing
 			penalty := penaltyNumerator / totalBalance * increment
-			if err = helpers.DecreaseBalance(st, primitives.ValidatorIndex(idx), penalty); err != nil {
-				return
-			}
+			bals[idx] = helpers.DecreaseBalanceWithVal(bals[idx], penalty)
+			changed = true
 		}
-		return
+		return nil
 	})
-	return st, err
+	if err != nil {
+		return nil, err
+	}
+	if changed {
+		if err := st.SetBalances(bals); err != nil {
+			return nil, err
+		}
+	}
+	return st, nil
 }
 
 // ProcessEth1DataReset processes updates to ETH1 data votes during epoch processing.

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -31,7 +31,6 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

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

@@ -11,7 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"go.opencensus.io/trace"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 )
 
 // New gets called at the beginning of process epoch cycle to return

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

@@ -5,9 +5,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/math"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
 // ProcessSlashingsPrecompute processes the slashed validators during epoch processing.
@@ -44,17 +42,18 @@ func ProcessSlashingsPrecompute(s state.BeaconState, pBal *Balance) error {
 	}
 
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
-	validatorFunc := func(idx int, val state.ReadOnlyValidator) (newVal *ethpb.Validator, err error) {
+	bals := s.Balances()
+	validatorFunc := func(idx int, val state.ReadOnlyValidator) error {
 		correctEpoch := epochToWithdraw == val.WithdrawableEpoch()
 		if val.Slashed() && correctEpoch {
 			penaltyNumerator := val.EffectiveBalance() / increment * minSlashing
 			penalty := penaltyNumerator / pBal.ActiveCurrentEpoch * increment
-			if err = helpers.DecreaseBalance(s, primitives.ValidatorIndex(idx), penalty); err != nil {
-				return
-			}
+			bals[idx] = helpers.DecreaseBalanceWithVal(bals[idx], penalty)
 		}
-		return
+		return nil
 	}
-
-	return s.ApplyToEveryValidator(validatorFunc)
+	if err := s.ReadFromEveryValidator(validatorFunc); err != nil {
+		return err
+	}
+	return s.SetBalances(bals)
 }

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

@@ -30,8 +30,9 @@ go_test(
     deps = [
         ":go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//proto/eth/v2:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
     ],

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

@@ -2,6 +2,7 @@ package light_client
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 
 	"github.com/pkg/errors"
@@ -13,22 +14,22 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v5/proto/migration"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 
-	"context"
-
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 )
 
 const (
-	FinalityBranchNumOfLeaves = 6
+	FinalityBranchNumOfLeaves  = 6
+	executionBranchNumOfLeaves = 4
 )
 
-// CreateLightClientFinalityUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_finality_update
+// createLightClientFinalityUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_finality_update
 // def create_light_client_finality_update(update: LightClientUpdate) -> LightClientFinalityUpdate:
 //
 //	return LightClientFinalityUpdate(
@@ -38,7 +39,7 @@ const (
 //	    sync_aggregate=update.sync_aggregate,
 //	    signature_slot=update.signature_slot,
 //	)
-func CreateLightClientFinalityUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientFinalityUpdate {
+func createLightClientFinalityUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientFinalityUpdate {
 	finalityUpdate := &ethpbv2.LightClientFinalityUpdate{
 		AttestedHeader:  update.AttestedHeader,
 		FinalizedHeader: update.FinalizedHeader,
@@ -50,7 +51,7 @@ func CreateLightClientFinalityUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2
 	return finalityUpdate
 }
 
-// CreateLightClientOptimisticUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_optimistic_update
+// createLightClientOptimisticUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_optimistic_update
 // def create_light_client_optimistic_update(update: LightClientUpdate) -> LightClientOptimisticUpdate:
 //
 //	return LightClientOptimisticUpdate(
@@ -58,7 +59,7 @@ func CreateLightClientFinalityUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2
 //	    sync_aggregate=update.sync_aggregate,
 //	    signature_slot=update.signature_slot,
 //	)
-func CreateLightClientOptimisticUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientOptimisticUpdate {
+func createLightClientOptimisticUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientOptimisticUpdate {
 	optimisticUpdate := &ethpbv2.LightClientOptimisticUpdate{
 		AttestedHeader: update.AttestedHeader,
 		SyncAggregate:  update.SyncAggregate,
@@ -68,11 +69,98 @@ func CreateLightClientOptimisticUpdate(update *ethpbv2.LightClientUpdate) *ethpb
 	return optimisticUpdate
 }
 
+func NewLightClientFinalityUpdateFromBeaconState(
+	ctx context.Context,
+	state state.BeaconState,
+	block interfaces.ReadOnlySignedBeaconBlock,
+	attestedState state.BeaconState,
+	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
+) (*ethpbv2.LightClientFinalityUpdate, error) {
+	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	if err != nil {
+		return nil, err
+	}
+
+	return createLightClientFinalityUpdate(update), nil
+}
+
 func NewLightClientOptimisticUpdateFromBeaconState(
 	ctx context.Context,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState) (*ethpbv2.LightClientUpdate, error) {
+	attestedState state.BeaconState,
+) (*ethpbv2.LightClientOptimisticUpdate, error) {
+	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return createLightClientOptimisticUpdate(update), nil
+}
+
+// NewLightClientUpdateFromBeaconState implements https://github.com/ethereum/consensus-specs/blob/d70dcd9926a4bbe987f1b4e65c3e05bd029fcfb8/specs/altair/light-client/full-node.md#create_light_client_update
+// def create_light_client_update(state: BeaconState,
+//
+//	                           block: SignedBeaconBlock,
+//	                           attested_state: BeaconState,
+//	                           finalized_block: Optional[SignedBeaconBlock]) -> LightClientUpdate:
+//	assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH
+//	assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS
+//
+//	assert state.slot == state.latest_block_header.slot
+//	header = state.latest_block_header.copy()
+//	header.state_root = hash_tree_root(state)
+//	assert hash_tree_root(header) == hash_tree_root(block.message)
+//	update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot))
+//
+//	assert attested_state.slot == attested_state.latest_block_header.slot
+//	attested_header = attested_state.latest_block_header.copy()
+//	attested_header.state_root = hash_tree_root(attested_state)
+//	assert hash_tree_root(attested_header) == block.message.parent_root
+//	update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
+//
+//	# `next_sync_committee` is only useful if the message is signed by the current sync committee
+//	if update_attested_period == update_signature_period:
+//	    next_sync_committee = attested_state.next_sync_committee
+//	    next_sync_committee_branch = compute_merkle_proof_for_state(attested_state, NEXT_SYNC_COMMITTEE_INDEX)
+//	else:
+//	    next_sync_committee = SyncCommittee()
+//	    next_sync_committee_branch = [Bytes32() for _ in range(floorlog2(NEXT_SYNC_COMMITTEE_INDEX))]
+//
+//	# Indicate finality whenever possible
+//	if finalized_block is not None:
+//	    if finalized_block.message.slot != GENESIS_SLOT:
+//	        finalized_header = BeaconBlockHeader(
+//	            slot=finalized_block.message.slot,
+//	            proposer_index=finalized_block.message.proposer_index,
+//	            parent_root=finalized_block.message.parent_root,
+//	            state_root=finalized_block.message.state_root,
+//	            body_root=hash_tree_root(finalized_block.message.body),
+//	        )
+//	        assert hash_tree_root(finalized_header) == attested_state.finalized_checkpoint.root
+//	    else:
+//	        assert attested_state.finalized_checkpoint.root == Bytes32()
+//	        finalized_header = BeaconBlockHeader()
+//	    finality_branch = compute_merkle_proof_for_state(attested_state, FINALIZED_ROOT_INDEX)
+//	else:
+//	    finalized_header = BeaconBlockHeader()
+//	    finality_branch = [Bytes32() for _ in range(floorlog2(FINALIZED_ROOT_INDEX))]
+//
+//	return LightClientUpdate(
+//	    attested_header=attested_header,
+//	    next_sync_committee=next_sync_committee,
+//	    next_sync_committee_branch=next_sync_committee_branch,
+//	    finalized_header=finalized_header,
+//	    finality_branch=finality_branch,
+//	    sync_aggregate=block.message.body.sync_aggregate,
+//	    signature_slot=block.message.slot,
+//	)
+func NewLightClientUpdateFromBeaconState(
+	ctx context.Context,
+	state state.BeaconState,
+	block interfaces.ReadOnlySignedBeaconBlock,
+	attestedState state.BeaconState,
+	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientUpdate, error) {
 	// assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH
 	attestedEpoch := slots.ToEpoch(attestedState.Slot())
 	if attestedEpoch < params.BeaconConfig().AltairForkEpoch {
@@ -84,7 +172,6 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get sync aggregate")
 	}
-
 	if syncAggregate.SyncCommitteeBits.Count() < params.BeaconConfig().MinSyncCommitteeParticipants {
 		return nil, fmt.Errorf("invalid sync committee bits count %d", syncAggregate.SyncCommitteeBits.Count())
 	}
@@ -101,21 +188,21 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 		return nil, errors.Wrap(err, "could not get state root")
 	}
 	header.StateRoot = stateRoot[:]
-
 	headerRoot, err := header.HashTreeRoot()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get header root")
 	}
-
 	blockRoot, err := block.Block().HashTreeRoot()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get block root")
 	}
-
 	if headerRoot != blockRoot {
 		return nil, fmt.Errorf("header root %#x not equal to block root %#x", headerRoot, blockRoot)
 	}
 
+	// update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot))
+	updateSignaturePeriod := slots.SyncCommitteePeriod(slots.ToEpoch(block.Block().Slot()))
+
 	// assert attested_state.slot == attested_state.latest_block_header.slot
 	if attestedState.Slot() != attestedState.LatestBlockHeader().Slot {
 		return nil, fmt.Errorf("attested state slot %d not equal to attested latest block header slot %d", attestedState.Slot(), attestedState.LatestBlockHeader().Slot)
@@ -136,34 +223,32 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attested header root")
 	}
-
 	if attestedHeaderRoot != block.Block().ParentRoot() {
 		return nil, fmt.Errorf("attested header root %#x not equal to block parent root %#x", attestedHeaderRoot, block.Block().ParentRoot())
 	}
 
-	syncAggregateResult := &ethpbv1.SyncAggregate{
-		SyncCommitteeBits:      syncAggregate.SyncCommitteeBits,
-		SyncCommitteeSignature: syncAggregate.SyncCommitteeSignature,
+	// update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
+	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(attestedHeader.Slot))
+
+	// update = LightClientUpdate()
+	result, err := createDefaultLightClientUpdate(block.Block().Version())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not create default light client update")
 	}
 
-	result := &ethpbv2.LightClientUpdate{
-		SyncAggregate: syncAggregateResult,
-		SignatureSlot: block.Block().Slot(),
+	// update.attested_header = block_to_light_client_header(attested_block)
+	blockHeader := &ethpbv1.BeaconBlockHeader{
+		Slot:          attestedHeader.Slot,
+		ProposerIndex: attestedHeader.ProposerIndex,
+		ParentRoot:    attestedHeader.ParentRoot,
+		StateRoot:     attestedHeader.StateRoot,
+		BodyRoot:      attestedHeader.BodyRoot,
 	}
-
 	switch block.Block().Version() {
 	case version.Altair, version.Bellatrix:
 		result.AttestedHeader = &ethpbv2.LightClientHeaderContainer{
 			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-				HeaderAltair: &ethpbv2.LightClientHeader{
-					Beacon: &ethpbv1.BeaconBlockHeader{
-						Slot:          attestedHeader.Slot,
-						ProposerIndex: attestedHeader.ProposerIndex,
-						ParentRoot:    attestedHeader.ParentRoot,
-						StateRoot:     attestedHeader.StateRoot,
-						BodyRoot:      attestedHeader.BodyRoot,
-					},
-				},
+				HeaderAltair: &ethpbv2.LightClientHeader{Beacon: blockHeader},
 			},
 		}
 	case version.Capella:
@@ -171,49 +256,32 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get execution payload header")
 		}
-
 		executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get execution payload proof")
 		}
-
 		result.AttestedHeader = &ethpbv2.LightClientHeaderContainer{
 			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
 				HeaderCapella: &ethpbv2.LightClientHeaderCapella{
-					Beacon: &ethpbv1.BeaconBlockHeader{
-						Slot:          attestedHeader.Slot,
-						ProposerIndex: attestedHeader.ProposerIndex,
-						ParentRoot:    attestedHeader.ParentRoot,
-						StateRoot:     attestedHeader.StateRoot,
-						BodyRoot:      attestedHeader.BodyRoot,
-					},
+					Beacon:          blockHeader,
 					Execution:       executionPayloadHeader,
 					ExecutionBranch: executionPayloadProof,
 				},
 			},
 		}
-
-	case version.Deneb, version.Electra:
+	case version.Deneb:
 		executionPayloadHeader, err := getExecutionPayloadHeaderDeneb(block)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get execution payload header")
 		}
-
 		executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get execution payload proof")
 		}
-
 		result.AttestedHeader = &ethpbv2.LightClientHeaderContainer{
 			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
 				HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
-					Beacon: &ethpbv1.BeaconBlockHeader{
-						Slot:          attestedHeader.Slot,
-						ProposerIndex: attestedHeader.ProposerIndex,
-						ParentRoot:    attestedHeader.ParentRoot,
-						StateRoot:     attestedHeader.StateRoot,
-						BodyRoot:      attestedHeader.BodyRoot,
-					},
+					Beacon:          blockHeader,
 					Execution:       executionPayloadHeader,
 					ExecutionBranch: executionPayloadProof,
 				},
@@ -223,168 +291,198 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 		return nil, fmt.Errorf("unsupported block version %s", version.String(block.Block().Version()))
 	}
 
-	return result, nil
-}
+	// if update_attested_period == update_signature_period
+	if updateAttestedPeriod == updateSignaturePeriod {
+		tempNextSyncCommittee, err := attestedState.NextSyncCommittee()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get next sync committee")
+		}
+		nextSyncCommittee := &ethpbv2.SyncCommittee{
+			Pubkeys:         tempNextSyncCommittee.Pubkeys,
+			AggregatePubkey: tempNextSyncCommittee.AggregatePubkey,
+		}
+		nextSyncCommitteeBranch, err := attestedState.NextSyncCommitteeProof(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get next sync committee proof")
+		}
 
-func NewLightClientFinalityUpdateFromBeaconState(
-	ctx context.Context,
-	state state.BeaconState,
-	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientUpdate, error) {
-	result, err := NewLightClientOptimisticUpdateFromBeaconState(
-		ctx,
-		state,
-		block,
-		attestedState,
-	)
-	if err != nil {
-		return nil, err
+		// update.next_sync_committee = attested_state.next_sync_committee
+		result.NextSyncCommittee = nextSyncCommittee
+
+		// update.next_sync_committee_branch = NextSyncCommitteeBranch(
+		//     compute_merkle_proof(attested_state, next_sync_committee_gindex_at_slot(attested_state.slot)))
+		result.NextSyncCommitteeBranch = nextSyncCommitteeBranch
 	}
 
-	// Indicate finality whenever possible
-	var finalizedHeaderBeacon *ethpbv1.BeaconBlockHeader
-	var finalityBranch [][]byte
-
+	// if finalized_block is not None
 	if finalizedBlock != nil && !finalizedBlock.IsNil() {
+		// if finalized_block.message.slot != GENESIS_SLOT
 		if finalizedBlock.Block().Slot() != 0 {
-			tempFinalizedHeader, err := finalizedBlock.Header()
+			// update.finalized_header = block_to_light_client_header(finalized_block)
+			v1alpha1FinalizedHeader, err := finalizedBlock.Header()
 			if err != nil {
 				return nil, errors.Wrap(err, "could not get finalized header")
 			}
-			finalizedHeaderBeacon := migration.V1Alpha1SignedHeaderToV1(tempFinalizedHeader).GetMessage()
-
-			finalizedHeaderRoot, err := finalizedHeaderBeacon.HashTreeRoot()
+			finalizedHeader := migration.V1Alpha1SignedHeaderToV1(v1alpha1FinalizedHeader).GetMessage()
+			finalizedHeaderRoot, err := finalizedHeader.HashTreeRoot()
 			if err != nil {
 				return nil, errors.Wrap(err, "could not get finalized header root")
 			}
+			switch block.Block().Version() {
+			case version.Altair, version.Bellatrix:
+				result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
+					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
+						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: finalizedHeader},
+					},
+				}
+			case version.Capella:
+				executionPayloadHeader, err := getExecutionPayloadHeaderCapella(finalizedBlock)
+				if err != nil {
+					return nil, errors.Wrap(err, "could not get execution payload header")
+				}
+				executionPayloadProof, err := blocks.PayloadProof(ctx, finalizedBlock.Block())
+				if err != nil {
+					return nil, errors.Wrap(err, "could not get execution payload proof")
+				}
+				result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
+					Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
+						HeaderCapella: &ethpbv2.LightClientHeaderCapella{
+							Beacon:          finalizedHeader,
+							Execution:       executionPayloadHeader,
+							ExecutionBranch: executionPayloadProof,
+						},
+					},
+				}
+			case version.Deneb:
+				executionPayloadHeader, err := getExecutionPayloadHeaderDeneb(finalizedBlock)
+				if err != nil {
+					return nil, errors.Wrap(err, "could not get execution payload header")
+				}
+				executionPayloadProof, err := blocks.PayloadProof(ctx, finalizedBlock.Block())
+				if err != nil {
+					return nil, errors.Wrap(err, "could not get execution payload proof")
+				}
+				result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
+					Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
+						HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
+							Beacon:          finalizedHeader,
+							Execution:       executionPayloadHeader,
+							ExecutionBranch: executionPayloadProof,
+						},
+					},
+				}
+			default:
+				return nil, fmt.Errorf("unsupported block version %s", version.String(block.Block().Version()))
+			}
 
+			// assert hash_tree_root(update.finalized_header.beacon) == attested_state.finalized_checkpoint.root
 			if finalizedHeaderRoot != bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root) {
-				return nil, fmt.Errorf("finalized header root %#x not equal to attested finalized checkpoint root %#x", finalizedHeaderRoot, bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root))
+				return nil, fmt.Errorf(
+					"finalized header root %#x not equal to attested finalized checkpoint root %#x",
+					finalizedHeaderRoot,
+					bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root),
+				)
 			}
 		} else {
+			// assert attested_state.finalized_checkpoint.root == Bytes32()
 			if !bytes.Equal(attestedState.FinalizedCheckpoint().Root, make([]byte, 32)) {
 				return nil, fmt.Errorf("invalid finalized header root %v", attestedState.FinalizedCheckpoint().Root)
 			}
-
-			finalizedHeaderBeacon = &ethpbv1.BeaconBlockHeader{
-				Slot:          0,
-				ProposerIndex: 0,
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
-				BodyRoot:      make([]byte, 32),
-			}
 		}
 
-		var bErr error
-		finalityBranch, bErr = attestedState.FinalizedRootProof(ctx)
-		if bErr != nil {
-			return nil, errors.Wrap(bErr, "could not get finalized root proof")
-		}
-	} else {
-		finalizedHeaderBeacon = &ethpbv1.BeaconBlockHeader{
-			Slot:          0,
-			ProposerIndex: 0,
-			ParentRoot:    make([]byte, 32),
-			StateRoot:     make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
-		}
-
-		finalityBranch = make([][]byte, FinalityBranchNumOfLeaves)
-		for i := 0; i < FinalityBranchNumOfLeaves; i++ {
-			finalityBranch[i] = make([]byte, 32)
-		}
-	}
-
-	switch block.Block().Version() {
-	case version.Altair, version.Bellatrix:
-		result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-				HeaderAltair: &ethpbv2.LightClientHeader{Beacon: finalizedHeaderBeacon},
-			},
+		// update.finality_branch = FinalityBranch(
+		//     compute_merkle_proof(attested_state, finalized_root_gindex_at_slot(attested_state.slot)))
+		finalityBranch, err := attestedState.FinalizedRootProof(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get finalized root proof")
 		}
 		result.FinalityBranch = finalityBranch
-	case version.Capella:
-		if finalizedBlock != nil && !finalizedBlock.IsNil() {
-			execution, err := getExecutionPayloadHeaderCapella(finalizedBlock)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get execution payload header")
-			}
-			executionBranch, err := blocks.PayloadProof(ctx, finalizedBlock.Block())
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get execution payload proof")
-			}
-
-			result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-				Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
-					HeaderCapella: &ethpbv2.LightClientHeaderCapella{
-						Beacon:          finalizedHeaderBeacon,
-						Execution:       execution,
-						ExecutionBranch: executionBranch,
-					},
-				},
-			}
-			result.FinalityBranch = finalityBranch
-		} else {
-			execution := createEmptyExecutionPayloadHeaderCapella()
-			executionBranch := make([][]byte, 0)
-
-			result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-				Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
-					HeaderCapella: &ethpbv2.LightClientHeaderCapella{
-						Beacon:          finalizedHeaderBeacon,
-						Execution:       execution,
-						ExecutionBranch: executionBranch,
-					},
-				},
-			}
-
-			result.FinalityBranch = finalityBranch
-		}
-	case version.Deneb, version.Electra:
-		if finalizedBlock != nil && !finalizedBlock.IsNil() {
-			execution, err := getExecutionPayloadHeaderDeneb(finalizedBlock)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get execution payload header")
-			}
-			executionBranch, err := blocks.PayloadProof(ctx, finalizedBlock.Block())
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get execution payload proof")
-			}
-
-			result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-				Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
-					HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
-						Beacon:          finalizedHeaderBeacon,
-						Execution:       execution,
-						ExecutionBranch: executionBranch,
-					},
-				},
-			}
-			result.FinalityBranch = finalityBranch
-		} else {
-			execution := createEmptyExecutionPayloadHeaderDeneb()
-			executionBranch := make([][]byte, 0)
-
-			result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-				Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
-					HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
-						Beacon:          finalizedHeaderBeacon,
-						Execution:       execution,
-						ExecutionBranch: executionBranch,
-					},
-				},
-			}
-
-			result.FinalityBranch = finalityBranch
-		}
-	default:
-		return nil, fmt.Errorf("unsupported block version %s", version.String(block.Block().Version()))
 	}
 
+	// update.sync_aggregate = block.message.body.sync_aggregate
+	result.SyncAggregate = &ethpbv1.SyncAggregate{
+		SyncCommitteeBits:      syncAggregate.SyncCommitteeBits,
+		SyncCommitteeSignature: syncAggregate.SyncCommitteeSignature,
+	}
+
+	// update.signature_slot = block.message.slot
+	result.SignatureSlot = block.Block().Slot()
+
 	return result, nil
 }
 
+func createDefaultLightClientUpdate(v int) (*ethpbv2.LightClientUpdate, error) {
+	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
+	pubKeys := make([][]byte, syncCommitteeSize)
+	for i := uint64(0); i < syncCommitteeSize; i++ {
+		pubKeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
+	}
+	nextSyncCommittee := &ethpbv2.SyncCommittee{
+		Pubkeys:         pubKeys,
+		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
+	}
+	nextSyncCommitteeBranch := make([][]byte, fieldparams.NextSyncCommitteeBranchDepth)
+	for i := 0; i < fieldparams.NextSyncCommitteeBranchDepth; i++ {
+		nextSyncCommitteeBranch[i] = make([]byte, fieldparams.RootLength)
+	}
+	executionBranch := make([][]byte, executionBranchNumOfLeaves)
+	for i := 0; i < executionBranchNumOfLeaves; i++ {
+		executionBranch[i] = make([]byte, 32)
+	}
+	finalizedBlockHeader := &ethpbv1.BeaconBlockHeader{
+		Slot:          0,
+		ProposerIndex: 0,
+		ParentRoot:    make([]byte, 32),
+		StateRoot:     make([]byte, 32),
+		BodyRoot:      make([]byte, 32),
+	}
+	finalityBranch := make([][]byte, FinalityBranchNumOfLeaves)
+	for i := 0; i < FinalityBranchNumOfLeaves; i++ {
+		finalityBranch[i] = make([]byte, 32)
+	}
+
+	var finalizedHeader *ethpbv2.LightClientHeaderContainer
+	switch v {
+	case version.Altair, version.Bellatrix:
+		finalizedHeader = &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
+				HeaderAltair: &ethpbv2.LightClientHeader{
+					Beacon: finalizedBlockHeader,
+				},
+			},
+		}
+	case version.Capella:
+		finalizedHeader = &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
+				HeaderCapella: &ethpbv2.LightClientHeaderCapella{
+					Beacon:          finalizedBlockHeader,
+					Execution:       createEmptyExecutionPayloadHeaderCapella(),
+					ExecutionBranch: executionBranch,
+				},
+			},
+		}
+	case version.Deneb:
+		finalizedHeader = &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
+				HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
+					Beacon:          finalizedBlockHeader,
+					Execution:       createEmptyExecutionPayloadHeaderDeneb(),
+					ExecutionBranch: executionBranch,
+				},
+			},
+		}
+	default:
+		return nil, fmt.Errorf("unsupported block version %s", version.String(v))
+	}
+
+	return &ethpbv2.LightClientUpdate{
+		NextSyncCommittee:       nextSyncCommittee,
+		NextSyncCommitteeBranch: nextSyncCommitteeBranch,
+		FinalizedHeader:         finalizedHeader,
+		FinalityBranch:          finalityBranch,
+	}, nil
+}
+
 func createEmptyExecutionPayloadHeaderCapella() *enginev1.ExecutionPayloadHeaderCapella {
 	return &enginev1.ExecutionPayloadHeaderCapella{
 		ParentHash:       make([]byte, 32),
@@ -534,20 +632,196 @@ func getExecutionPayloadHeaderDeneb(block interfaces.ReadOnlySignedBeaconBlock)
 
 	return execution, nil
 }
-func NewLightClientUpdateFromFinalityUpdate(update *ethpbv2.LightClientFinalityUpdate) *ethpbv2.LightClientUpdate {
-	return &ethpbv2.LightClientUpdate{
-		AttestedHeader:  update.AttestedHeader,
-		FinalizedHeader: update.FinalizedHeader,
-		FinalityBranch:  update.FinalityBranch,
-		SyncAggregate:   update.SyncAggregate,
-		SignatureSlot:   update.SignatureSlot,
+
+func ComputeTransactionsRoot(payload interfaces.ExecutionData) ([]byte, error) {
+	transactionsRoot, err := payload.TransactionsRoot()
+	if errors.Is(err, consensus_types.ErrUnsupportedField) {
+		transactions, err := payload.Transactions()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get transactions")
+		}
+		transactionsRootArray, err := ssz.TransactionsRoot(transactions)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get transactions root")
+		}
+		transactionsRoot = transactionsRootArray[:]
+	} else if err != nil {
+		return nil, errors.Wrap(err, "could not get transactions root")
 	}
+	return transactionsRoot, nil
 }
 
-func NewLightClientUpdateFromOptimisticUpdate(update *ethpbv2.LightClientOptimisticUpdate) *ethpbv2.LightClientUpdate {
-	return &ethpbv2.LightClientUpdate{
-		AttestedHeader: update.AttestedHeader,
-		SyncAggregate:  update.SyncAggregate,
-		SignatureSlot:  update.SignatureSlot,
+func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
+	withdrawalsRoot, err := payload.WithdrawalsRoot()
+	if errors.Is(err, consensus_types.ErrUnsupportedField) {
+		withdrawals, err := payload.Withdrawals()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals")
+		}
+		withdrawalsRootArray, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals root")
+		}
+		withdrawalsRoot = withdrawalsRootArray[:]
+	} else if err != nil {
+		return nil, errors.Wrap(err, "could not get withdrawals root")
 	}
+	return withdrawalsRoot, nil
+}
+
+func BlockToLightClientHeaderAltair(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeader, error) {
+	if block.Version() != version.Altair {
+		return nil, fmt.Errorf("block version is %s instead of Altair", version.String(block.Version()))
+	}
+
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	return &ethpbv2.LightClientHeader{
+		Beacon: &ethpbv1.BeaconBlockHeader{
+			Slot:          block.Block().Slot(),
+			ProposerIndex: block.Block().ProposerIndex(),
+			ParentRoot:    parentRoot[:],
+			StateRoot:     stateRoot[:],
+			BodyRoot:      bodyRoot[:],
+		},
+	}, nil
+}
+
+func BlockToLightClientHeaderCapella(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderCapella, error) {
+	if block.Version() != version.Capella {
+		return nil, fmt.Errorf("block version is %s instead of Capella", version.String(block.Version()))
+	}
+
+	payload, err := block.Block().Body().Execution()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload")
+	}
+
+	transactionsRoot, err := ComputeTransactionsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+	withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	executionHeader := &v11.ExecutionPayloadHeaderCapella{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload proof")
+	}
+
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	return &ethpbv2.LightClientHeaderCapella{
+		Beacon: &ethpbv1.BeaconBlockHeader{
+			Slot:          block.Block().Slot(),
+			ProposerIndex: block.Block().ProposerIndex(),
+			ParentRoot:    parentRoot[:],
+			StateRoot:     stateRoot[:],
+			BodyRoot:      bodyRoot[:],
+		},
+		Execution:       executionHeader,
+		ExecutionBranch: executionPayloadProof,
+	}, nil
+}
+
+func BlockToLightClientHeaderDeneb(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderDeneb, error) {
+	if block.Version() != version.Deneb {
+		return nil, fmt.Errorf("block version is %s instead of Deneb", version.String(block.Version()))
+	}
+
+	payload, err := block.Block().Body().Execution()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload")
+	}
+
+	transactionsRoot, err := ComputeTransactionsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+	withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payload.BlobGasUsed()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get blob gas used")
+	}
+	excessBlobGas, err := payload.ExcessBlobGas()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get excess blob gas")
+	}
+
+	executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+		BlobGasUsed:      blobGasUsed,
+		ExcessBlobGas:    excessBlobGas,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload proof")
+	}
+
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	return &ethpbv2.LightClientHeaderDeneb{
+		Beacon: &ethpbv1.BeaconBlockHeader{
+			Slot:          block.Block().Slot(),
+			ProposerIndex: block.Block().ProposerIndex(),
+			ParentRoot:    parentRoot[:],
+			StateRoot:     stateRoot[:],
+			BodyRoot:      bodyRoot[:],
+		},
+		Execution:       executionHeader,
+		ExecutionBranch: executionPayloadProof,
+	}, nil
 }

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

@@ -3,30 +3,17 @@ package light_client_test
 import (
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+
 	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+	light_client "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateCapella(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestCapella()
-
-	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
-	require.NoError(t, err)
-	require.NotNil(t, update, "update is nil")
-
-	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-	l.CheckSyncAggregate(update)
-	l.CheckAttestedHeader(update)
-
-	require.Equal(t, (*v2.LightClientHeaderContainer)(nil), update.FinalizedHeader, "Finalized header is not nil")
-	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
-}
-
 func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateAltair(t *testing.T) {
 	l := util.NewTestLightClient(t).SetupTestAltair()
 
@@ -36,15 +23,12 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateAltair(t *test
 
 	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
 
-	l.CheckSyncAggregate(update)
-	l.CheckAttestedHeader(update)
-
-	require.Equal(t, (*v2.LightClientHeaderContainer)(nil), update.FinalizedHeader, "Finalized header is not nil")
-	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
+	l.CheckSyncAggregate(update.SyncAggregate)
+	l.CheckAttestedHeader(update.AttestedHeader)
 }
 
-func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateDeneb(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestDeneb()
+func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateCapella(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestCapella(false)
 
 	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
 	require.NoError(t, err)
@@ -52,22 +36,34 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateDeneb(t *testi
 
 	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
 
-	l.CheckSyncAggregate(update)
-	l.CheckAttestedHeader(update)
-
-	require.Equal(t, (*v2.LightClientHeaderContainer)(nil), update.FinalizedHeader, "Finalized header is not nil")
-	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
+	l.CheckSyncAggregate(update.SyncAggregate)
+	l.CheckAttestedHeader(update.AttestedHeader)
 }
-func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateCapella(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestCapella()
+
+func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateDeneb(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestDeneb(false)
+
+	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
+	require.NoError(t, err)
+	require.NotNil(t, update, "update is nil")
+
+	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
+
+	l.CheckSyncAggregate(update.SyncAggregate)
+	l.CheckAttestedHeader(update.AttestedHeader)
+}
+
+func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateAltair(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestAltair()
+
 	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
 	require.NoError(t, err)
 	require.NotNil(t, update, "update is nil")
 
 	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
 
-	l.CheckSyncAggregate(update)
-	l.CheckAttestedHeader(update)
+	l.CheckSyncAggregate(update.SyncAggregate)
+	l.CheckAttestedHeader(update.AttestedHeader)
 
 	zeroHash := params.BeaconConfig().ZeroHash[:]
 	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
@@ -84,17 +80,16 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateCapella(t *testi
 	}
 }
 
-func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateAltair(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestAltair()
-
+func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateCapella(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestCapella(false)
 	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
 	require.NoError(t, err)
 	require.NotNil(t, update, "update is nil")
 
 	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
 
-	l.CheckSyncAggregate(update)
-	l.CheckAttestedHeader(update)
+	l.CheckSyncAggregate(update.SyncAggregate)
+	l.CheckAttestedHeader(update.AttestedHeader)
 
 	zeroHash := params.BeaconConfig().ZeroHash[:]
 	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
@@ -112,7 +107,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateAltair(t *testin
 }
 
 func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateDeneb(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestDeneb()
+	l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
 	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
 	require.NoError(t, err)
@@ -120,8 +115,8 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateDeneb(t *testing
 
 	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
 
-	l.CheckSyncAggregate(update)
-	l.CheckAttestedHeader(update)
+	l.CheckSyncAggregate(update.SyncAggregate)
+	l.CheckAttestedHeader(update.AttestedHeader)
 
 	zeroHash := params.BeaconConfig().ZeroHash[:]
 	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
@@ -139,4 +134,251 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateDeneb(t *testing
 	}
 }
 
+func TestLightClient_BlockToLightClientHeaderAltair(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestAltair()
+
+	header, err := lightClient.BlockToLightClientHeaderAltair(l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderCapella_NonBlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestCapella(false)
+
+	header, err := lightClient.BlockToLightClientHeaderCapella(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := light_client.ComputeTransactionsRoot(payload)
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := light_client.ComputeWithdrawalsRoot(payload)
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderCapella{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderCapella_BlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestCapella(true)
+
+	header, err := lightClient.BlockToLightClientHeaderCapella(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := payload.TransactionsRoot()
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := payload.WithdrawalsRoot()
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderCapella{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderDeneb_NonBlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestDeneb(false)
+
+	header, err := lightClient.BlockToLightClientHeaderDeneb(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := light_client.ComputeTransactionsRoot(payload)
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := light_client.ComputeWithdrawalsRoot(payload)
+	require.NoError(t, err)
+
+	blobGasUsed, err := payload.BlobGasUsed()
+	require.NoError(t, err)
+
+	excessBlobGas, err := payload.ExcessBlobGas()
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+		BlobGasUsed:      blobGasUsed,
+		ExcessBlobGas:    excessBlobGas,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderDeneb_BlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestDeneb(true)
+
+	header, err := lightClient.BlockToLightClientHeaderDeneb(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := payload.TransactionsRoot()
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := payload.WithdrawalsRoot()
+	require.NoError(t, err)
+
+	blobGasUsed, err := payload.BlobGasUsed()
+	require.NoError(t, err)
+
+	excessBlobGas, err := payload.ExcessBlobGas()
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+		BlobGasUsed:      blobGasUsed,
+		ExcessBlobGas:    excessBlobGas,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
 // TODO - add finality update tests with non-nil finalized block for different versions

beacon-chain/core/transition/BUILD.bazel

@@ -49,7 +49,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",
+        "@io_opentelemetry_go_otel_trace//:go_default_library",
     ],
 )
 

beacon-chain/core/transition/transition.go

@@ -25,9 +25,9 @@ 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"
+	prysmTrace "github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	goTrace "go.opencensus.io/trace"
+	"go.opentelemetry.io/otel/trace"
 )
 
 type customProcessingFn func(context.Context, state.BeaconState) error
@@ -63,7 +63,7 @@ func ExecuteStateTransition(
 		return nil, err
 	}
 
-	ctx, span := trace.StartSpan(ctx, "core.state.ExecuteStateTransition")
+	ctx, span := prysmTrace.StartSpan(ctx, "core.state.ExecuteStateTransition")
 	defer span.End()
 	var err error
 
@@ -103,9 +103,9 @@ func ExecuteStateTransition(
 //	  previous_block_root = hash_tree_root(state.latest_block_header)
 //	  state.block_roots[state.slot % SLOTS_PER_HISTORICAL_ROOT] = previous_block_root
 func ProcessSlot(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlot")
+	ctx, span := prysmTrace.StartSpan(ctx, "core.state.ProcessSlot")
 	defer span.End()
-	span.AddAttributes(trace.Int64Attribute("slot", int64(state.Slot()))) // lint:ignore uintcast -- This is OK for tracing.
+	span.SetAttributes(prysmTrace.Int64Attribute("slot", int64(state.Slot()))) // lint:ignore uintcast -- This is OK for tracing.
 
 	prevStateRoot, err := state.HashTreeRoot(ctx)
 	if err != nil {
@@ -148,7 +148,7 @@ func ProcessSlotsUsingNextSlotCache(
 	parentState state.BeaconState,
 	parentRoot []byte,
 	slot primitives.Slot) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlotsUsingNextSlotCache")
+	ctx, span := prysmTrace.StartSpan(ctx, "core.state.ProcessSlotsUsingNextSlotCache")
 	defer span.End()
 
 	nextSlotState := NextSlotState(parentRoot, slot)
@@ -178,12 +178,12 @@ func ProcessSlotsIfPossible(ctx context.Context, state state.BeaconState, target
 
 // ProcessSlots includes core slot processing as well as a cache
 func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.Slot) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlots")
+	ctx, span := prysmTrace.StartSpan(ctx, "core.state.ProcessSlots")
 	defer span.End()
 	if state == nil || state.IsNil() {
 		return nil, errors.New("nil state")
 	}
-	span.AddAttributes(trace.Int64Attribute("slots", int64(slot)-int64(state.Slot()))) // lint:ignore uintcast -- This is OK for tracing.
+	span.SetAttributes(prysmTrace.Int64Attribute("slots", int64(slot)-int64(state.Slot()))) // lint:ignore uintcast -- This is OK for tracing.
 
 	// The block must have a higher slot than parent state.
 	if state.Slot() >= slot {
@@ -259,7 +259,7 @@ func cacheBestBeaconStateOnErrFn(highestSlot primitives.Slot, key [32]byte) cust
 //	      if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
 //	          process_epoch(state)
 //	      state.slot = Slot(state.slot + 1)
-func ProcessSlotsCore(ctx context.Context, span *goTrace.Span, state state.BeaconState, slot primitives.Slot, fn customProcessingFn) (state.BeaconState, error) {
+func ProcessSlotsCore(ctx context.Context, span trace.Span, state state.BeaconState, slot primitives.Slot, fn customProcessingFn) (state.BeaconState, error) {
 	var err error
 	for state.Slot() < slot {
 		if fn != nil {
@@ -318,7 +318,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 
 // UpgradeState upgrades the state to the next version if possible.
 func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.UpgradeState")
+	ctx, span := prysmTrace.StartSpan(ctx, "core.state.UpgradeState")
 	defer span.End()
 
 	var err error
@@ -445,9 +445,9 @@ func VerifyOperationLengths(_ context.Context, state state.BeaconState, b interf
 // ProcessEpochPrecompute describes the per epoch operations that are performed on the beacon state.
 // It's optimized by pre computing validator attested info and epoch total/attested balances upfront.
 func ProcessEpochPrecompute(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.ProcessEpochPrecompute")
+	ctx, span := prysmTrace.StartSpan(ctx, "core.state.ProcessEpochPrecompute")
 	defer span.End()
-	span.AddAttributes(trace.Int64Attribute("epoch", int64(time.CurrentEpoch(state)))) // lint:ignore uintcast -- This is OK for tracing.
+	span.SetAttributes(prysmTrace.Int64Attribute("epoch", int64(time.CurrentEpoch(state)))) // lint:ignore uintcast -- This is OK for tracing.
 
 	if state == nil || state.IsNil() {
 		return nil, errors.New("nil state")

beacon-chain/db/filesystem/cache.go

@@ -114,5 +114,5 @@ func (s *blobStorageCache) evict(key [32]byte) {
 func (s *blobStorageCache) updateMetrics(delta float64) {
 	s.nBlobs += delta
 	blobDiskCount.Set(s.nBlobs)
-	blobDiskSize.Set(s.nBlobs * bytesPerSidecar)
+	blobDiskSize.Set(s.nBlobs * fieldparams.BlobSidecarSize)
 }

beacon-chain/db/filesystem/pruner.go

@@ -21,7 +21,6 @@ import (
 )
 
 const retentionBuffer primitives.Epoch = 2
-const bytesPerSidecar = 131928
 
 var (
 	errPruningFailures = errors.New("blobs could not be pruned for some roots")

beacon-chain/db/kv/BUILD.bazel

@@ -70,7 +70,6 @@ go_library(
         "@com_github_schollz_progressbar_v3//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_etcd_go_bbolt//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
@@ -117,6 +116,7 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
+        "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",

beacon-chain/db/kv/archived_point.go

@@ -5,8 +5,8 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
 )
 
 // LastArchivedSlot from the db.

beacon-chain/db/kv/backfill.go

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

beacon-chain/db/kv/deposit_contract.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
 )
 
 // DepositContractAddress returns contract address is the address of

beacon-chain/db/kv/encoding.go

@@ -7,8 +7,8 @@ import (
 
 	"github.com/golang/snappy"
 	fastssz "github.com/prysmaticlabs/fastssz"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"go.opencensus.io/trace"
 	"google.golang.org/protobuf/proto"
 )
 

beacon-chain/db/kv/lightclient.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
 )
 
 func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update *ethpbv2.LightClientUpdateWithVersion) error {

beacon-chain/db/kv/lightclient_test.go

@@ -5,38 +5,179 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
-func TestStore_LightclientUpdate_CanSaveRetrieve(t *testing.T) {
+func TestStore_LightClientUpdate_CanSaveRetrieveAltair(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
 	update := &ethpbv2.LightClientUpdate{
-		AttestedHeader:          nil,
-		NextSyncCommittee:       nil,
+		AttestedHeader: &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
+				HeaderAltair: &ethpbv2.LightClientHeader{
+					Beacon: &ethpbv1.BeaconBlockHeader{
+						Slot:          1,
+						ProposerIndex: 1,
+						ParentRoot:    []byte{1, 1, 1},
+						StateRoot:     []byte{1, 1, 1},
+						BodyRoot:      []byte{1, 1, 1},
+					},
+				},
+			},
+		},
+		NextSyncCommittee: &ethpbv2.SyncCommittee{
+			Pubkeys:         nil,
+			AggregatePubkey: nil,
+		},
 		NextSyncCommitteeBranch: nil,
-		FinalizedHeader:         nil,
-		FinalityBranch:          nil,
-		SyncAggregate:           nil,
-		SignatureSlot:           7,
+		FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
+				HeaderAltair: &ethpbv2.LightClientHeader{
+					Beacon: &ethpbv1.BeaconBlockHeader{
+						Slot:          1,
+						ProposerIndex: 1,
+						ParentRoot:    []byte{1, 1, 1},
+						StateRoot:     []byte{1, 1, 1},
+						BodyRoot:      []byte{1, 1, 1},
+					},
+				},
+			},
+		},
+		FinalityBranch: nil,
+		SyncAggregate:  nil,
+		SignatureSlot:  7,
 	}
-
 	period := uint64(1)
 	err := db.SaveLightClientUpdate(ctx, period, &ethpbv2.LightClientUpdateWithVersion{
-		Version: 1,
+		Version: version.Altair,
 		Data:    update,
 	})
 	require.NoError(t, err)
 
-	// Retrieve the update
 	retrievedUpdate, err := db.LightClientUpdate(ctx, period)
 	require.NoError(t, err)
-	require.Equal(t, update.SignatureSlot, retrievedUpdate.Data.SignatureSlot, "retrieved update does not match saved update")
-
+	require.DeepEqual(t, update, retrievedUpdate.Data, "retrieved update does not match saved update")
 }
 
-func TestStore_LightclientUpdates_canRetrieveRange(t *testing.T) {
+func TestStore_LightClientUpdate_CanSaveRetrieveCapella(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	update := &ethpbv2.LightClientUpdate{
+		AttestedHeader: &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
+				HeaderCapella: &ethpbv2.LightClientHeaderCapella{
+					Beacon: &ethpbv1.BeaconBlockHeader{
+						Slot:          1,
+						ProposerIndex: 1,
+						ParentRoot:    []byte{1, 1, 1},
+						StateRoot:     []byte{1, 1, 1},
+						BodyRoot:      []byte{1, 1, 1},
+					},
+					Execution: &enginev1.ExecutionPayloadHeaderCapella{
+						FeeRecipient: []byte{1, 2, 3},
+					},
+					ExecutionBranch: [][]byte{{1, 2, 3}, {4, 5, 6}},
+				},
+			},
+		},
+		NextSyncCommittee: &ethpbv2.SyncCommittee{
+			Pubkeys:         nil,
+			AggregatePubkey: nil,
+		},
+		NextSyncCommitteeBranch: nil,
+		FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
+				HeaderCapella: &ethpbv2.LightClientHeaderCapella{
+					Beacon: &ethpbv1.BeaconBlockHeader{
+						Slot:          1,
+						ProposerIndex: 1,
+						ParentRoot:    []byte{1, 1, 1},
+						StateRoot:     []byte{1, 1, 1},
+						BodyRoot:      []byte{1, 1, 1},
+					},
+					Execution:       nil,
+					ExecutionBranch: nil,
+				},
+			},
+		},
+		FinalityBranch: nil,
+		SyncAggregate:  nil,
+		SignatureSlot:  7,
+	}
+	period := uint64(1)
+	err := db.SaveLightClientUpdate(ctx, period, &ethpbv2.LightClientUpdateWithVersion{
+		Version: version.Capella,
+		Data:    update,
+	})
+	require.NoError(t, err)
+
+	retrievedUpdate, err := db.LightClientUpdate(ctx, period)
+	require.NoError(t, err)
+	require.DeepEqual(t, update, retrievedUpdate.Data, "retrieved update does not match saved update")
+}
+
+func TestStore_LightClientUpdate_CanSaveRetrieveDeneb(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	update := &ethpbv2.LightClientUpdate{
+		AttestedHeader: &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
+				HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
+					Beacon: &ethpbv1.BeaconBlockHeader{
+						Slot:          1,
+						ProposerIndex: 1,
+						ParentRoot:    []byte{1, 1, 1},
+						StateRoot:     []byte{1, 1, 1},
+						BodyRoot:      []byte{1, 1, 1},
+					},
+					Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+						FeeRecipient: []byte{1, 2, 3},
+					},
+					ExecutionBranch: [][]byte{{1, 2, 3}, {4, 5, 6}},
+				},
+			},
+		},
+		NextSyncCommittee: &ethpbv2.SyncCommittee{
+			Pubkeys:         nil,
+			AggregatePubkey: nil,
+		},
+		NextSyncCommitteeBranch: nil,
+		FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
+				HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
+					Beacon: &ethpbv1.BeaconBlockHeader{
+						Slot:          1,
+						ProposerIndex: 1,
+						ParentRoot:    []byte{1, 1, 1},
+						StateRoot:     []byte{1, 1, 1},
+						BodyRoot:      []byte{1, 1, 1},
+					},
+					Execution:       nil,
+					ExecutionBranch: nil,
+				},
+			},
+		},
+		FinalityBranch: nil,
+		SyncAggregate:  nil,
+		SignatureSlot:  7,
+	}
+	period := uint64(1)
+	err := db.SaveLightClientUpdate(ctx, period, &ethpbv2.LightClientUpdateWithVersion{
+		Version: version.Deneb,
+		Data:    update,
+	})
+	require.NoError(t, err)
+
+	retrievedUpdate, err := db.LightClientUpdate(ctx, period)
+	require.NoError(t, err)
+	require.DeepEqual(t, update, retrievedUpdate.Data, "retrieved update does not match saved update")
+}
+
+func TestStore_LightClientUpdates_canRetrieveRange(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
 	updates := []*ethpbv2.LightClientUpdateWithVersion{

beacon-chain/db/kv/state.go

@@ -16,11 +16,11 @@ 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"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
 )
 
 // State returns the saved state using block's signing root,
@@ -74,7 +74,7 @@ func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
 		tracing.AnnotateError(span, err)
 		return nil, err
 	}
-	span.AddAttributes(trace.BoolAttribute("cache_hit", cached != nil))
+	span.SetAttributes(trace.BoolAttribute("cache_hit", cached != nil))
 	if cached != nil {
 		return cached, nil
 	}

beacon-chain/db/slasherkv/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_golang_snappy//:go_default_library",
@@ -29,7 +30,6 @@ go_library(
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_etcd_go_bbolt//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )

beacon-chain/db/slasherkv/slasher.go

@@ -14,9 +14,9 @@ import (
 	slashertypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
 	"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"
 	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
 )
 

beacon-chain/execution/block_cache.go

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

beacon-chain/execution/block_reader.go

@@ -31,10 +31,10 @@ func (s *Service) BlockExists(ctx context.Context, hash common.Hash) (bool, *big
 		if err != nil {
 			return false, nil, err
 		}
-		span.AddAttributes(trace.BoolAttribute("blockCacheHit", true))
+		span.SetAttributes(trace.BoolAttribute("blockCacheHit", true))
 		return true, hdrInfo.Number, nil
 	}
-	span.AddAttributes(trace.BoolAttribute("blockCacheHit", false))
+	span.SetAttributes(trace.BoolAttribute("blockCacheHit", false))
 	header, err := s.HeaderByHash(ctx, hash)
 	if err != nil {
 		return false, big.NewInt(0), errors.Wrap(err, "could not query block with given hash")
@@ -56,10 +56,10 @@ func (s *Service) BlockHashByHeight(ctx context.Context, height *big.Int) (commo
 		if err != nil {
 			return [32]byte{}, err
 		}
-		span.AddAttributes(trace.BoolAttribute("headerCacheHit", true))
+		span.SetAttributes(trace.BoolAttribute("headerCacheHit", true))
 		return hInfo.Hash, nil
 	}
-	span.AddAttributes(trace.BoolAttribute("headerCacheHit", false))
+	span.SetAttributes(trace.BoolAttribute("headerCacheHit", false))
 
 	if s.rpcClient == nil {
 		err := errors.New("nil rpc client")

beacon-chain/node/BUILD.bazel

@@ -65,7 +65,6 @@ go_library(
         "//runtime/prereqs:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
@@ -82,6 +81,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/server/middleware:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",

beacon-chain/node/config.go

@@ -8,12 +8,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	tracing2 "github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	"github.com/urfave/cli/v2"
 )
 
 func configureTracing(cliCtx *cli.Context) error {
-	return tracing2.Setup(
+	return tracing.Setup(
 		"beacon-chain", // service name
 		cliCtx.String(cmd.TracingProcessNameFlag.Name),
 		cliCtx.String(cmd.TracingEndpointFlag.Name),

beacon-chain/node/node.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"net"
+	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -17,7 +18,6 @@ import (
 	"syscall"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/httprest"
 	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
@@ -361,7 +361,7 @@ func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *sta
 	}
 
 	log.Debugln("Registering RPC Service")
-	router := newRouter(cliCtx)
+	router := http.NewServeMux()
 	if err := beacon.registerRPCService(router); err != nil {
 		return errors.Wrap(err, "could not register RPC service")
 	}
@@ -397,19 +397,6 @@ func initSyncWaiter(ctx context.Context, complete chan struct{}) func() error {
 	}
 }
 
-func newRouter(cliCtx *cli.Context) *mux.Router {
-	var allowedOrigins []string
-	if cliCtx.IsSet(flags.HTTPServerCorsDomain.Name) {
-		allowedOrigins = strings.Split(cliCtx.String(flags.HTTPServerCorsDomain.Name), ",")
-	} else {
-		allowedOrigins = strings.Split(flags.HTTPServerCorsDomain.Value, ",")
-	}
-	r := mux.NewRouter()
-	r.Use(middleware.NormalizeQueryValuesHandler)
-	r.Use(middleware.CorsHandler(allowedOrigins))
-	return r
-}
-
 // StateFeed implements statefeed.Notifier.
 func (b *BeaconNode) StateFeed() *event.Feed {
 	return b.stateFeed
@@ -916,7 +903,7 @@ func (b *BeaconNode) registerSlasherService() error {
 	return b.services.RegisterService(slasherSrv)
 }
 
-func (b *BeaconNode) registerRPCService(router *mux.Router) error {
+func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 	var chainService *blockchain.Service
 	if err := b.services.FetchService(&chainService); err != nil {
 		return err
@@ -1043,13 +1030,26 @@ func (b *BeaconNode) registerPrometheusService(_ *cli.Context) error {
 	return b.services.RegisterService(service)
 }
 
-func (b *BeaconNode) registerHTTPService(router *mux.Router) error {
+func (b *BeaconNode) registerHTTPService(router *http.ServeMux) error {
 	host := b.cliCtx.String(flags.HTTPServerHost.Name)
 	port := b.cliCtx.Int(flags.HTTPServerPort.Name)
 	address := net.JoinHostPort(host, strconv.Itoa(port))
+	var allowedOrigins []string
+	if b.cliCtx.IsSet(flags.HTTPServerCorsDomain.Name) {
+		allowedOrigins = strings.Split(b.cliCtx.String(flags.HTTPServerCorsDomain.Name), ",")
+	} else {
+		allowedOrigins = strings.Split(flags.HTTPServerCorsDomain.Value, ",")
+	}
+
+	middlewares := []middleware.Middleware{
+		middleware.NormalizeQueryValuesHandler,
+		middleware.CorsHandler(allowedOrigins),
+	}
+
 	opts := []httprest.Option{
 		httprest.WithRouter(router),
 		httprest.WithHTTPAddr(address),
+		httprest.WithMiddlewares(middlewares),
 	}
 	if b.cliCtx.IsSet(cmd.ApiTimeoutFlag.Name) {
 		opts = append(opts, httprest.WithTimeout(b.cliCtx.Duration(cmd.ApiTimeoutFlag.Name)))

beacon-chain/node/node_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
@@ -252,19 +253,19 @@ func Test_hasNetworkFlag(t *testing.T) {
 }
 
 func TestCORS(t *testing.T) {
-	// Mock CLI context with a test CORS domain
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	set.String(flags.HTTPServerCorsDomain.Name, "http://allowed-example.com", "")
-	cliCtx := cli.NewContext(&app, set, nil)
-	require.NoError(t, cliCtx.Set(flags.HTTPServerCorsDomain.Name, "http://allowed-example.com"))
-
-	router := newRouter(cliCtx)
-
+	router := http.NewServeMux()
 	// Ensure a test route exists
-	router.HandleFunc("/some-path", func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	}).Methods(http.MethodGet)
+	router.HandleFunc("/some-path", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodGet {
+			w.WriteHeader(http.StatusOK)
+		} else {
+			http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
+		}
+	})
+
+	// Register the CORS middleware on mux Router
+	allowedOrigins := []string{"http://allowed-example.com"}
+	handler := middleware.CorsHandler(allowedOrigins)(router)
 
 	// Define test cases
 	tests := []struct {
@@ -285,7 +286,7 @@ func TestCORS(t *testing.T) {
 			rr := httptest.NewRecorder()
 
 			// Serve HTTP
-			router.ServeHTTP(rr, req)
+			handler.ServeHTTP(rr, req)
 
 			// Check the CORS headers based on the expected outcome
 			if tc.expectAllow && rr.Header().Get("Access-Control-Allow-Origin") != tc.origin {

beacon-chain/operations/attestations/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
         "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
@@ -32,7 +33,6 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/operations/attestations/kv/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
@@ -24,7 +25,6 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/operations/attestations/kv/aggregated.go

@@ -8,12 +8,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"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"
 	attaggregation "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation/aggregation/attestations"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	log "github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 )
 
 // AggregateUnaggregatedAttestations aggregates the unaggregated attestations and saves the

beacon-chain/operations/attestations/kv/unaggregated.go

@@ -6,10 +6,10 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"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"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"go.opencensus.io/trace"
 )
 
 // SaveUnaggregatedAttestation saves an unaggregated attestation in cache.

beacon-chain/operations/attestations/prepare_forkchoice.go

@@ -9,11 +9,11 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"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"
 	attaggregation "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation/aggregation/attestations"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"go.opencensus.io/trace"
 )
 
 // This prepares fork choice attestations by running batchForkChoiceAtts

beacon-chain/operations/slashings/BUILD.bazel

@@ -23,13 +23,13 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_trailofbits_go_mutexasserts//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/operations/slashings/service.go

@@ -13,9 +13,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/trailofbits/go-mutexasserts"
-	"go.opencensus.io/trace"
 )
 
 // NewPool returns an initialized attester slashing and proposer slashing pool.

beacon-chain/p2p/BUILD.bazel

@@ -105,7 +105,6 @@ go_library(
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/p2p/broadcaster.go

@@ -110,7 +110,7 @@ func (s *Service) internalBroadcastAttestation(ctx context.Context, subnet uint6
 	hasPeer := s.hasPeerWithSubnet(attestationToTopic(subnet, forkDigest))
 	s.subnetLocker(subnet).RUnlock()
 
-	span.AddAttributes(
+	span.SetAttributes(
 		trace.BoolAttribute("hasPeer", hasPeer),
 		trace.Int64Attribute("slot", int64(att.GetData().Slot)), // lint:ignore uintcast -- It's safe to do this for tracing.
 		trace.Int64Attribute("subnet", int64(subnet)),           // lint:ignore uintcast -- It's safe to do this for tracing.
@@ -169,7 +169,7 @@ func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMs
 	hasPeer := s.hasPeerWithSubnet(syncCommitteeToTopic(subnet, forkDigest))
 	s.subnetLocker(wrappedSubIdx).RUnlock()
 
-	span.AddAttributes(
+	span.SetAttributes(
 		trace.BoolAttribute("hasPeer", hasPeer),
 		trace.Int64Attribute("slot", int64(sMsg.Slot)), // lint:ignore uintcast -- It's safe to do this for tracing.
 		trace.Int64Attribute("subnet", int64(subnet)),  // lint:ignore uintcast -- It's safe to do this for tracing.
@@ -273,7 +273,7 @@ func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic
 	ctx, span := trace.StartSpan(ctx, "p2p.broadcastObject")
 	defer span.End()
 
-	span.AddAttributes(trace.StringAttribute("topic", topic))
+	span.SetAttributes(trace.StringAttribute("topic", topic))
 
 	buf := new(bytes.Buffer)
 	if _, err := s.Encoding().EncodeGossip(buf, obj); err != nil {
@@ -282,12 +282,12 @@ func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic
 		return err
 	}
 
-	if span.IsRecordingEvents() {
+	if span.IsRecording() {
 		id := hash.FastSum64(buf.Bytes())
 		messageLen := int64(buf.Len())
 		// lint:ignore uintcast -- It's safe to do this for tracing.
 		iid := int64(id)
-		span.AddMessageSendEvent(iid, messageLen /*uncompressed*/, messageLen /*compressed*/)
+		span = trace.AddMessageSendEvent(span, iid, messageLen /*uncompressed*/, messageLen /*compressed*/)
 	}
 	if err := s.PublishToTopic(ctx, topic+s.Encoding().ProtocolSuffix(), buf.Bytes()); err != nil {
 		err := errors.Wrap(err, "could not publish message")

beacon-chain/p2p/dial_relay_node.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/peer"
-	"go.opencensus.io/trace"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 )
 
 // MakePeer from multiaddress string.

beacon-chain/p2p/sender.go

@@ -10,8 +10,8 @@ import (
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 )
 
 // Send a message to a specific peer. The returned stream may be used for reading, but has been
@@ -25,7 +25,7 @@ func (s *Service) Send(ctx context.Context, message interface{}, baseTopic strin
 		return nil, err
 	}
 	topic := baseTopic + s.Encoding().ProtocolSuffix()
-	span.AddAttributes(trace.StringAttribute("topic", topic))
+	span.SetAttributes(trace.StringAttribute("topic", topic))
 
 	log.WithFields(logrus.Fields{
 		"topic":   topic,

beacon-chain/p2p/subnets.go

@@ -57,7 +57,7 @@ func (s *Service) FindPeersWithSubnet(ctx context.Context, topic string,
 	ctx, span := trace.StartSpan(ctx, "p2p.FindPeersWithSubnet")
 	defer span.End()
 
-	span.AddAttributes(trace.Int64Attribute("index", int64(index))) // lint:ignore uintcast -- It's safe to do this for tracing.
+	span.SetAttributes(trace.Int64Attribute("index", int64(index))) // lint:ignore uintcast -- It's safe to do this for tracing.
 
 	if s.dv5Listener == nil {
 		// return if discovery isn't set

beacon-chain/rpc/BUILD.bazel

@@ -55,7 +55,6 @@ go_library(
         "//io/logs:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_grpc_ecosystem_go_grpc_middleware//:go_default_library",
         "@com_github_grpc_ecosystem_go_grpc_middleware//recovery:go_default_library",
         "@com_github_grpc_ecosystem_go_grpc_middleware//tracing/opentracing:go_default_library",
@@ -88,7 +87,6 @@ go_test(
         "//beacon-chain/sync/initial-sync/testing:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],

beacon-chain/rpc/core/BUILD.bazel

@@ -36,13 +36,13 @@ go_library(
         "//consensus-types/validator:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time: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",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],

beacon-chain/rpc/core/validator.go

@@ -25,12 +25,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"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"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
 )
 

beacon-chain/rpc/endpoints.go

@@ -3,7 +3,6 @@ package rpc
 import (
 	"net/http"
 
-	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/prysmaticlabs/prysm/v5/api"
@@ -30,7 +29,7 @@ import (
 type endpoint struct {
 	template   string
 	name       string
-	middleware []mux.MiddlewareFunc
+	middleware []middleware.Middleware
 	handler    http.HandlerFunc
 	methods    []string
 }
@@ -93,7 +92,7 @@ func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater,
 		{
 			template: "/eth/v1/beacon/rewards/blocks/{block_id}",
 			name:     namespace + ".BlockRewards",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.BlockRewards,
@@ -102,7 +101,7 @@ func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater,
 		{
 			template: "/eth/v1/beacon/rewards/attestations/{epoch}",
 			name:     namespace + ".AttestationRewards",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -112,7 +111,7 @@ func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater,
 		{
 			template: "/eth/v1/beacon/rewards/sync_committee/{block_id}",
 			name:     namespace + ".SyncCommitteeRewards",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -134,7 +133,7 @@ func (s *Service) builderEndpoints(stater lookup.Stater) []endpoint {
 		{
 			template: "/eth/v1/builder/states/{state_id}/expected_withdrawals",
 			name:     namespace + ".ExpectedWithdrawals",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.ExpectedWithdrawals,
@@ -153,7 +152,7 @@ func (*Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 		{
 			template: "/eth/v1/beacon/blob_sidecars/{block_id}",
 			name:     namespace + ".Blobs",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.Blobs,
@@ -194,7 +193,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/aggregate_attestation",
 			name:     namespace + ".GetAggregateAttestation",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetAggregateAttestation,
@@ -203,7 +202,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/contribution_and_proofs",
 			name:     namespace + ".SubmitContributionAndProofs",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -213,7 +212,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/aggregate_and_proofs",
 			name:     namespace + ".SubmitAggregateAndProofs",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -223,7 +222,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/sync_committee_contribution",
 			name:     namespace + ".ProduceSyncCommitteeContribution",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.ProduceSyncCommitteeContribution,
@@ -232,7 +231,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/sync_committee_subscriptions",
 			name:     namespace + ".SubmitSyncCommitteeSubscription",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -242,7 +241,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/beacon_committee_subscriptions",
 			name:     namespace + ".SubmitBeaconCommitteeSubscription",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -252,7 +251,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/attestation_data",
 			name:     namespace + ".GetAttestationData",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetAttestationData,
@@ -261,7 +260,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/register_validator",
 			name:     namespace + ".RegisterValidator",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -271,7 +270,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/duties/attester/{epoch}",
 			name:     namespace + ".GetAttesterDuties",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -281,7 +280,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/duties/proposer/{epoch}",
 			name:     namespace + ".GetProposerDuties",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetProposerDuties,
@@ -290,7 +289,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/duties/sync/{epoch}",
 			name:     namespace + ".GetSyncCommitteeDuties",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -300,7 +299,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/prepare_beacon_proposer",
 			name:     namespace + ".PrepareBeaconProposer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -310,7 +309,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/liveness/{epoch}",
 			name:     namespace + ".GetLiveness",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -320,7 +319,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v2/validator/blocks/{slot}",
 			name:     namespace + ".ProduceBlockV2",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.ProduceBlockV2,
@@ -329,7 +328,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/blinded_blocks/{slot}",
 			name:     namespace + ".ProduceBlindedBlock",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.ProduceBlindedBlock,
@@ -338,7 +337,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v3/validator/blocks/{slot}",
 			name:     namespace + ".ProduceBlockV3",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.ProduceBlockV3,
@@ -347,7 +346,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/beacon_committee_selections",
 			name:     namespace + ".BeaconCommitteeSelections",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.BeaconCommitteeSelections,
@@ -356,7 +355,7 @@ func (s *Service) validatorEndpoints(
 		{
 			template: "/eth/v1/validator/sync_committee_selections",
 			name:     namespace + ".SyncCommittee Selections",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.SyncCommitteeSelections,
@@ -384,7 +383,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/syncing",
 			name:     namespace + ".GetSyncStatus",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetSyncStatus,
@@ -393,7 +392,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/identity",
 			name:     namespace + ".GetIdentity",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetIdentity,
@@ -402,7 +401,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/peers/{peer_id}",
 			name:     namespace + ".GetPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetPeer,
@@ -411,7 +410,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/peers",
 			name:     namespace + ".GetPeers",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetPeers,
@@ -420,7 +419,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/peer_count",
 			name:     namespace + ".GetPeerCount",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetPeerCount,
@@ -429,7 +428,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/version",
 			name:     namespace + ".GetVersion",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetVersion,
@@ -438,7 +437,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 		{
 			template: "/eth/v1/node/health",
 			name:     namespace + ".GetHealth",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetHealth,
@@ -486,7 +485,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/committees",
 			name:     namespace + ".GetCommittees",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetCommittees,
@@ -495,7 +494,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/fork",
 			name:     namespace + ".GetStateFork",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetStateFork,
@@ -504,7 +503,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/root",
 			name:     namespace + ".GetStateRoot",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetStateRoot,
@@ -513,7 +512,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/sync_committees",
 			name:     namespace + ".GetSyncCommittees",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetSyncCommittees,
@@ -522,7 +521,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/randao",
 			name:     namespace + ".GetRandao",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetRandao,
@@ -531,7 +530,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/blocks",
 			name:     namespace + ".PublishBlock",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -541,7 +540,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/blinded_blocks",
 			name:     namespace + ".PublishBlindedBlock",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -551,7 +550,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v2/beacon/blocks",
 			name:     namespace + ".PublishBlockV2",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -561,7 +560,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v2/beacon/blinded_blocks",
 			name:     namespace + ".PublishBlindedBlockV2",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -571,7 +570,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v2/beacon/blocks/{block_id}",
 			name:     namespace + ".GetBlockV2",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetBlockV2,
@@ -580,7 +579,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/blocks/{block_id}/attestations",
 			name:     namespace + ".GetBlockAttestations",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetBlockAttestations,
@@ -589,7 +588,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/blinded_blocks/{block_id}",
 			name:     namespace + ".GetBlindedBlock",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetBlindedBlock,
@@ -598,7 +597,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/blocks/{block_id}/root",
 			name:     namespace + ".GetBlockRoot",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetBlockRoot,
@@ -607,7 +606,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/attestations",
 			name:     namespace + ".ListAttestations",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.ListAttestations,
@@ -616,7 +615,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/attestations",
 			name:     namespace + ".SubmitAttestations",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -626,7 +625,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/voluntary_exits",
 			name:     namespace + ".ListVoluntaryExits",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.ListVoluntaryExits,
@@ -635,7 +634,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/voluntary_exits",
 			name:     namespace + ".SubmitVoluntaryExit",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -645,7 +644,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/sync_committees",
 			name:     namespace + ".SubmitSyncCommitteeSignatures",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -655,7 +654,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/bls_to_execution_changes",
 			name:     namespace + ".ListBLSToExecutionChanges",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.ListBLSToExecutionChanges,
@@ -664,7 +663,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/bls_to_execution_changes",
 			name:     namespace + ".SubmitBLSToExecutionChanges",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -674,7 +673,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/attester_slashings",
 			name:     namespace + ".GetAttesterSlashings",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetAttesterSlashings,
@@ -683,7 +682,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/attester_slashings",
 			name:     namespace + ".SubmitAttesterSlashing",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -693,7 +692,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/proposer_slashings",
 			name:     namespace + ".GetProposerSlashings",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetProposerSlashings,
@@ -702,7 +701,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/pool/proposer_slashings",
 			name:     namespace + ".SubmitProposerSlashing",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -712,7 +711,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/headers",
 			name:     namespace + ".GetBlockHeaders",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetBlockHeaders,
@@ -721,7 +720,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/headers/{block_id}",
 			name:     namespace + ".GetBlockHeader",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetBlockHeader,
@@ -730,7 +729,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/genesis",
 			name:     namespace + ".GetGenesis",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetGenesis,
@@ -739,7 +738,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/finality_checkpoints",
 			name:     namespace + ".GetFinalityCheckpoints",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetFinalityCheckpoints,
@@ -748,7 +747,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/validators",
 			name:     namespace + ".GetValidators",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -758,7 +757,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/validators/{validator_id}",
 			name:     namespace + ".GetValidator",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetValidator,
@@ -767,7 +766,7 @@ func (s *Service) beaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/validator_balances",
 			name:     namespace + ".GetValidatorBalances",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -783,7 +782,7 @@ func (*Service) configEndpoints() []endpoint {
 		{
 			template: "/eth/v1/config/deposit_contract",
 			name:     namespace + ".GetDepositContract",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: config.GetDepositContract,
@@ -792,7 +791,7 @@ func (*Service) configEndpoints() []endpoint {
 		{
 			template: "/eth/v1/config/fork_schedule",
 			name:     namespace + ".GetForkSchedule",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: config.GetForkSchedule,
@@ -801,7 +800,7 @@ func (*Service) configEndpoints() []endpoint {
 		{
 			template: "/eth/v1/config/spec",
 			name:     namespace + ".GetSpec",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: config.GetSpec,
@@ -823,7 +822,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 		{
 			template: "/eth/v1/beacon/light_client/bootstrap/{block_root}",
 			name:     namespace + ".GetLightClientBootstrap",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetLightClientBootstrap,
@@ -832,7 +831,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 		{
 			template: "/eth/v1/beacon/light_client/updates",
 			name:     namespace + ".GetLightClientUpdatesByRange",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetLightClientUpdatesByRange,
@@ -841,7 +840,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 		{
 			template: "/eth/v1/beacon/light_client/finality_update",
 			name:     namespace + ".GetLightClientFinalityUpdate",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetLightClientFinalityUpdate,
@@ -850,7 +849,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 		{
 			template: "/eth/v1/beacon/light_client/optimistic_update",
 			name:     namespace + ".GetLightClientOptimisticUpdate",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetLightClientOptimisticUpdate,
@@ -876,7 +875,7 @@ func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
 		{
 			template: "/eth/v2/debug/beacon/states/{state_id}",
 			name:     namespace + ".GetBeaconStateV2",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetBeaconStateV2,
@@ -885,7 +884,7 @@ func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
 		{
 			template: "/eth/v2/debug/beacon/heads",
 			name:     namespace + ".GetForkChoiceHeadsV2",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetForkChoiceHeadsV2,
@@ -894,7 +893,7 @@ func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
 		{
 			template: "/eth/v1/debug/fork_choice",
 			name:     namespace + ".GetForkChoice",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetForkChoice,
@@ -917,7 +916,7 @@ func (s *Service) eventsEndpoints() []endpoint {
 		{
 			template: "/eth/v1/events",
 			name:     namespace + ".StreamEvents",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.EventStreamMediaType}),
 			},
 			handler: server.StreamEvents,
@@ -950,7 +949,7 @@ func (s *Service) prysmBeaconEndpoints(
 		{
 			template: "/prysm/v1/beacon/weak_subjectivity",
 			name:     namespace + ".GetWeakSubjectivity",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetWeakSubjectivity,
@@ -959,7 +958,7 @@ func (s *Service) prysmBeaconEndpoints(
 		{
 			template: "/eth/v1/beacon/states/{state_id}/validator_count",
 			name:     namespace + ".GetValidatorCount",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetValidatorCount,
@@ -968,7 +967,7 @@ func (s *Service) prysmBeaconEndpoints(
 		{
 			template: "/prysm/v1/beacon/states/{state_id}/validator_count",
 			name:     namespace + ".GetValidatorCount",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetValidatorCount,
@@ -977,7 +976,7 @@ func (s *Service) prysmBeaconEndpoints(
 		{
 			template: "/prysm/v1/beacon/individual_votes",
 			name:     namespace + ".GetIndividualVotes",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -987,7 +986,7 @@ func (s *Service) prysmBeaconEndpoints(
 		{
 			template: "/prysm/v1/beacon/chain_head",
 			name:     namespace + ".GetChainHead",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetChainHead,
@@ -1014,7 +1013,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 		{
 			template: "/prysm/node/trusted_peers",
 			name:     namespace + ".ListTrustedPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.ListTrustedPeer,
@@ -1023,7 +1022,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 		{
 			template: "/prysm/v1/node/trusted_peers",
 			name:     namespace + ".ListTrustedPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.ListTrustedPeer,
@@ -1032,7 +1031,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 		{
 			template: "/prysm/node/trusted_peers",
 			name:     namespace + ".AddTrustedPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -1042,7 +1041,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 		{
 			template: "/prysm/v1/node/trusted_peers",
 			name:     namespace + ".AddTrustedPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -1052,7 +1051,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 		{
 			template: "/prysm/node/trusted_peers/{peer_id}",
 			name:     namespace + ".RemoveTrustedPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.RemoveTrustedPeer,
@@ -1061,7 +1060,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 		{
 			template: "/prysm/v1/node/trusted_peers/{peer_id}",
 			name:     namespace + ".RemoveTrustedPeer",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.RemoveTrustedPeer,
@@ -1082,7 +1081,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 		{
 			template: "/prysm/validators/performance",
 			name:     namespace + ".GetPerformance",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -1092,7 +1091,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 		{
 			template: "/prysm/v1/validators/performance",
 			name:     namespace + ".GetPerformance",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
@@ -1102,7 +1101,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 		{
 			template: "/prysm/v1/validators/participation",
 			name:     namespace + ".GetParticipation",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetParticipation,
@@ -1111,7 +1110,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 		{
 			template: "/prysm/v1/validators/active_set_changes",
 			name:     namespace + ".GetActiveSetChanges",
-			middleware: []mux.MiddlewareFunc{
+			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.GetActiveSetChanges,

beacon-chain/rpc/eth/beacon/BUILD.bazel

@@ -52,16 +52,15 @@ go_library(
         "//consensus-types/validator:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_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",
     ],
 )
 
@@ -120,7 +119,6 @@ go_test(
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",

beacon-chain/rpc/eth/beacon/handlers.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/api"
@@ -29,12 +28,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	eth "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"
 )
 
 const (
@@ -54,7 +53,7 @@ func (s *Server) GetBlockV2(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockV2")
 	defer span.End()
 
-	blockId := mux.Vars(r)["block_id"]
+	blockId := r.PathValue("block_id")
 	if blockId == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
@@ -85,7 +84,7 @@ func (s *Server) GetBlindedBlock(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlindedBlock")
 	defer span.End()
 
-	blockId := mux.Vars(r)["block_id"]
+	blockId := r.PathValue("block_id")
 	if blockId == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
@@ -201,7 +200,7 @@ func (s *Server) GetBlockAttestations(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockAttestations")
 	defer span.End()
 
-	blockId := mux.Vars(r)["block_id"]
+	blockId := r.PathValue("block_id")
 	if blockId == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
@@ -1037,7 +1036,7 @@ func (s *Server) GetBlockRoot(w http.ResponseWriter, r *http.Request) {
 
 	var err error
 	var root []byte
-	blockID := mux.Vars(r)["block_id"]
+	blockID := r.PathValue("block_id")
 	if blockID == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
@@ -1149,7 +1148,8 @@ func (s *Server) GetBlockRoot(w http.ResponseWriter, r *http.Request) {
 func (s *Server) GetStateFork(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetStateFork")
 	defer span.End()
-	stateId := mux.Vars(r)["state_id"]
+
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return
@@ -1189,7 +1189,7 @@ func (s *Server) GetCommittees(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetCommittees")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return
@@ -1374,7 +1374,7 @@ func (s *Server) GetBlockHeader(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockHeader")
 	defer span.End()
 
-	blockID := mux.Vars(r)["block_id"]
+	blockID := r.PathValue("block_id")
 	if blockID == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
@@ -1432,7 +1432,7 @@ func (s *Server) GetFinalityCheckpoints(w http.ResponseWriter, r *http.Request)
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetFinalityCheckpoints")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return

beacon-chain/rpc/eth/beacon/handlers_pool.go

@@ -23,11 +23,11 @@ import (
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"go.opencensus.io/trace"
 )
 
 const broadcastBLSChangesRateLimit = 128

beacon-chain/rpc/eth/beacon/handlers_state.go

@@ -8,7 +8,6 @@ import (
 	"strconv"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/helpers"
@@ -18,10 +17,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"go.opencensus.io/trace"
 )
 
 type syncCommitteeStateRequest struct {
@@ -34,7 +33,7 @@ func (s *Server) GetStateRoot(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetStateRoot")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return
@@ -85,7 +84,7 @@ func (s *Server) GetRandao(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetRandao")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return
@@ -151,7 +150,7 @@ func (s *Server) GetSyncCommittees(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetSyncCommittees")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return

beacon-chain/rpc/eth/beacon/handlers_state_test.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	chainMock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	dbTest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
@@ -56,7 +55,7 @@ func TestGetStateRoot(t *testing.T) {
 	}
 
 	request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/root", nil)
-	request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+	request.SetPathValue("state_id", "head")
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -80,7 +79,7 @@ func TestGetStateRoot(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/root", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -111,7 +110,7 @@ func TestGetStateRoot(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/root", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -158,7 +157,7 @@ func TestGetRandao(t *testing.T) {
 
 	t.Run("no epoch requested", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/randao", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -170,7 +169,7 @@ func TestGetRandao(t *testing.T) {
 	})
 	t.Run("current epoch requested", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com//eth/v1/beacon/states/{state_id}/randao?epoch=%d", epochCurrent), nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -182,7 +181,7 @@ func TestGetRandao(t *testing.T) {
 	})
 	t.Run("old epoch requested", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com//eth/v1/beacon/states/{state_id}/randao?epoch=%d", epochOld), nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -198,7 +197,7 @@ func TestGetRandao(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/randao", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -211,7 +210,7 @@ func TestGetRandao(t *testing.T) {
 	t.Run("epoch too old", func(t *testing.T) {
 		epochTooOld := primitives.Epoch(100000 - st.RandaoMixesLength())
 		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com//eth/v1/beacon/states/{state_id}/randao?epoch=%d", epochTooOld), nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -225,7 +224,7 @@ func TestGetRandao(t *testing.T) {
 	t.Run("epoch in the future", func(t *testing.T) {
 		futureEpoch := primitives.Epoch(100000 + 1)
 		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com//eth/v1/beacon/states/{state_id}/randao?epoch=%d", futureEpoch), nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -257,7 +256,7 @@ func TestGetRandao(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/randao", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -294,7 +293,7 @@ func TestGetRandao(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/randao", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -453,7 +452,7 @@ func TestGetSyncCommittees(t *testing.T) {
 	}
 
 	request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/sync_committees", nil)
-	request = mux.SetURLVars(request, map[string]string{"state_id": hexutil.Encode(stRoot[:])})
+	request.SetPathValue("state_id", hexutil.Encode(stRoot[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -503,7 +502,7 @@ func TestGetSyncCommittees(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/sync_committees", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": hexutil.Encode(stRoot[:])})
+		request.SetPathValue("state_id", hexutil.Encode(stRoot[:]))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -547,7 +546,7 @@ func TestGetSyncCommittees(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com//eth/v1/beacon/states/{state_id}/sync_committees", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": hexutil.Encode(stRoot[:])})
+		request.SetPathValue("state_id", hexutil.Encode(stRoot[:]))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -613,7 +612,7 @@ func TestGetSyncCommittees_Future(t *testing.T) {
 
 	epoch := 2 * params.BeaconConfig().EpochsPerSyncCommitteePeriod
 	request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com//eth/v1/beacon/states/{state_id}/sync_committees?epoch=%d", epoch), nil)
-	request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+	request.SetPathValue("state_id", "head")
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 	s.GetSyncCommittees(writer, request)
@@ -625,7 +624,7 @@ func TestGetSyncCommittees_Future(t *testing.T) {
 
 	epoch = 2*params.BeaconConfig().EpochsPerSyncCommitteePeriod - 1
 	request = httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com//eth/v1/beacon/states/{state_id}/sync_committees?epoch=%d", epoch), nil)
-	request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+	request.SetPathValue("state_id", "head")
 	writer = httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 	s.GetSyncCommittees(writer, request)

beacon-chain/rpc/eth/beacon/handlers_test.go

@@ -13,7 +13,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/api"
@@ -96,7 +95,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "123552314"})
+		request.SetPathValue("block_id", "123552314")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -118,7 +117,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -151,7 +150,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -185,7 +184,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -219,7 +218,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -253,7 +252,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -287,7 +286,7 @@ func TestGetBlockV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -314,7 +313,7 @@ func TestGetBlockV2(t *testing.T) {
 			}
 
 			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(r[:])})
+			request.SetPathValue("block_id", hexutil.Encode(r[:]))
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -333,7 +332,7 @@ func TestGetBlockV2(t *testing.T) {
 			}
 
 			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(r[:])})
+			request.SetPathValue("block_id", hexutil.Encode(r[:]))
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -358,7 +357,7 @@ func TestGetBlockSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -381,7 +380,7 @@ func TestGetBlockSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -404,7 +403,7 @@ func TestGetBlockSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -427,7 +426,7 @@ func TestGetBlockSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -450,7 +449,7 @@ func TestGetBlockSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -517,7 +516,7 @@ func TestGetBlockAttestations(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}/attestations", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -551,7 +550,7 @@ func TestGetBlockAttestations(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}/attestations", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -578,7 +577,7 @@ func TestGetBlockAttestations(t *testing.T) {
 			}
 
 			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}/attestations", nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+			request.SetPathValue("block_id", "head")
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -597,7 +596,7 @@ func TestGetBlockAttestations(t *testing.T) {
 			}
 
 			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}/attestations", nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+			request.SetPathValue("block_id", "head")
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -622,7 +621,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -651,7 +650,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -682,7 +681,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -713,7 +712,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -744,7 +743,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -777,7 +776,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -803,7 +802,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(root[:])})
+		request.SetPathValue("block_id", hexutil.Encode(root[:]))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -829,7 +828,7 @@ func TestGetBlindedBlock(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(root[:])})
+		request.SetPathValue("block_id", hexutil.Encode(root[:]))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -852,7 +851,7 @@ func TestGetBlindedBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -874,7 +873,7 @@ func TestGetBlindedBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -896,7 +895,7 @@ func TestGetBlindedBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -918,7 +917,7 @@ func TestGetBlindedBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -940,7 +939,7 @@ func TestGetBlindedBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2803,8 +2802,9 @@ func TestServer_GetBlockRoot(t *testing.T) {
 		}
 		for _, tt := range tests {
 			t.Run(tt.name, func(t *testing.T) {
+				blockID := tt.blockID
 				request := httptest.NewRequest(http.MethodGet, url, nil)
-				request = mux.SetURLVars(request, tt.blockID)
+				request.SetPathValue("block_id", blockID["block_id"])
 				writer := httptest.NewRecorder()
 
 				writer.Body = &bytes.Buffer{}
@@ -2847,7 +2847,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, url, nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -2882,7 +2882,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 		}
 		t.Run("true", func(t *testing.T) {
 			request := httptest.NewRequest(http.MethodGet, url, nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": "32"})
+			request.SetPathValue("block_id", "32")
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -2894,7 +2894,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 		})
 		t.Run("false", func(t *testing.T) {
 			request := httptest.NewRequest(http.MethodGet, url, nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": "64"})
+			request.SetPathValue("block_id", "64")
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -2910,7 +2910,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 func TestGetStateFork(t *testing.T) {
 	ctx := context.Background()
 	request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/states/{state_id}/fork", nil)
-	request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+	request.SetPathValue("state_id", "head")
 	request.Header.Set("Accept", "application/octet-stream")
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
@@ -2949,7 +2949,7 @@ func TestGetStateFork(t *testing.T) {
 	assert.DeepEqual(t, hexutil.Encode(expectedFork.PreviousVersion), stateForkReponse.Data.PreviousVersion)
 	t.Run("execution optimistic", func(t *testing.T) {
 		request = httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/states/{state_id}/fork", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", "application/octet-stream")
 		writer = httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2980,7 +2980,7 @@ func TestGetStateFork(t *testing.T) {
 
 	t.Run("finalized", func(t *testing.T) {
 		request = httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/states/{state_id}/fork", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", "application/octet-stream")
 		writer = httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -3038,7 +3038,7 @@ func TestGetCommittees(t *testing.T) {
 
 	t.Run("Head all committees", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, url, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3059,7 +3059,7 @@ func TestGetCommittees(t *testing.T) {
 	t.Run("Head all committees of epoch 10", func(t *testing.T) {
 		query := url + "?epoch=10"
 		request := httptest.NewRequest(http.MethodGet, query, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3076,7 +3076,7 @@ func TestGetCommittees(t *testing.T) {
 	t.Run("Head all committees of slot 4", func(t *testing.T) {
 		query := url + "?slot=4"
 		request := httptest.NewRequest(http.MethodGet, query, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3102,7 +3102,7 @@ func TestGetCommittees(t *testing.T) {
 	t.Run("Head all committees of index 1", func(t *testing.T) {
 		query := url + "?index=1"
 		request := httptest.NewRequest(http.MethodGet, query, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3128,7 +3128,7 @@ func TestGetCommittees(t *testing.T) {
 	t.Run("Head all committees of slot 2, index 1", func(t *testing.T) {
 		query := url + "?slot=2&index=1"
 		request := httptest.NewRequest(http.MethodGet, query, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3171,7 +3171,7 @@ func TestGetCommittees(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, url, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3208,7 +3208,7 @@ func TestGetCommittees(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, url, nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 
 		writer.Body = &bytes.Buffer{}
@@ -3481,7 +3481,7 @@ func TestServer_GetBlockHeader(t *testing.T) {
 
 	t.Run("ok", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/headers/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -3525,7 +3525,7 @@ func TestServer_GetBlockHeader(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/headers/{block_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.SetPathValue("block_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -3549,7 +3549,7 @@ func TestServer_GetBlockHeader(t *testing.T) {
 			}
 
 			request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/headers/{block_id}", nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(r[:])})
+			request.SetPathValue("block_id", hexutil.Encode(r[:]))
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -3569,7 +3569,7 @@ func TestServer_GetBlockHeader(t *testing.T) {
 			}
 
 			request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/headers/{block_id}", nil)
-			request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(r[:])})
+			request.SetPathValue("block_id", hexutil.Encode(r[:]))
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -3621,7 +3621,7 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 
 	t.Run("ok", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, "/eth/v1/beacon/states/{state_id}/finality_checkpoints", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -3651,7 +3651,7 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 	})
 	t.Run("state not found", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, "/eth/v1/beacon/states/{state_id}/finality_checkpoints", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "foobar"})
+		request.SetPathValue("state_id", "foobar")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -3674,7 +3674,7 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "/eth/v1/beacon/states/{state_id}/finality_checkpoints", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -3702,7 +3702,7 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "/eth/v1/beacon/states/{state_id}/finality_checkpoints", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 

beacon-chain/rpc/eth/beacon/handlers_validator.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/helpers"
@@ -20,9 +19,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"go.opencensus.io/trace"
 )
 
 // GetValidators returns filterable list of validators with their balance, status and index.
@@ -30,7 +29,7 @@ func (s *Server) GetValidators(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetValidators")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return
@@ -179,12 +178,12 @@ func (s *Server) GetValidator(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetValidator")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return
 	}
-	valId := mux.Vars(r)["validator_id"]
+	valId := r.PathValue("validator_id")
 	if valId == "" {
 		httputil.HandleError(w, "validator_id is required in URL params", http.StatusBadRequest)
 		return
@@ -244,7 +243,7 @@ func (s *Server) GetValidatorBalances(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetValidatorBalances")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return

beacon-chain/rpc/eth/beacon/handlers_validators_test.go

@@ -11,7 +11,6 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	chainMock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
@@ -47,7 +46,7 @@ func TestGetValidators(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -86,7 +85,7 @@ func TestGetValidators(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators?id=0&id=1",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -118,7 +117,7 @@ func TestGetValidators(t *testing.T) {
 			fmt.Sprintf("http://example.com/eth/v1/beacon/states/{state_id}/validators?id=%s&id=%s", hexPubkey1, hexPubkey2),
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -148,7 +147,7 @@ func TestGetValidators(t *testing.T) {
 			fmt.Sprintf("http://example.com/eth/v1/beacon/states/{state_id}/validators?id=%s&id=1", hexPubkey),
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -197,7 +196,7 @@ func TestGetValidators(t *testing.T) {
 			fmt.Sprintf("http://example.com/eth/v1/beacon/states/{state_id}/validators?id=%s&id=%s", hexPubkey, hexutil.Encode([]byte(strings.Repeat("x", fieldparams.BLSPubkeyLength)))),
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -220,7 +219,7 @@ func TestGetValidators(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators?id=1&id=99999", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -243,7 +242,7 @@ func TestGetValidators(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -271,7 +270,7 @@ func TestGetValidators(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -306,7 +305,7 @@ func TestGetValidators(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators",
 			&body,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -342,7 +341,7 @@ func TestGetValidators(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators",
 			&body,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -368,7 +367,7 @@ func TestGetValidators(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -398,7 +397,7 @@ func TestGetValidators(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators",
 			&body,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -492,7 +491,7 @@ func TestGetValidators_FilterByStatus(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators?status=active", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -523,7 +522,7 @@ func TestGetValidators_FilterByStatus(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators?status=active_ongoing", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -553,7 +552,7 @@ func TestGetValidators_FilterByStatus(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators?status=exited", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -586,7 +585,7 @@ func TestGetValidators_FilterByStatus(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators?status=pending_initialized&status=exited_unslashed",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -619,7 +618,7 @@ func TestGetValidators_FilterByStatus(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validators?status=pending&status=exited_slashed",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -654,7 +653,8 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head", "validator_id": "0"})
+		request.SetPathValue("state_id", "head")
+		request.SetPathValue("validator_id", "0")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -689,7 +689,8 @@ func TestGetValidator(t *testing.T) {
 		pubKey := st.PubkeyAtIndex(primitives.ValidatorIndex(0))
 		hexPubkey := hexutil.Encode(pubKey[:])
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head", "validator_id": hexPubkey})
+		request.SetPathValue("state_id", "head")
+		request.SetPathValue("validator_id", hexPubkey)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -708,7 +709,7 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"validator_id": "1"})
+		request.SetPathValue("validator_id", "1")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -728,7 +729,7 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -748,7 +749,8 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head", "validator_id": "99999"})
+		request.SetPathValue("state_id", "head")
+		request.SetPathValue("validator_id", "99999")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -768,7 +770,8 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head", "validator_id": hexutil.Encode([]byte(strings.Repeat("x", fieldparams.BLSPubkeyLength)))})
+		request.SetPathValue("state_id", "head")
+		request.SetPathValue("validator_id", hexutil.Encode([]byte(strings.Repeat("x", fieldparams.BLSPubkeyLength))))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -791,7 +794,8 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head", "validator_id": "0"})
+		request.SetPathValue("state_id", "head")
+		request.SetPathValue("validator_id", "0")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -819,7 +823,8 @@ func TestGetValidator(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validators/{validator_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head", "validator_id": "0"})
+		request.SetPathValue("state_id", "head")
+		request.SetPathValue("validator_id", "0")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -853,7 +858,7 @@ func TestGetValidatorBalances(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validator_balances", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -882,7 +887,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validator_balances?id=0&id=1",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -914,7 +919,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			fmt.Sprintf("http://example.com/eth/v1/beacon/states/{state_id}/validator_balances?id=%s&id=%s", hexPubkey1, hexPubkey2),
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -944,7 +949,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			fmt.Sprintf("http://example.com/eth/v1/beacon/states/{state_id}/validators?id=%s&id=1", hexPubkey),
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -974,7 +979,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			fmt.Sprintf("http://example.com/eth/v1/beacon/states/{state_id}/validator_balances?id=%s&id=%s", hexPubkey, hexutil.Encode([]byte(strings.Repeat("x", fieldparams.BLSPubkeyLength)))),
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -997,7 +1002,7 @@ func TestGetValidatorBalances(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/validator_balances?id=1&id=99999", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -1043,7 +1048,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validator_balances?id=0",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -1075,7 +1080,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validator_balances?id=0",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -1108,7 +1113,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validator_balances",
 			&body,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -1136,7 +1141,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validator_balances",
 			nil,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -1166,7 +1171,7 @@ func TestGetValidatorBalances(t *testing.T) {
 			"http://example.com/eth/v1/beacon/states/{state_id}/validator_balances",
 			&body,
 		)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 

beacon-chain/rpc/eth/blob/BUILD.bazel

@@ -13,10 +13,11 @@ go_library(
         "//beacon-chain/rpc/core:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
         "//config/fieldparams:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
     ],
 )
 
@@ -32,6 +33,7 @@ go_test(
         "//beacon-chain/rpc/lookup:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/rpc/eth/blob/handlers.go

@@ -8,19 +8,19 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
-	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"go.opencensus.io/trace"
 )
 
 // Blobs is an HTTP handler for Beacon API getBlobs.
 func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.Blobs")
 	defer span.End()
-	var sidecars []*eth.BlobSidecar
 
 	indices, err := parseIndices(r.URL)
 	if err != nil {
@@ -48,14 +48,9 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 	}
-	for i := range verifiedBlobs {
-		sidecars = append(sidecars, verifiedBlobs[i].BlobSidecar)
-	}
+
 	if httputil.RespondWithSsz(r) {
-		sidecarResp := &eth.BlobSidecars{
-			Sidecars: sidecars,
-		}
-		sszResp, err := sidecarResp.MarshalSSZ()
+		sszResp, err := buildSidecarsSSZResponse(verifiedBlobs)
 		if err != nil {
 			httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
 			return
@@ -64,7 +59,7 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	httputil.WriteJson(w, buildSidecarsResponse(sidecars))
+	httputil.WriteJson(w, buildSidecarsJsonResponse(verifiedBlobs))
 }
 
 // parseIndices filters out invalid and duplicate blob indices
@@ -97,9 +92,9 @@ loop:
 	return indices, nil
 }
 
-func buildSidecarsResponse(sidecars []*eth.BlobSidecar) *structs.SidecarsResponse {
-	resp := &structs.SidecarsResponse{Data: make([]*structs.Sidecar, len(sidecars))}
-	for i, sc := range sidecars {
+func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) *structs.SidecarsResponse {
+	resp := &structs.SidecarsResponse{Data: make([]*structs.Sidecar, len(verifiedBlobs))}
+	for i, sc := range verifiedBlobs {
 		proofs := make([]string, len(sc.CommitmentInclusionProof))
 		for j := range sc.CommitmentInclusionProof {
 			proofs[j] = hexutil.Encode(sc.CommitmentInclusionProof[j])
@@ -115,3 +110,15 @@ func buildSidecarsResponse(sidecars []*eth.BlobSidecar) *structs.SidecarsRespons
 	}
 	return resp
 }
+
+func buildSidecarsSSZResponse(verifiedBlobs []*blocks.VerifiedROBlob) ([]byte, error) {
+	ssz := make([]byte, field_params.BlobSidecarSize*len(verifiedBlobs))
+	for i, sidecar := range verifiedBlobs {
+		sszrep, err := sidecar.MarshalSSZ()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to marshal sidecar ssz")
+		}
+		copy(ssz[i*field_params.BlobSidecarSize:(i+1)*field_params.BlobSidecarSize], sszrep)
+	}
+	return ssz, nil
+}

beacon-chain/rpc/eth/blob/handlers_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/testutil"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -366,7 +367,32 @@ func TestBlobs(t *testing.T) {
 		}
 		s.Blobs(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
-		require.Equal(t, len(writer.Body.Bytes()), 131932)
+		require.Equal(t, len(writer.Body.Bytes()), fieldparams.BlobSidecarSize) // size of each sidecar
+		// can directly unmarshal to sidecar since there's only 1
+		var sidecar eth.BlobSidecar
+		require.NoError(t, sidecar.UnmarshalSSZ(writer.Body.Bytes()))
+		require.NotNil(t, sidecar.Blob)
+	})
+	t.Run("ssz multiple blobs", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		blocker := &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s := &Server{
+			Blocker: blocker,
+		}
+		s.Blobs(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		require.Equal(t, len(writer.Body.Bytes()), fieldparams.BlobSidecarSize*4) // size of each sidecar
 	})
 }
 

beacon-chain/rpc/eth/builder/BUILD.bazel

@@ -20,7 +20,6 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )
@@ -44,6 +43,5 @@ go_test(
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
     ],
 )

beacon-chain/rpc/eth/builder/handlers.go

@@ -6,7 +6,6 @@ import (
 	"strconv"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
@@ -21,7 +20,7 @@ import (
 // ExpectedWithdrawals get the withdrawals computed from the specified state, that will be included in the block that gets built on the specified state.
 func (s *Server) ExpectedWithdrawals(w http.ResponseWriter, r *http.Request) {
 	// Retrieve beacon state
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.WriteError(w, &httputil.DefaultJsonError{
 			Message: "state_id is required in URL params",

beacon-chain/rpc/eth/builder/handlers_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/testutil"
@@ -91,7 +90,7 @@ func TestExpectedWithdrawals_BadRequest(t *testing.T) {
 				Stater:                &testutil.MockStater{BeaconState: testCase.state},
 			}
 			request := httptest.NewRequest("GET", testCase.path, nil)
-			request = mux.SetURLVars(request, testCase.urlParams)
+			request.SetPathValue("state_id", testCase.urlParams["state_id"])
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
 
@@ -172,7 +171,7 @@ func TestExpectedWithdrawals(t *testing.T) {
 		request := httptest.NewRequest(
 			"GET", "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot="+
 				strconv.FormatUint(uint64(currentSlot+params.BeaconConfig().SlotsPerEpoch), 10), nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 

beacon-chain/rpc/eth/config/BUILD.bazel

@@ -8,10 +8,10 @@ go_library(
     deps = [
         "//api/server/structs:go_default_library",
         "//config/params:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//network/forks:go_default_library",
         "//network/httputil:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/rpc/eth/config/handlers.go

@@ -10,9 +10,9 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/forks"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
-	"go.opencensus.io/trace"
 )
 
 // GetDepositContract retrieves deposit contract address and genesis fork version.

beacon-chain/rpc/eth/config/handlers_test.go

@@ -175,10 +175,6 @@ func TestGetSpec(t *testing.T) {
 	var dam [4]byte
 	copy(dam[:], []byte{'1', '0', '0', '0'})
 	config.DomainApplicationMask = dam
-	var dc [4]byte
-	copy(dc[:], []byte{'1', '1', '0', '0'})
-	config.DomainConsolidation = dc
-
 	params.OverrideBeaconConfig(config)
 
 	request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/config/spec", nil)
@@ -192,7 +188,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 155, len(data))
+	assert.Equal(t, 154, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -515,8 +511,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "86", v)
 			case "MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD":
 				assert.Equal(t, "87", v)
-			case "DOMAIN_CONSOLIDATION":
-				assert.Equal(t, "0x31313030", v)
 			case "MAX_ATTESTER_SLASHINGS_ELECTRA":
 				assert.Equal(t, "88", v)
 			case "MAX_ATTESTATIONS_ELECTRA":

beacon-chain/rpc/eth/debug/BUILD.bazel

@@ -16,11 +16,10 @@ go_library(
         "//beacon-chain/rpc/eth/helpers:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 
@@ -42,6 +41,5 @@ go_test(
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
     ],
 )

beacon-chain/rpc/eth/debug/handlers.go

@@ -7,14 +7,13 @@ import (
 	"net/http"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"go.opencensus.io/trace"
 )
 
 const errMsgStateFromConsensus = "Could not convert consensus state to response"
@@ -24,7 +23,7 @@ func (s *Server) GetBeaconStateV2(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "debug.GetBeaconStateV2")
 	defer span.End()
 
-	stateId := mux.Vars(r)["state_id"]
+	stateId := r.PathValue("state_id")
 	if stateId == "" {
 		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
 		return

beacon-chain/rpc/eth/debug/handlers_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	blockchainmock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
@@ -43,7 +42,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -71,7 +70,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -99,7 +98,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -127,7 +126,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -155,7 +154,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -191,7 +190,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -230,7 +229,7 @@ func TestGetBeaconStateV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
@@ -255,7 +254,7 @@ func TestGetBeaconStateSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -279,7 +278,7 @@ func TestGetBeaconStateSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -303,7 +302,7 @@ func TestGetBeaconStateSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -327,7 +326,7 @@ func TestGetBeaconStateSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -351,7 +350,7 @@ func TestGetBeaconStateSSZV2(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
+		request.SetPathValue("state_id", "head")
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}

beacon-chain/rpc/eth/events/events.go

@@ -301,45 +301,15 @@ func (s *Server) handleStateEvents(ctx context.Context, w http.ResponseWriter, f
 		if !ok {
 			return write(w, flusher, topicDataMismatch, event.Data, LightClientFinalityUpdateTopic)
 		}
-
-		var finalityBranch []string
-		for _, b := range updateData.Data.FinalityBranch {
-			finalityBranch = append(finalityBranch, hexutil.Encode(b))
-		}
-
-		attestedBeacon, err := updateData.Data.AttestedHeader.GetBeacon()
+		update, err := structs.LightClientFinalityUpdateFromConsensus(updateData.Data)
 		if err != nil {
-			return errors.Wrap(err, "could not get attested header")
+			return err
 		}
-		finalizedBeacon, err := updateData.Data.FinalizedHeader.GetBeacon()
-		if err != nil {
-			return errors.Wrap(err, "could not get finalized header")
-		}
-		update := &structs.LightClientFinalityUpdateEvent{
+		updateEvent := &structs.LightClientFinalityUpdateEvent{
 			Version: version.String(int(updateData.Version)),
-			Data: &structs.LightClientFinalityUpdate{
-				AttestedHeader: &structs.BeaconBlockHeader{
-					Slot:          fmt.Sprintf("%d", attestedBeacon.Slot),
-					ProposerIndex: fmt.Sprintf("%d", attestedBeacon.ProposerIndex),
-					ParentRoot:    hexutil.Encode(attestedBeacon.ParentRoot),
-					StateRoot:     hexutil.Encode(attestedBeacon.StateRoot),
-					BodyRoot:      hexutil.Encode(attestedBeacon.BodyRoot),
-				},
-				FinalizedHeader: &structs.BeaconBlockHeader{
-					Slot:          fmt.Sprintf("%d", finalizedBeacon.Slot),
-					ProposerIndex: fmt.Sprintf("%d", finalizedBeacon.ProposerIndex),
-					ParentRoot:    hexutil.Encode(finalizedBeacon.ParentRoot),
-					StateRoot:     hexutil.Encode(finalizedBeacon.StateRoot),
-				},
-				FinalityBranch: finalityBranch,
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeSignature),
-				},
-				SignatureSlot: fmt.Sprintf("%d", updateData.Data.SignatureSlot),
-			},
+			Data:    update,
 		}
-		return send(w, flusher, LightClientFinalityUpdateTopic, update)
+		return send(w, flusher, LightClientFinalityUpdateTopic, updateEvent)
 	case statefeed.LightClientOptimisticUpdate:
 		if _, ok := requestedTopics[LightClientOptimisticUpdateTopic]; !ok {
 			return nil
@@ -348,28 +318,15 @@ func (s *Server) handleStateEvents(ctx context.Context, w http.ResponseWriter, f
 		if !ok {
 			return write(w, flusher, topicDataMismatch, event.Data, LightClientOptimisticUpdateTopic)
 		}
-		attestedBeacon, err := updateData.Data.AttestedHeader.GetBeacon()
+		update, err := structs.LightClientOptimisticUpdateFromConsensus(updateData.Data)
 		if err != nil {
-			return errors.Wrap(err, "could not get attested header")
+			return err
 		}
-		update := &structs.LightClientOptimisticUpdateEvent{
+		updateEvent := &structs.LightClientOptimisticUpdateEvent{
 			Version: version.String(int(updateData.Version)),
-			Data: &structs.LightClientOptimisticUpdate{
-				AttestedHeader: &structs.BeaconBlockHeader{
-					Slot:          fmt.Sprintf("%d", attestedBeacon.Slot),
-					ProposerIndex: fmt.Sprintf("%d", attestedBeacon.ProposerIndex),
-					ParentRoot:    hexutil.Encode(attestedBeacon.ParentRoot),
-					StateRoot:     hexutil.Encode(attestedBeacon.StateRoot),
-					BodyRoot:      hexutil.Encode(attestedBeacon.BodyRoot),
-				},
-				SyncAggregate: &structs.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeSignature),
-				},
-				SignatureSlot: fmt.Sprintf("%d", updateData.Data.SignatureSlot),
-			},
+			Data:    update,
 		}
-		return send(w, flusher, LightClientOptimisticUpdateTopic, update)
+		return send(w, flusher, LightClientOptimisticUpdateTopic, updateEvent)
 	case statefeed.Reorg:
 		if _, ok := requestedTopics[ChainReorgTopic]; !ok {
 			return nil

beacon-chain/rpc/eth/light-client/BUILD.bazel

@@ -25,17 +25,14 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
+        "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
-        "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
-        "//proto/migration:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_wealdtech_go_bytesutil//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 
@@ -66,6 +63,5 @@ go_test(
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
     ],
 )

beacon-chain/rpc/eth/light-client/handlers.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
@@ -16,10 +15,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/wealdtech/go-bytesutil"
-	"go.opencensus.io/trace"
 )
 
 // GetLightClientBootstrap - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/bootstrap.yaml
@@ -29,7 +28,7 @@ func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Reques
 	defer span.End()
 
 	// Get the block
-	blockRootParam, err := hexutil.Decode(mux.Vars(req)["block_root"])
+	blockRootParam, err := hexutil.Decode(req.PathValue("block_root"))
 	if err != nil {
 		httputil.HandleError(w, "invalid block root: "+err.Error(), http.StatusBadRequest)
 		return
@@ -119,7 +118,7 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 	}
 
 	// Populate updates
-	var updates []*structs.LightClientUpdateWithVersion
+	var updates []*structs.LightClientUpdateResponse
 	for period := startPeriod; period <= endPeriod; period++ {
 		// Get the last known state of the period,
 		//    1. We wish the block has a parent in the same period if possible
@@ -200,7 +199,7 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 			}
 		}
 
-		update, err := createLightClientUpdate(
+		update, err := newLightClientUpdateFromBeaconState(
 			ctx,
 			state,
 			block,
@@ -209,7 +208,7 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 		)
 
 		if err == nil {
-			updates = append(updates, &structs.LightClientUpdateWithVersion{
+			updates = append(updates, &structs.LightClientUpdateResponse{
 				Version: version.String(attestedState.Version()),
 				Data:    update,
 			})
@@ -226,7 +225,6 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 
 // GetLightClientFinalityUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/finality_update.yaml
 func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.Request) {
-	// Prepare
 	ctx, span := trace.StartSpan(req.Context(), "beacon.GetLightClientFinalityUpdate")
 	defer span.End()
 
@@ -234,56 +232,48 @@ func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.R
 	minSyncCommitteeParticipants := float64(params.BeaconConfig().MinSyncCommitteeParticipants)
 	minSignatures := uint64(math.Ceil(minSyncCommitteeParticipants * 2 / 3))
 
-	block, err := s.getLightClientEventBlock(ctx, minSignatures)
+	block, err := s.suitableBlock(ctx, minSignatures)
 	if !shared.WriteBlockFetchError(w, block, err) {
 		return
 	}
 
-	state, err := s.Stater.StateBySlot(ctx, block.Block().Slot())
+	st, err := s.Stater.StateBySlot(ctx, block.Block().Slot())
 	if err != nil {
-		httputil.HandleError(w, "could not get state: "+err.Error(), http.StatusInternalServerError)
+		httputil.HandleError(w, "Could not get state: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	// Get attested state
 	attestedRoot := block.Block().ParentRoot()
 	attestedBlock, err := s.Blocker.Block(ctx, attestedRoot[:])
-	if err != nil || attestedBlock == nil {
-		httputil.HandleError(w, "could not get attested block: "+err.Error(), http.StatusInternalServerError)
+	if !shared.WriteBlockFetchError(w, block, errors.Wrap(err, "could not get attested block")) {
 		return
 	}
-
 	attestedSlot := attestedBlock.Block().Slot()
 	attestedState, err := s.Stater.StateBySlot(ctx, attestedSlot)
 	if err != nil {
-		httputil.HandleError(w, "could not get attested state: "+err.Error(), http.StatusInternalServerError)
+		httputil.HandleError(w, "Could not get attested state: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	// Get finalized block
 	var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
-	finalizedCheckPoint := attestedState.FinalizedCheckpoint()
-	if finalizedCheckPoint != nil {
-		finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root)
-		finalizedBlock, err = s.Blocker.Block(ctx, finalizedRoot[:])
-		if err != nil {
-			finalizedBlock = nil
-		}
+	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
+	if finalizedCheckpoint == nil {
+		httputil.HandleError(w, "Attested state does not have a finalized checkpoint", http.StatusInternalServerError)
+		return
 	}
-
-	update, err := newLightClientFinalityUpdateFromBeaconState(
-		ctx,
-		state,
-		block,
-		attestedState,
-		finalizedBlock,
-	)
-	if err != nil {
-		httputil.HandleError(w, "could not get light client finality update: "+err.Error(), http.StatusInternalServerError)
+	finalizedRoot := bytesutil.ToBytes32(finalizedCheckpoint.Root)
+	finalizedBlock, err = s.Blocker.Block(ctx, finalizedRoot[:])
+	if !shared.WriteBlockFetchError(w, block, errors.Wrap(err, "could not get finalized block")) {
 		return
 	}
 
-	response := &structs.LightClientUpdateWithVersion{
+	update, err := newLightClientFinalityUpdateFromBeaconState(ctx, st, block, attestedState, finalizedBlock)
+	if err != nil {
+		httputil.HandleError(w, "Could not get light client finality update: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := &structs.LightClientFinalityUpdateResponse{
 		Version: version.String(attestedState.Version()),
 		Data:    update,
 	}
@@ -293,54 +283,42 @@ func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.R
 
 // GetLightClientOptimisticUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/optimistic_update.yaml
 func (s *Server) GetLightClientOptimisticUpdate(w http.ResponseWriter, req *http.Request) {
-	// Prepare
 	ctx, span := trace.StartSpan(req.Context(), "beacon.GetLightClientOptimisticUpdate")
 	defer span.End()
 
-	minSignatures := params.BeaconConfig().MinSyncCommitteeParticipants
-
-	block, err := s.getLightClientEventBlock(ctx, minSignatures)
+	block, err := s.suitableBlock(ctx, params.BeaconConfig().MinSyncCommitteeParticipants)
 	if !shared.WriteBlockFetchError(w, block, err) {
 		return
 	}
-
-	state, err := s.Stater.StateBySlot(ctx, block.Block().Slot())
+	st, err := s.Stater.StateBySlot(ctx, block.Block().Slot())
 	if err != nil {
 		httputil.HandleError(w, "could not get state: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-
-	// Get attested state
 	attestedRoot := block.Block().ParentRoot()
 	attestedBlock, err := s.Blocker.Block(ctx, attestedRoot[:])
 	if err != nil {
-		httputil.HandleError(w, "could not get attested block: "+err.Error(), http.StatusInternalServerError)
+		httputil.HandleError(w, "Could not get attested block: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 	if attestedBlock == nil {
-		httputil.HandleError(w, "attested block is nil", http.StatusInternalServerError)
+		httputil.HandleError(w, "Attested block is nil", http.StatusInternalServerError)
 		return
 	}
-
 	attestedSlot := attestedBlock.Block().Slot()
 	attestedState, err := s.Stater.StateBySlot(ctx, attestedSlot)
 	if err != nil {
-		httputil.HandleError(w, "could not get attested state: "+err.Error(), http.StatusInternalServerError)
+		httputil.HandleError(w, "Could not get attested state: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	update, err := newLightClientOptimisticUpdateFromBeaconState(
-		ctx,
-		state,
-		block,
-		attestedState,
-	)
+	update, err := newLightClientOptimisticUpdateFromBeaconState(ctx, st, block, attestedState)
 	if err != nil {
-		httputil.HandleError(w, "could not get light client optimistic update: "+err.Error(), http.StatusInternalServerError)
+		httputil.HandleError(w, "Could not get light client optimistic update: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	response := &structs.LightClientUpdateWithVersion{
+	response := &structs.LightClientOptimisticUpdateResponse{
 		Version: version.String(attestedState.Version()),
 		Data:    update,
 	}
@@ -348,17 +326,15 @@ func (s *Server) GetLightClientOptimisticUpdate(w http.ResponseWriter, req *http
 	httputil.WriteJson(w, response)
 }
 
-// getLightClientEventBlock - returns the block that should be used for light client events, which satisfies the minimum number of signatures from sync committee
-func (s *Server) getLightClientEventBlock(ctx context.Context, minSignaturesRequired uint64) (interfaces.ReadOnlySignedBeaconBlock, error) {
-	// Get the current state
-	state, err := s.HeadFetcher.HeadState(ctx)
+// suitableBlock returns the latest block that satisfies all criteria required for creating a new update
+func (s *Server) suitableBlock(ctx context.Context, minSignaturesRequired uint64) (interfaces.ReadOnlySignedBeaconBlock, error) {
+	st, err := s.HeadFetcher.HeadState(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get head state")
 	}
 
-	// Get the block
-	latestBlockHeader := *state.LatestBlockHeader()
-	stateRoot, err := state.HashTreeRoot(ctx)
+	latestBlockHeader := st.LatestBlockHeader()
+	stateRoot, err := st.HashTreeRoot(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get state root")
 	}
@@ -378,7 +354,7 @@ func (s *Server) getLightClientEventBlock(ctx context.Context, minSignaturesRequ
 
 	// Loop through the blocks until we find a block that satisfies minSignaturesRequired requirement
 	var numOfSyncCommitteeSignatures uint64
-	if syncAggregate, err := block.Block().Body().SyncAggregate(); err == nil && syncAggregate != nil {
+	if syncAggregate, err := block.Block().Body().SyncAggregate(); err == nil {
 		numOfSyncCommitteeSignatures = syncAggregate.SyncCommitteeBits.Count()
 	}
 
@@ -395,7 +371,7 @@ func (s *Server) getLightClientEventBlock(ctx context.Context, minSignaturesRequ
 
 		// Get the number of sync committee signatures
 		numOfSyncCommitteeSignatures = 0
-		if syncAggregate, err := block.Block().Body().SyncAggregate(); err == nil && syncAggregate != nil {
+		if syncAggregate, err := block.Block().Body().SyncAggregate(); err == nil {
 			numOfSyncCommitteeSignatures = syncAggregate.SyncCommitteeBits.Count()
 		}
 	}

beacon-chain/rpc/eth/light-client/handlers_test.go

@@ -10,7 +10,6 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
@@ -61,10 +60,8 @@ func TestLightClientHandler_GetLightClientBootstrap_Altair(t *testing.T) {
 		Blocker:     mockBlocker,
 		HeadFetcher: mockChainService,
 	}
-	muxVars := make(map[string]string)
-	muxVars["block_root"] = hexutil.Encode(r[:])
 	request := httptest.NewRequest("GET", "http://foo.com/", nil)
-	request = mux.SetURLVars(request, muxVars)
+	request.SetPathValue("block_root", hexutil.Encode(r[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -116,10 +113,8 @@ func TestLightClientHandler_GetLightClientBootstrap_Capella(t *testing.T) {
 		Blocker:     mockBlocker,
 		HeadFetcher: mockChainService,
 	}
-	muxVars := make(map[string]string)
-	muxVars["block_root"] = hexutil.Encode(r[:])
 	request := httptest.NewRequest("GET", "http://foo.com/", nil)
-	request = mux.SetURLVars(request, muxVars)
+	request.SetPathValue("block_root", hexutil.Encode(r[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -171,10 +166,8 @@ func TestLightClientHandler_GetLightClientBootstrap_Deneb(t *testing.T) {
 		Blocker:     mockBlocker,
 		HeadFetcher: mockChainService,
 	}
-	muxVars := make(map[string]string)
-	muxVars["block_root"] = hexutil.Encode(r[:])
 	request := httptest.NewRequest("GET", "http://foo.com/", nil)
-	request = mux.SetURLVars(request, muxVars)
+	request.SetPathValue("block_root", hexutil.Encode(r[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -1242,7 +1235,7 @@ func TestLightClientHandler_GetLightClientFinalityUpdateAltair(t *testing.T) {
 	s.GetLightClientFinalityUpdate(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp structs.LightClientUpdateWithVersion
+	var resp *structs.LightClientUpdateResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	var respHeader structs.LightClientHeader
@@ -1352,7 +1345,7 @@ func TestLightClientHandler_GetLightClientFinalityUpdateCapella(t *testing.T) {
 	s.GetLightClientFinalityUpdate(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp structs.LightClientUpdateWithVersion
+	var resp *structs.LightClientUpdateResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	var respHeader structs.LightClientHeader
@@ -1462,7 +1455,7 @@ func TestLightClientHandler_GetLightClientFinalityUpdateDeneb(t *testing.T) {
 	s.GetLightClientFinalityUpdate(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp structs.LightClientUpdateWithVersion
+	var resp *structs.LightClientUpdateResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	var respHeader structs.LightClientHeaderDeneb
@@ -1572,7 +1565,7 @@ func TestLightClientHandler_GetLightClientOptimisticUpdateAltair(t *testing.T) {
 	s.GetLightClientOptimisticUpdate(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp structs.LightClientUpdateWithVersion
+	var resp *structs.LightClientUpdateResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	var respHeader structs.LightClientHeader
@@ -1682,7 +1675,7 @@ func TestLightClientHandler_GetLightClientOptimisticUpdateCapella(t *testing.T)
 	s.GetLightClientOptimisticUpdate(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp structs.LightClientUpdateWithVersion
+	var resp *structs.LightClientUpdateResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	var respHeader structs.LightClientHeaderCapella
@@ -1792,7 +1785,7 @@ func TestLightClientHandler_GetLightClientOptimisticUpdateDeneb(t *testing.T) {
 	s.GetLightClientOptimisticUpdate(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp structs.LightClientUpdateWithVersion
+	var resp *structs.LightClientUpdateResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	var respHeader structs.LightClientHeaderDeneb
@@ -1897,7 +1890,7 @@ func TestLightClientHandler_GetLightClientEventBlock(t *testing.T) {
 	}
 
 	minSignaturesRequired := uint64(100)
-	eventBlock, err := s.getLightClientEventBlock(ctx, minSignaturesRequired)
+	eventBlock, err := s.suitableBlock(ctx, minSignaturesRequired)
 
 	require.NoError(t, err)
 	require.NotNil(t, eventBlock)
@@ -2004,7 +1997,7 @@ func TestLightClientHandler_GetLightClientEventBlock_NeedFetchParent(t *testing.
 	}
 
 	minSignaturesRequired := uint64(100)
-	eventBlock, err := s.getLightClientEventBlock(ctx, minSignaturesRequired)
+	eventBlock, err := s.suitableBlock(ctx, minSignaturesRequired)
 
 	require.NoError(t, err)
 	require.NotNil(t, eventBlock)

beacon-chain/rpc/eth/light-client/helpers.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
-	"strconv"
 
 	"github.com/pkg/errors"
 
@@ -21,9 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	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"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -349,128 +346,19 @@ func createLightClientBootstrapDeneb(ctx context.Context, state state.BeaconStat
 	return result, nil
 }
 
-// createLightClientUpdate - implements https://github.
-// com/ethereum/consensus-specs/blob/d70dcd9926a4bbe987f1b4e65c3e05bd029fcfb8/specs/altair/light-client/full-node.md#create_light_client_update
-// def create_light_client_update(state: BeaconState,
-//
-//	                           block: SignedBeaconBlock,
-//	                           attested_state: BeaconState,
-//	                           finalized_block: Optional[SignedBeaconBlock]) -> LightClientUpdate:
-//	assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH
-//	assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS
-//
-//	assert state.slot == state.latest_block_header.slot
-//	header = state.latest_block_header.copy()
-//	header.state_root = hash_tree_root(state)
-//	assert hash_tree_root(header) == hash_tree_root(block.message)
-//	update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot))
-//
-//	assert attested_state.slot == attested_state.latest_block_header.slot
-//	attested_header = attested_state.latest_block_header.copy()
-//	attested_header.state_root = hash_tree_root(attested_state)
-//	assert hash_tree_root(attested_header) == block.message.parent_root
-//	update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
-//
-//	# `next_sync_committee` is only useful if the message is signed by the current sync committee
-//	if update_attested_period == update_signature_period:
-//	    next_sync_committee = attested_state.next_sync_committee
-//	    next_sync_committee_branch = compute_merkle_proof_for_state(attested_state, NEXT_SYNC_COMMITTEE_INDEX)
-//	else:
-//	    next_sync_committee = SyncCommittee()
-//	    next_sync_committee_branch = [Bytes32() for _ in range(floorlog2(NEXT_SYNC_COMMITTEE_INDEX))]
-//
-//	# Indicate finality whenever possible
-//	if finalized_block is not None:
-//	    if finalized_block.message.slot != GENESIS_SLOT:
-//	        finalized_header = BeaconBlockHeader(
-//	            slot=finalized_block.message.slot,
-//	            proposer_index=finalized_block.message.proposer_index,
-//	            parent_root=finalized_block.message.parent_root,
-//	            state_root=finalized_block.message.state_root,
-//	            body_root=hash_tree_root(finalized_block.message.body),
-//	        )
-//	        assert hash_tree_root(finalized_header) == attested_state.finalized_checkpoint.root
-//	    else:
-//	        assert attested_state.finalized_checkpoint.root == Bytes32()
-//	        finalized_header = BeaconBlockHeader()
-//	    finality_branch = compute_merkle_proof_for_state(attested_state, FINALIZED_ROOT_INDEX)
-//	else:
-//	    finalized_header = BeaconBlockHeader()
-//	    finality_branch = [Bytes32() for _ in range(floorlog2(FINALIZED_ROOT_INDEX))]
-//
-//	return LightClientUpdate(
-//	    attested_header=attested_header,
-//	    next_sync_committee=next_sync_committee,
-//	    next_sync_committee_branch=next_sync_committee_branch,
-//	    finalized_header=finalized_header,
-//	    finality_branch=finality_branch,
-//	    sync_aggregate=block.message.body.sync_aggregate,
-//	    signature_slot=block.message.slot,
-//	)
-func createLightClientUpdate(
+func newLightClientUpdateFromBeaconState(
 	ctx context.Context,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientUpdate, error) {
-	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
+) (*structs.LightClientUpdate, error) {
+	result, err := lightclient.NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
 
-	// Generate next sync committee and proof
-	var nextSyncCommittee *v2.SyncCommittee
-	var nextSyncCommitteeBranch [][]byte
-
-	// update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot))
-	updateSignaturePeriod := slots.SyncCommitteePeriod(slots.ToEpoch(block.Block().Slot()))
-
-	// update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
-	resultAttestedHeaderBeacon, err := result.AttestedHeader.GetBeacon()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get attested header beacon")
-	}
-	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(resultAttestedHeaderBeacon.Slot))
-
-	if updateAttestedPeriod == updateSignaturePeriod {
-		tempNextSyncCommittee, err := attestedState.NextSyncCommittee()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get next sync committee")
-		}
-
-		nextSyncCommittee = &v2.SyncCommittee{
-			Pubkeys:         tempNextSyncCommittee.Pubkeys,
-			AggregatePubkey: tempNextSyncCommittee.AggregatePubkey,
-		}
-
-		nextSyncCommitteeBranch, err = attestedState.NextSyncCommitteeProof(ctx)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get next sync committee proof")
-		}
-	} else {
-		syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
-		pubKeys := make([][]byte, syncCommitteeSize)
-		for i := uint64(0); i < syncCommitteeSize; i++ {
-			pubKeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
-		}
-		nextSyncCommittee = &v2.SyncCommittee{
-			Pubkeys:         pubKeys,
-			AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
-		}
-
-		nextSyncCommitteeBranch = make([][]byte, fieldparams.NextSyncCommitteeBranchDepth)
-		for i := 0; i < fieldparams.NextSyncCommitteeBranchDepth; i++ {
-			nextSyncCommitteeBranch[i] = make([]byte, fieldparams.RootLength)
-		}
-	}
-
-	result.NextSyncCommittee = nextSyncCommittee
-	result.NextSyncCommitteeBranch = nextSyncCommitteeBranch
-	res, err := newLightClientUpdateToJSON(result)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert light client update to JSON")
-	}
-	return res, nil
+	return structs.LightClientUpdateFromConsensus(result)
 }
 
 func newLightClientFinalityUpdateFromBeaconState(
@@ -478,99 +366,28 @@ func newLightClientFinalityUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientUpdate, error) {
+	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
+) (*structs.LightClientFinalityUpdate, error) {
 	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
 
-	res, err := newLightClientUpdateToJSON(result)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert light client update to JSON")
-	}
-	return res, nil
+	return structs.LightClientFinalityUpdateFromConsensus(result)
 }
 
 func newLightClientOptimisticUpdateFromBeaconState(
 	ctx context.Context,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState) (*structs.LightClientUpdate, error) {
+	attestedState state.BeaconState,
+) (*structs.LightClientOptimisticUpdate, error) {
 	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState)
 	if err != nil {
 		return nil, err
 	}
 
-	res, err := newLightClientUpdateToJSON(result)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert light client update to JSON")
-	}
-	return res, 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) *structs.SyncAggregate {
-	if input == nil {
-		return nil
-	}
-	return &structs.SyncAggregate{
-		SyncCommitteeBits:      hexutil.Encode(input.SyncCommitteeBits),
-		SyncCommitteeSignature: hexutil.Encode(input.SyncCommitteeSignature),
-	}
-}
-
-func newLightClientUpdateToJSON(input *v2.LightClientUpdate) (*structs.LightClientUpdate, error) {
-	if input == nil {
-		return nil, errors.New("input is nil")
-	}
-
-	var nextSyncCommittee *structs.SyncCommittee
-	if input.NextSyncCommittee != nil {
-		nextSyncCommittee = structs.SyncCommitteeFromConsensus(migration.V2SyncCommitteeToV1Alpha1(input.NextSyncCommittee))
-	}
-
-	var finalizedHeader *structs.BeaconBlockHeader
-	if input.FinalizedHeader != nil {
-		inputFinalizedHeaderBeacon, err := input.FinalizedHeader.GetBeacon()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get finalized header beacon")
-		}
-		finalizedHeader = structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(inputFinalizedHeaderBeacon))
-	}
-
-	inputAttestedHeaderBeacon, err := input.AttestedHeader.GetBeacon()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get attested header beacon")
-	}
-	attestedHeaderJson, err := json.Marshal(&structs.LightClientHeader{Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(inputAttestedHeaderBeacon))})
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert attested header to raw message")
-	}
-	finalizedHeaderJson, err := json.Marshal(&structs.LightClientHeader{Beacon: finalizedHeader})
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert finalized header to raw message")
-	}
-	result := &structs.LightClientUpdate{
-		AttestedHeader:          attestedHeaderJson,
-		NextSyncCommittee:       nextSyncCommittee,
-		NextSyncCommitteeBranch: branchToJSON(input.NextSyncCommitteeBranch),
-		FinalizedHeader:         finalizedHeaderJson,
-		FinalityBranch:          branchToJSON(input.FinalityBranch),
-		SyncAggregate:           syncAggregateToJSON(input.SyncAggregate),
-		SignatureSlot:           strconv.FormatUint(uint64(input.SignatureSlot), 10),
-	}
-
-	return result, nil
+	return structs.LightClientOptimisticUpdateFromConsensus(result)
 }
 
 func IsSyncCommitteeUpdate(update *v2.LightClientUpdate) bool {