rm deprecated blob type and db methods

.bazelversion

@@ -1 +1 @@
-7.0.0
+6.4.0

.buildkite-bazelrc

@@ -10,7 +10,7 @@
 
 # Prysm specific remote-cache properties.
 build:remote-cache --remote_download_minimal
-build:remote-cache --remote_build_event_upload=minimal
+build:remote-cache --experimental_remote_build_event_upload=minimal
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
 # Does not work with rules_oci. See https://github.com/bazel-contrib/rules_oci/issues/292
 #build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092

BUILD.bazel

@@ -194,6 +194,33 @@ nogo(
     config = ":nogo_config_with_excludes",
     visibility = ["//visibility:public"],
     deps = [
+        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/unreachable:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/tests:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/structtag:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/shift:go_default_library",
+        # "@org_golang_x_tools//go/analysis/passes/shadow:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/printf:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/nilness:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/loopclosure:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/httpresponse:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/copylock:go_default_library",
+        #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/buildtag:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/buildssa:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/bools:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/atomic:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/assign:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_default_library",
         "//tools/analyzers/comparesame:go_default_library",
         "//tools/analyzers/cryptorand:go_default_library",
         "//tools/analyzers/errcheck:go_default_library",
@@ -209,53 +236,6 @@ nogo(
         "//tools/analyzers/shadowpredecl:go_default_library",
         "//tools/analyzers/slicedirect:go_default_library",
         "//tools/analyzers/uintcast:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/appends:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/assign:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/atomic:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/bools:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/buildssa:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/buildtag:go_default_library",
-        # cgocall disabled
-        #"@org_golang_x_tools//go/analysis/passes/cgocall:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/copylock:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/defers:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/directive:go_default_library",
-        # fieldalignment disabled
-        #"@org_golang_x_tools//go/analysis/passes/fieldalignment:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/framepointer:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/httpmux:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/httpresponse:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/ifaceassert:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/loopclosure:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/nilness:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/printf:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/reflectvaluecompare:go_default_library",
-        # shadow disabled
-        #"@org_golang_x_tools//go/analysis/passes/shadow:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/shift:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/sigchanyzer:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/slog:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/sortslice:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/stringintconv:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/structtag:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/testinggoroutine:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/tests:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/timeformat:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unreachable:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unusedresult:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unusedwrite:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/usesgenerics:go_default_library",
     ] + select({
         # nogo checks that fail with coverage enabled.
         ":coverage_enabled": [],

MODULE.bazel

@@ -1,6 +0,0 @@
-###############################################################################
-# Bazel now uses Bzlmod by default to manage external dependencies.
-# Please consider migrating your external dependencies from WORKSPACE to MODULE.bazel.
-#
-# For more details, please check https://github.com/bazelbuild/bazel/issues/18958
-###############################################################################

WORKSPACE

@@ -182,7 +182,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.21.6",
+    go_version = "1.21.5",
     nogo = "@//:nogo",
 )
 
@@ -349,17 +349,17 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "5f4be6fd088683ea9db45c863b9c5a1884422449e5b59fd2d561d3ba0f73ffd9",
-    strip_prefix = "holesky-9d9aabf2d4de51334ee5fed6c79a4d55097d1a43",
-    url = "https://github.com/eth-clients/holesky/archive/9d9aabf2d4de51334ee5fed6c79a4d55097d1a43.tar.gz",  # 2024-01-22
+    sha256 = "9f66d8d5644982d3d0d2e3d2b9ebe77a5f96638a5d7fcd715599c32818195cb3",
+    strip_prefix = "holesky-ea39b9006210848e13f28d92e12a30548cecd41d",
+    url = "https://github.com/eth-clients/holesky/archive/ea39b9006210848e13f28d92e12a30548cecd41d.tar.gz",  # 2023-09-21
 )
 
 http_archive(
     name = "com_google_protobuf",
-    sha256 = "9bd87b8280ef720d3240514f884e56a712f2218f0d693b48050c836028940a42",
-    strip_prefix = "protobuf-25.1",
+    sha256 = "4e176116949be52b0408dfd24f8925d1eb674a781ae242a75296b17a1c721395",
+    strip_prefix = "protobuf-23.3",
     urls = [
-        "https://github.com/protocolbuffers/protobuf/archive/v25.1.tar.gz",
+        "https://github.com/protocolbuffers/protobuf/archive/v23.3.tar.gz",
     ],
 )
 

api/headers.go

@@ -7,6 +7,4 @@ const (
 	ConsensusBlockValueHeader     = "Eth-Consensus-Block-Value"
 	JsonMediaType                 = "application/json"
 	OctetStreamMediaType          = "application/octet-stream"
-	EventStreamMediaType          = "text/event-stream"
-	KeepAlive                     = "keep-alive"
 )

beacon-chain/blockchain/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "chain_info.go",
         "chain_info_forkchoice.go",
         "currently_syncing_block.go",
-        "defragment.go",
         "error.go",
         "execution_engine.go",
         "forkchoice_update_execution.go",

beacon-chain/blockchain/chain_info.go

@@ -6,10 +6,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
-	f "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
@@ -21,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -336,21 +334,12 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index primiti
 	return v.PublicKey(), nil
 }
 
-// ForkChoicer returns the forkchoice interface.
-func (s *Service) ForkChoicer() f.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}
-
 // IsOptimistic returns true if the current head is optimistic.
 func (s *Service) IsOptimistic(_ context.Context) (bool, error) {
 	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
 		return false, nil
 	}
 	s.headLock.RLock()
-	if s.head == nil {
-		s.headLock.RUnlock()
-		return false, ErrNilHead
-	}
 	headRoot := s.head.root
 	headSlot := s.head.slot
 	headOptimistic := s.head.optimistic
@@ -556,18 +545,3 @@ func (s *Service) RecentBlockSlot(root [32]byte) (primitives.Slot, error) {
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	return s.cfg.ForkChoiceStore.Slot(root)
 }
-
-// inRegularSync applies the following heuristics to decide if the node is in
-// regular sync mode vs init sync mode using only forkchoice.
-// It checks that the highest received block is behind the current time by at least 2 epochs
-// and that it was imported at least one epoch late if both of these
-// tests pass then the node is in init sync. The caller of this function MUST
-// have a lock on forkchoice
-func (s *Service) inRegularSync() bool {
-	currentSlot := s.CurrentSlot()
-	fc := s.cfg.ForkChoiceStore
-	if currentSlot-fc.HighestReceivedBlockSlot() < 2*params.BeaconConfig().SlotsPerEpoch {
-		return true
-	}
-	return fc.HighestReceivedBlockDelay() < params.BeaconConfig().SlotsPerEpoch
-}

beacon-chain/blockchain/chain_info_test.go

@@ -429,11 +429,6 @@ func TestService_IsOptimistic(t *testing.T) {
 	opt, err = c.IsOptimistic(ctx)
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
-
-	// If head is nil, for some reason, an error should be returned rather than panic.
-	c = &Service{}
-	_, err = c.IsOptimistic(ctx)
-	require.ErrorIs(t, err, ErrNilHead)
 }
 
 func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
@@ -593,26 +588,3 @@ func TestService_IsFinalized(t *testing.T) {
 	require.Equal(t, true, c.IsFinalized(ctx, br))
 	require.Equal(t, false, c.IsFinalized(ctx, [32]byte{'c'}))
 }
-
-func TestService_inRegularSync(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	require.Equal(t, false, c.inRegularSync())
-	c.SetGenesisTime(time.Now().Add(time.Second * time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot))))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 128, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	require.Equal(t, false, c.inRegularSync())
-
-	c.SetGenesisTime(time.Now().Add(time.Second * time.Duration(-5*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot))))
-	require.Equal(t, true, c.inRegularSync())
-
-	c.SetGenesisTime(time.Now().Add(time.Second * time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot))))
-	c.cfg.ForkChoiceStore.SetGenesisTime(uint64(time.Now().Unix()))
-	require.Equal(t, true, c.inRegularSync())
-}

beacon-chain/blockchain/defragment.go

@@ -1,27 +0,0 @@
-package blockchain
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v4/config/features"
-	"github.com/prysmaticlabs/prysm/v4/time"
-)
-
-var stateDefragmentationTime = promauto.NewSummary(prometheus.SummaryOpts{
-	Name: "head_state_defragmentation_milliseconds",
-	Help: "Milliseconds it takes to defragment the head state",
-})
-
-// This method defragments our state, so that any specific fields which have
-// a higher number of fragmented indexes are reallocated to a new separate slice for
-// that field.
-func (s *Service) defragmentState(st state.BeaconState) {
-	if !features.Get().EnableExperimentalState {
-		return
-	}
-	startTime := time.Now()
-	st.Defragment()
-	elapsedTime := time.Since(startTime)
-	stateDefragmentationTime.Observe(float64(elapsedTime.Milliseconds()))
-}

beacon-chain/blockchain/error.go

@@ -28,8 +28,6 @@ var (
 	// ErrNotCheckpoint is returned when a given checkpoint is not a
 	// checkpoint in any chain known to forkchoice
 	ErrNotCheckpoint = errors.New("not a checkpoint in forkchoice")
-	// ErrNilHead is returned when no head is present in the blockchain service.
-	ErrNilHead = errors.New("nil head")
 )
 
 var errMaxBlobsExceeded = errors.New("Expected commitments in block exceeds MAX_BLOBS_PER_BLOCK")

beacon-chain/blockchain/execution_engine.go

@@ -387,10 +387,7 @@ func (s *Service) removeInvalidBlockAndState(ctx context.Context, blkRoots [][32
 			// This is an irreparable condition, it would me a justified or finalized block has become invalid.
 			return err
 		}
-		if err := s.blobStorage.Remove(root); err != nil {
-			// Blobs may not exist for some blocks, leading to deletion failures. Log such errors at debug level.
-			log.WithError(err).Debug("Could not remove blob from blob storage")
-		}
+		// TODO: delete blobs from storage
 	}
 	return nil
 }

beacon-chain/blockchain/execution_engine_test.go

@@ -151,10 +151,8 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 							ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 							LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 							PrevRandao:    make([]byte, fieldparams.RootLength),
-							ExtraData:     make([]byte, 0),
 							BaseFeePerGas: make([]byte, fieldparams.RootLength),
 							BlockHash:     make([]byte, fieldparams.RootLength),
-							Transactions:  make([][]byte, 0),
 						},
 					},
 				}})
@@ -496,10 +494,8 @@ func Test_NotifyNewPayload(t *testing.T) {
 					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 					PrevRandao:    make([]byte, fieldparams.RootLength),
-					ExtraData:     make([]byte, 0),
 					BaseFeePerGas: make([]byte, fieldparams.RootLength),
 					BlockHash:     make([]byte, fieldparams.RootLength),
-					Transactions:  make([][]byte, 0),
 				},
 			},
 		},
@@ -601,10 +597,8 @@ func Test_NotifyNewPayload(t *testing.T) {
 								ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 								LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 								PrevRandao:    make([]byte, fieldparams.RootLength),
-								ExtraData:     make([]byte, 0),
 								BaseFeePerGas: make([]byte, fieldparams.RootLength),
 								BlockHash:     make([]byte, fieldparams.RootLength),
-								Transactions:  make([][]byte, 0),
 							},
 						},
 					},

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//consensus-types/blocks:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -24,7 +25,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//consensus-types/blocks:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",

beacon-chain/blockchain/kzg/validation_test.go

@@ -58,9 +58,9 @@ func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZG
 	return commitment, proof, err
 }
 
-func TestVerify(t *testing.T) {
+func TestIsDataAvailable(t *testing.T) {
 	sidecars := make([]blocks.ROBlob, 0)
-	require.NoError(t, Verify(sidecars...))
+	require.NoError(t, Verify(sidecars[0]))
 }
 
 func TestBytesToAny(t *testing.T) {

beacon-chain/blockchain/process_block.go

@@ -6,8 +6,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
@@ -31,6 +29,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // A custom slot deadline for processing state slots in our cache.
@@ -67,10 +66,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	startTime := time.Now()
 	fcuArgs := &fcuConfig{}
 
-	if s.inRegularSync() {
-		defer s.handleSecondFCUCall(cfg, fcuArgs)
-	}
-	defer s.sendLightClientFeeds(cfg)
+	defer s.handleSecondFCUCall(cfg, fcuArgs)
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)
 	defer reportAttestationInclusion(cfg.signed.Block())
@@ -106,7 +102,6 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	if err := s.sendFCU(cfg, fcuArgs); err != nil {
 		return errors.Wrap(err, "could not send FCU to engine")
 	}
-
 	return nil
 }
 
@@ -582,15 +577,10 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if s.CurrentSlot() == s.HeadSlot() {
 		return
 	}
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	// return early if we are in init sync
-	if !s.inRegularSync() {
-		return
-	}
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.MissedSlot,
 	})
+
 	s.headLock.RLock()
 	headRoot := s.headRoot()
 	headState := s.headState(ctx)
@@ -605,22 +595,18 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
 		log.WithError(err).Debug("could not update next slot state cache")
 	}
+	// handleEpochBoundary requires a forkchoice lock to obtain the target root.
+	s.cfg.ForkChoiceStore.RLock()
 	if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
 		log.WithError(err).Error("lateBlockTasks: could not update epoch boundary caches")
 	}
+	s.cfg.ForkChoiceStore.RUnlock()
 	// return early if we already started building a block for the current
 	// head root
 	_, has := s.cfg.PayloadIDCache.PayloadID(s.CurrentSlot()+1, headRoot)
 	if has {
 		return
 	}
-
-	attribute := s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
-	// return early if we are not proposing next slot
-	if attribute.IsEmpty() {
-		return
-	}
-
 	s.headLock.RLock()
 	headBlock, err := s.headBlock()
 	if err != nil {
@@ -631,12 +617,18 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	s.headLock.RUnlock()
 
 	fcuArgs := &fcuConfig{
-		headState:  headState,
-		headRoot:   headRoot,
-		headBlock:  headBlock,
-		attributes: attribute,
+		headState: headState,
+		headRoot:  headRoot,
+		headBlock: headBlock,
 	}
+	fcuArgs.attributes = s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
+	// return early if we are not proposing next slot
+	if fcuArgs.attributes.IsEmpty() {
+		return
+	}
+	s.cfg.ForkChoiceStore.RLock()
 	_, err = s.notifyForkchoiceUpdate(ctx, fcuArgs)
+	s.cfg.ForkChoiceStore.RUnlock()
 	if err != nil {
 		log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")
 	}

beacon-chain/blockchain/process_block_helpers.go

@@ -7,24 +7,21 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v4/config/features"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v4/math"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.
@@ -37,9 +34,6 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 	if err := s.getFCUArgsEarlyBlock(cfg, fcuArgs); err != nil {
 		return err
 	}
-	if !s.inRegularSync() {
-		return nil
-	}
 	slot := cfg.signed.Block().Slot()
 	if slots.WithinVotingWindow(uint64(s.genesisTime.Unix()), slot) {
 		return nil
@@ -112,128 +106,6 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 	})
 }
 
-// sendLightClientFeeds sends the light client feeds when feature flag is enabled.
-func (s *Service) sendLightClientFeeds(cfg *postBlockProcessConfig) {
-	if features.Get().EnableLightClient {
-		if _, err := s.sendLightClientOptimisticUpdate(cfg.ctx, cfg.signed, cfg.postState); err != nil {
-			log.WithError(err).Error("Failed to send light client optimistic update")
-		}
-
-		// Get the finalized checkpoint
-		finalized := s.ForkChoicer().FinalizedCheckpoint()
-
-		// LightClientFinalityUpdate needs super majority
-		s.tryPublishLightClientFinalityUpdate(cfg.ctx, cfg.signed, finalized, cfg.postState)
-	}
-}
-
-func (s *Service) tryPublishLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, finalized *forkchoicetypes.Checkpoint, postState state.BeaconState) {
-	if finalized.Epoch <= s.lastPublishedLightClientEpoch {
-		return
-	}
-
-	config := params.BeaconConfig()
-	if finalized.Epoch < config.AltairForkEpoch {
-		return
-	}
-
-	syncAggregate, err := signed.Block().Body().SyncAggregate()
-	if err != nil || syncAggregate == nil {
-		return
-	}
-
-	// LightClientFinalityUpdate needs super majority
-	if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 {
-		return
-	}
-
-	_, err = s.sendLightClientFinalityUpdate(ctx, signed, postState)
-	if err != nil {
-		log.WithError(err).Error("Failed to send light client finality update")
-	} else {
-		s.lastPublishedLightClientEpoch = finalized.Epoch
-	}
-}
-
-// sendLightClientFinalityUpdate sends a light client finality update notification to the state feed.
-func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState) (int, error) {
-	// Get attested state
-	attestedRoot := signed.Block().ParentRoot()
-	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested state")
-	}
-
-	// Get finalized block
-	var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
-	finalizedCheckPoint := attestedState.FinalizedCheckpoint()
-	if finalizedCheckPoint != nil {
-		finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root)
-		finalizedBlock, err = s.cfg.BeaconDB.Block(ctx, finalizedRoot)
-		if err != nil {
-			finalizedBlock = nil
-		}
-	}
-
-	update, err := NewLightClientFinalityUpdateFromBeaconState(
-		ctx,
-		postState,
-		signed,
-		attestedState,
-		finalizedBlock,
-	)
-
-	if err != nil {
-		return 0, errors.Wrap(err, "could not create light client update")
-	}
-
-	// Return the result
-	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
-		Version: ethpbv2.Version(signed.Version()),
-		Data:    CreateLightClientFinalityUpdate(update),
-	}
-
-	// Send event
-	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.LightClientFinalityUpdate,
-		Data: result,
-	}), nil
-}
-
-// sendLightClientOptimisticUpdate sends a light client optimistic update notification to the state feed.
-func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState) (int, error) {
-	// Get attested state
-	attestedRoot := signed.Block().ParentRoot()
-	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested state")
-	}
-
-	update, err := NewLightClientOptimisticUpdateFromBeaconState(
-		ctx,
-		postState,
-		signed,
-		attestedState,
-	)
-
-	if err != nil {
-		return 0, errors.Wrap(err, "could not create light client update")
-	}
-
-	// Return the result
-	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
-		Version: ethpbv2.Version(signed.Version()),
-		Data:    CreateLightClientOptimisticUpdate(update),
-	}
-
-	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.LightClientOptimisticUpdate,
-		Data: result,
-	}), nil
-}
-
 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch
 // boundary in order to compute the right proposer indices after processing
 // state transition. This function is called on late blocks while still locked,

beacon-chain/blockchain/process_block_test.go

@@ -923,10 +923,8 @@ func Test_validateMergeTransitionBlock(t *testing.T) {
 				ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 				LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 				PrevRandao:    make([]byte, fieldparams.RootLength),
-				ExtraData:     make([]byte, 0),
 				BaseFeePerGas: make([]byte, fieldparams.RootLength),
 				BlockHash:     make([]byte, fieldparams.RootLength),
-				Transactions:  make([][]byte, 0),
 			},
 		},
 		{
@@ -970,7 +968,6 @@ func Test_validateMergeTransitionBlock(t *testing.T) {
 					ReceiptsRoot:     make([]byte, fieldparams.RootLength),
 					LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
 					PrevRandao:       make([]byte, fieldparams.RootLength),
-					ExtraData:        make([]byte, 0),
 					BaseFeePerGas:    make([]byte, fieldparams.RootLength),
 					BlockHash:        make([]byte, fieldparams.RootLength),
 					TransactionsRoot: make([]byte, fieldparams.RootLength),

beacon-chain/blockchain/receive_attestation.go

@@ -150,9 +150,7 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 		headBlock:     headBlock,
 		proposingSlot: proposingSlot,
 	}
-	if s.inRegularSync() {
-		fcuArgs.attributes = s.getPayloadAttribute(ctx, headState, proposingSlot, newHeadRoot[:])
-	}
+	fcuArgs.attributes = s.getPayloadAttribute(ctx, headState, proposingSlot, newHeadRoot[:])
 	if fcuArgs.attributes != nil && s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
 		return
 	}

beacon-chain/blockchain/receive_block.go

@@ -123,9 +123,6 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 	daWaitedTime := time.Since(daStartTime)
 
-	// Defragment the state before continuing block processing.
-	s.defragmentState(postState)
-
 	// The rest of block processing takes a lock on forkchoice.
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()

beacon-chain/blockchain/service.go

@@ -11,8 +11,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v4/async/event"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache"
@@ -39,35 +37,34 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v4/time"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                           *config
-	ctx                           context.Context
-	cancel                        context.CancelFunc
-	genesisTime                   time.Time
-	head                          *head
-	headLock                      sync.RWMutex
-	originBlockRoot               [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	boundaryRoots                 [][32]byte
-	checkpointStateCache          *cache.CheckpointStateCache
-	initSyncBlocks                map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
-	initSyncBlocksLock            sync.RWMutex
-	wsVerifier                    *WeakSubjectivityVerifier
-	clockSetter                   startup.ClockSetter
-	clockWaiter                   startup.ClockWaiter
-	syncComplete                  chan struct{}
-	blobNotifiers                 *blobNotifierMap
-	blockBeingSynced              *currentlySyncingBlock
-	blobStorage                   *filesystem.BlobStorage
-	lastPublishedLightClientEpoch primitives.Epoch
+	cfg                  *config
+	ctx                  context.Context
+	cancel               context.CancelFunc
+	genesisTime          time.Time
+	head                 *head
+	headLock             sync.RWMutex
+	originBlockRoot      [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	boundaryRoots        [][32]byte
+	checkpointStateCache *cache.CheckpointStateCache
+	initSyncBlocks       map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
+	initSyncBlocksLock   sync.RWMutex
+	wsVerifier           *WeakSubjectivityVerifier
+	clockSetter          startup.ClockSetter
+	clockWaiter          startup.ClockWaiter
+	syncComplete         chan struct{}
+	blobNotifiers        *blobNotifierMap
+	blockBeingSynced     *currentlySyncingBlock
+	blobStorage          *filesystem.BlobStorage
 }
 
 // config options for the service.

beacon-chain/blockchain/setup_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/cache/depositcache"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db/filesystem"
 	testDB "github.com/prysmaticlabs/prysm/v4/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
@@ -117,7 +116,6 @@ func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceReq
 		WithBLSToExecPool(req.blsPool),
 		WithDepositCache(dc),
 		WithTrackedValidatorsCache(cache.NewTrackedValidatorsCache()),
-		WithBlobStorage(filesystem.NewEphemeralBlobStorage(t)),
 	}
 	// append the variadic opts so they override the defaults by being processed afterwards
 	opts = append(defOpts, opts...)

beacon-chain/core/altair/epoch_precompute.go

@@ -15,12 +15,11 @@ import (
 
 // AttDelta contains rewards and penalties for a single attestation.
 type AttDelta struct {
-	HeadReward        uint64
-	SourceReward      uint64
-	SourcePenalty     uint64
-	TargetReward      uint64
-	TargetPenalty     uint64
-	InactivityPenalty uint64
+	HeadReward    uint64
+	SourceReward  uint64
+	SourcePenalty uint64
+	TargetReward  uint64
+	TargetPenalty uint64
 }
 
 // InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
@@ -252,7 +251,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 		if err != nil {
 			return nil, err
 		}
-		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], delta.SourcePenalty+delta.TargetPenalty+delta.InactivityPenalty)
+		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], delta.SourcePenalty+delta.TargetPenalty)
 
 		vals[i].AfterEpochTransitionBalance = balances[i]
 	}
@@ -352,7 +351,7 @@ func attestationDelta(
 		if err != nil {
 			return &AttDelta{}, err
 		}
-		attDelta.InactivityPenalty = n / inactivityDenominator
+		attDelta.TargetPenalty += n / inactivityDenominator
 	}
 
 	return attDelta, nil

beacon-chain/core/altair/epoch_precompute_test.go

@@ -220,7 +220,7 @@ func TestAttestationsDelta(t *testing.T) {
 	penalties := make([]uint64, len(deltas))
 	for i, d := range deltas {
 		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty + d.InactivityPenalty
+		penalties[i] = d.SourcePenalty + d.TargetPenalty
 	}
 
 	// Reward amount should increase as validator index increases due to setup.
@@ -258,7 +258,7 @@ func TestAttestationsDeltaBellatrix(t *testing.T) {
 	penalties := make([]uint64, len(deltas))
 	for i, d := range deltas {
 		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty + d.InactivityPenalty
+		penalties[i] = d.SourcePenalty + d.TargetPenalty
 	}
 
 	// Reward amount should increase as validator index increases due to setup.
@@ -306,7 +306,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 	penalties := make([]uint64, len(deltas))
 	for i, d := range deltas {
 		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty + d.InactivityPenalty
+		penalties[i] = d.SourcePenalty + d.TargetPenalty
 	}
 	for i := range rewards {
 		wanted[i] += rewards[i]

beacon-chain/core/blocks/genesis.go

@@ -105,7 +105,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 						ReceiptsRoot:  make([]byte, 32),
 						LogsBloom:     make([]byte, 256),
 						PrevRandao:    make([]byte, 32),
-						ExtraData:     make([]byte, 0),
 						BaseFeePerGas: make([]byte, 32),
 						BlockHash:     make([]byte, 32),
 						Transactions:  make([][]byte, 0),
@@ -137,7 +136,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 						ReceiptsRoot:  make([]byte, 32),
 						LogsBloom:     make([]byte, 256),
 						PrevRandao:    make([]byte, 32),
-						ExtraData:     make([]byte, 0),
 						BaseFeePerGas: make([]byte, 32),
 						BlockHash:     make([]byte, 32),
 						Transactions:  make([][]byte, 0),
@@ -170,7 +168,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 						ReceiptsRoot:  make([]byte, 32),
 						LogsBloom:     make([]byte, 256),
 						PrevRandao:    make([]byte, 32),
-						ExtraData:     make([]byte, 0),
 						BaseFeePerGas: make([]byte, 32),
 						BlockHash:     make([]byte, 32),
 						Transactions:  make([][]byte, 0),

beacon-chain/core/blocks/payload_test.go

@@ -853,10 +853,10 @@ func emptyPayloadHeader() (interfaces.ExecutionData, error) {
 		ReceiptsRoot:     make([]byte, fieldparams.RootLength),
 		LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
 		PrevRandao:       make([]byte, fieldparams.RootLength),
-		ExtraData:        make([]byte, 0),
 		BaseFeePerGas:    make([]byte, fieldparams.RootLength),
 		BlockHash:        make([]byte, fieldparams.RootLength),
 		TransactionsRoot: make([]byte, fieldparams.RootLength),
+		ExtraData:        make([]byte, 0),
 	})
 }
 
@@ -868,11 +868,11 @@ func emptyPayloadHeaderCapella() (interfaces.ExecutionData, error) {
 		ReceiptsRoot:     make([]byte, fieldparams.RootLength),
 		LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
 		PrevRandao:       make([]byte, fieldparams.RootLength),
-		ExtraData:        make([]byte, 0),
 		BaseFeePerGas:    make([]byte, fieldparams.RootLength),
 		BlockHash:        make([]byte, fieldparams.RootLength),
 		TransactionsRoot: make([]byte, fieldparams.RootLength),
 		WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+		ExtraData:        make([]byte, 0),
 	}, 0)
 }
 
@@ -884,10 +884,10 @@ func emptyPayload() *enginev1.ExecutionPayload {
 		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 		PrevRandao:    make([]byte, fieldparams.RootLength),
-		ExtraData:     make([]byte, 0),
 		BaseFeePerGas: make([]byte, fieldparams.RootLength),
 		BlockHash:     make([]byte, fieldparams.RootLength),
 		Transactions:  make([][]byte, 0),
+		ExtraData:     make([]byte, 0),
 	}
 }
 
@@ -899,10 +899,10 @@ func emptyPayloadCapella() *enginev1.ExecutionPayloadCapella {
 		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 		PrevRandao:    make([]byte, fieldparams.RootLength),
-		ExtraData:     make([]byte, 0),
 		BaseFeePerGas: make([]byte, fieldparams.RootLength),
 		BlockHash:     make([]byte, fieldparams.RootLength),
 		Transactions:  make([][]byte, 0),
 		Withdrawals:   make([]*enginev1.Withdrawal, 0),
+		ExtraData:     make([]byte, 0),
 	}
 }

beacon-chain/core/capella/upgrade_test.go

@@ -84,7 +84,6 @@ func TestUpgradeToCapella(t *testing.T) {
 		GasLimit:         prevHeader.GasLimit(),
 		GasUsed:          prevHeader.GasUsed(),
 		Timestamp:        prevHeader.Timestamp(),
-		ExtraData:        prevHeader.ExtraData(),
 		BaseFeePerGas:    prevHeader.BaseFeePerGas(),
 		BlockHash:        prevHeader.BlockHash(),
 		TransactionsRoot: txRoot,

beacon-chain/core/deneb/upgrade.go

@@ -57,10 +57,6 @@ func UpgradeToDeneb(state state.BeaconState) (state.BeaconState, error) {
 	if err != nil {
 		return nil, err
 	}
-	historicalRoots, err := state.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
 
 	s := &ethpb.BeaconStateDeneb{
 		GenesisTime:           state.GenesisTime(),
@@ -74,7 +70,7 @@ func UpgradeToDeneb(state state.BeaconState) (state.BeaconState, error) {
 		LatestBlockHeader:           state.LatestBlockHeader(),
 		BlockRoots:                  state.BlockRoots(),
 		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             historicalRoots,
+		HistoricalRoots:             [][]byte{},
 		Eth1Data:                    state.Eth1Data(),
 		Eth1DataVotes:               state.Eth1DataVotes(),
 		Eth1DepositIndex:            state.Eth1DepositIndex(),
@@ -105,10 +101,10 @@ func UpgradeToDeneb(state state.BeaconState) (state.BeaconState, error) {
 			ExtraData:        payloadHeader.ExtraData(),
 			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
 			BlockHash:        payloadHeader.BlockHash(),
-			TransactionsRoot: txRoot,
-			WithdrawalsRoot:  wdRoot,
 			ExcessBlobGas:    0,
 			BlobGasUsed:      0,
+			TransactionsRoot: txRoot,
+			WithdrawalsRoot:  wdRoot,
 		},
 		NextWithdrawalIndex:          wi,
 		NextWithdrawalValidatorIndex: vi,

beacon-chain/core/deneb/upgrade_test.go

@@ -14,7 +14,6 @@ import (
 
 func TestUpgradeToDeneb(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateCapella(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetHistoricalRoots([][]byte{{1}}))
 	preForkState := st.Copy()
 	mSt, err := deneb.UpgradeToDeneb(st)
 	require.NoError(t, err)
@@ -47,12 +46,6 @@ func TestUpgradeToDeneb(t *testing.T) {
 	require.NoError(t, err)
 	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
 
-	hr1, err := preForkState.HistoricalRoots()
-	require.NoError(t, err)
-	hr2, err := mSt.HistoricalRoots()
-	require.NoError(t, err)
-	require.DeepEqual(t, hr1, hr2)
-
 	f := mSt.Fork()
 	require.DeepSSZEqual(t, &ethpb.Fork{
 		PreviousVersion: st.Fork().CurrentVersion,
@@ -92,7 +85,6 @@ func TestUpgradeToDeneb(t *testing.T) {
 		GasLimit:         prevHeader.GasLimit(),
 		GasUsed:          prevHeader.GasUsed(),
 		Timestamp:        prevHeader.Timestamp(),
-		ExtraData:        prevHeader.ExtraData(),
 		BaseFeePerGas:    prevHeader.BaseFeePerGas(),
 		BlockHash:        prevHeader.BlockHash(),
 		TransactionsRoot: txRoot,

beacon-chain/core/execution/upgrade.go

@@ -79,7 +79,6 @@ func UpgradeToBellatrix(state state.BeaconState) (state.BeaconState, error) {
 			GasLimit:         0,
 			GasUsed:          0,
 			Timestamp:        0,
-			ExtraData:        make([]byte, 0),
 			BaseFeePerGas:    make([]byte, 32),
 			BlockHash:        make([]byte, 32),
 			TransactionsRoot: make([]byte, 32),

beacon-chain/core/execution/upgrade_test.go

@@ -79,7 +79,6 @@ func TestUpgradeToBellatrix(t *testing.T) {
 		GasLimit:         0,
 		GasUsed:          0,
 		Timestamp:        0,
-		ExtraData:        make([]byte, 0),
 		BaseFeePerGas:    make([]byte, 32),
 		BlockHash:        make([]byte, 32),
 		TransactionsRoot: make([]byte, 32),

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

@@ -27,10 +27,6 @@ const (
 	NewHead
 	// MissedSlot is sent when we need to notify users that a slot was missed.
 	MissedSlot
-	// LightClientFinalityUpdate event
-	LightClientFinalityUpdate
-	// LightClientOptimisticUpdate event
-	LightClientOptimisticUpdate
 )
 
 // BlockProcessedData is the data sent with BlockProcessed events.

beacon-chain/core/helpers/weak_subjectivity.go

@@ -202,14 +202,3 @@ func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Chec
 		Root:  bRoot,
 	}, nil
 }
-
-// MinEpochsForBlockRequests computes the number of epochs of block history that we need to maintain,
-// relative to the current epoch, per the p2p specs. This is used to compute the slot where backfill is complete.
-// value defined:
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#configuration
-// MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2 (= 33024, ~5 months)
-// detailed rationale: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
-func MinEpochsForBlockRequests() primitives.Epoch {
-	return params.BeaconConfig().MinValidatorWithdrawabilityDelay +
-		primitives.Epoch(params.BeaconConfig().ChurnLimitQuotient/2)
-}

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -281,19 +281,3 @@ func genState(t *testing.T, valCount, avgBalance uint64) state.BeaconState {
 
 	return beaconState
 }
-
-func TestMinEpochsForBlockRequests(t *testing.T) {
-	params.SetActiveTestCleanup(t, params.MainnetConfig())
-	var expected primitives.Epoch = 33024
-	// expected value of 33024 via spec commentary:
-	// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
-	//	MIN_EPOCHS_FOR_BLOCK_REQUESTS is calculated using the arithmetic from compute_weak_subjectivity_period found in the weak subjectivity guide. Specifically to find this max epoch range, we use the worst case event of a very large validator size (>= MIN_PER_EPOCH_CHURN_LIMIT * CHURN_LIMIT_QUOTIENT).
-	//
-	//	MIN_EPOCHS_FOR_BLOCK_REQUESTS = (
-	//	    MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-	//	    + MAX_SAFETY_DECAY * CHURN_LIMIT_QUOTIENT // (2 * 100)
-	//	)
-	//
-	//	Where MAX_SAFETY_DECAY = 100 and thus MIN_EPOCHS_FOR_BLOCK_REQUESTS = 33024 (~5 months).
-	require.Equal(t, expected, helpers.MinEpochsForBlockRequests())
-}

beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go

@@ -245,10 +245,10 @@ func createFullBellatrixBlockWithOperations(t *testing.T) (state.BeaconState,
 					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 					PrevRandao:    make([]byte, fieldparams.RootLength),
-					ExtraData:     make([]byte, 0),
 					BaseFeePerGas: bytesutil.PadTo([]byte{1, 2, 3, 4}, fieldparams.RootLength),
 					BlockHash:     make([]byte, fieldparams.RootLength),
 					Transactions:  make([][]byte, 0),
+					ExtraData:     make([]byte, 0),
 				},
 			},
 		},
@@ -284,11 +284,11 @@ func createFullCapellaBlockWithOperations(t *testing.T) (state.BeaconState,
 					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 					PrevRandao:    make([]byte, fieldparams.RootLength),
-					ExtraData:     make([]byte, 0),
 					BaseFeePerGas: bytesutil.PadTo([]byte{1, 2, 3, 4}, fieldparams.RootLength),
 					BlockHash:     make([]byte, fieldparams.RootLength),
 					Transactions:  make([][]byte, 0),
 					Withdrawals:   make([]*enginev1.Withdrawal, 0),
+					ExtraData:     make([]byte, 0),
 				},
 			},
 		},

beacon-chain/core/transition/state-bellatrix.go

@@ -209,7 +209,6 @@ func OptimizedGenesisBeaconStateBellatrix(genesisTime uint64, preState state.Bea
 			ReceiptsRoot:  make([]byte, 32),
 			LogsBloom:     make([]byte, 256),
 			PrevRandao:    make([]byte, 32),
-			ExtraData:     make([]byte, 0),
 			BaseFeePerGas: make([]byte, 32),
 			BlockHash:     make([]byte, 32),
 			Transactions:  make([][]byte, 0),
@@ -270,7 +269,6 @@ func EmptyGenesisStateBellatrix() (state.BeaconState, error) {
 			ReceiptsRoot:     make([]byte, 32),
 			LogsBloom:        make([]byte, 256),
 			PrevRandao:       make([]byte, 32),
-			ExtraData:        make([]byte, 0),
 			BaseFeePerGas:    make([]byte, 32),
 			BlockHash:        make([]byte, 32),
 			TransactionsRoot: make([]byte, 32),

beacon-chain/das/cache.go

@@ -103,7 +103,7 @@ func (e *cacheEntry) filter(root [32]byte, kc safeCommitmentArray) ([]blocks.ROB
 	return scs, nil
 }
 
-// safeCommitmentArray is a fixed size array of commitment byte slices. This is helpful for avoiding
+// safeCommitemntArray is a fixed size array of commitment byte slices. This is helpful for avoiding
 // gratuitous bounds checks.
 type safeCommitmentArray [fieldparams.MaxBlobsPerBlock][]byte
 

beacon-chain/db/errors.go

@@ -22,6 +22,9 @@ var ErrNotFoundOriginBlockRoot = kv.ErrNotFoundOriginBlockRoot
 // ErrNotFoundBackfillBlockRoot wraps ErrNotFound for an error specific to the backfill block root.
 var ErrNotFoundBackfillBlockRoot = kv.ErrNotFoundBackfillBlockRoot
 
+// ErrNotFoundGenesisBlockRoot means no genesis block root was found, indicating the db was not initialized with genesis
+var ErrNotFoundGenesisBlockRoot = kv.ErrNotFoundGenesisBlockRoot
+
 // IsNotFound allows callers to treat errors from a flat-file database, where the file record is missing,
 // as equivalent to db.ErrNotFound.
 func IsNotFound(err error) bool {

beacon-chain/db/filesystem/blob.go

@@ -156,7 +156,7 @@ func (bs *BlobStorage) Save(sidecar blocks.VerifiedROBlob) error {
 	}
 	partialMoved = true
 	blobsWrittenCounter.Inc()
-	blobSaveLatency.Observe(float64(time.Since(startTime).Milliseconds()))
+	blobSaveLatency.Observe(time.Since(startTime).Seconds())
 	return nil
 }
 
@@ -180,17 +180,11 @@ func (bs *BlobStorage) Get(root [32]byte, idx uint64) (blocks.VerifiedROBlob, er
 		return blocks.VerifiedROBlob{}, err
 	}
 	defer func() {
-		blobFetchLatency.Observe(float64(time.Since(startTime).Milliseconds()))
+		blobFetchLatency.Observe(time.Since(startTime).Seconds())
 	}()
 	return verification.BlobSidecarNoop(ro)
 }
 
-// Remove removes all blobs for a given root.
-func (bs *BlobStorage) Remove(root [32]byte) error {
-	rootDir := blobNamer{root: root}.dir()
-	return bs.fs.RemoveAll(rootDir)
-}
-
 // Indices generates a bitmap representing which BlobSidecar.Index values are present on disk for a given root.
 // This value can be compared to the commitments observed in a block to determine which indices need to be found
 // on the network to confirm data availability.

beacon-chain/db/filesystem/blob_test.go

@@ -73,21 +73,6 @@ func TestBlobStorage_SaveBlobData(t *testing.T) {
 		require.NoError(t, err)
 		require.DeepSSZEqual(t, expected, actual)
 	})
-
-	t.Run("round trip write, read and delete", func(t *testing.T) {
-		bs := NewEphemeralBlobStorage(t)
-		err := bs.Save(testSidecars[0])
-		require.NoError(t, err)
-
-		expected := testSidecars[0]
-		actual, err := bs.Get(expected.BlockRoot(), expected.Index)
-		require.NoError(t, err)
-		require.DeepSSZEqual(t, expected, actual)
-
-		require.NoError(t, bs.Remove(expected.BlockRoot()))
-		_, err = bs.Get(expected.BlockRoot(), expected.Index)
-		require.ErrorContains(t, "file does not exist", err)
-	})
 }
 
 // pollUntil polls a condition function until it returns true or a timeout is reached.

beacon-chain/db/filesystem/metrics.go

@@ -6,15 +6,15 @@ import (
 )
 
 var (
-	blobBuckets     = []float64{3, 5, 7, 9, 11, 13}
+	blobBuckets     = []float64{0.00003, 0.00005, 0.00007, 0.00009, 0.00011, 0.00013, 0.00015}
 	blobSaveLatency = promauto.NewHistogram(prometheus.HistogramOpts{
 		Name:    "blob_storage_save_latency",
-		Help:    "Latency of BlobSidecar storage save operations in milliseconds",
+		Help:    "Latency of BlobSidecar storage save operations in seconds",
 		Buckets: blobBuckets,
 	})
 	blobFetchLatency = promauto.NewHistogram(prometheus.HistogramOpts{
 		Name:    "blob_storage_get_latency",
-		Help:    "Latency of BlobSidecar storage get operations in milliseconds",
+		Help:    "Latency of BlobSidecar storage get operations in seconds",
 		Buckets: blobBuckets,
 	})
 	blobsPrunedCounter = promauto.NewCounter(prometheus.CounterOpts{

beacon-chain/db/iface/BUILD.bazel

@@ -13,11 +13,9 @@ go_library(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/slasher/types:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//monitoring/backup:go_default_library",
-        "//proto/dbval:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
     ],

beacon-chain/db/iface/interface.go

@@ -11,11 +11,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db/filters"
 	slashertypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/monitoring/backup"
-	"github.com/prysmaticlabs/prysm/v4/proto/dbval"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
@@ -59,7 +57,7 @@ type ReadOnlyDatabase interface {
 
 	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
-	BackfillStatus(context.Context) (*dbval.BackfillStatus, error)
+	BackfillBlockRoot(ctx context.Context) ([32]byte, error)
 }
 
 // NoHeadAccessDatabase defines a struct without access to chain head data.
@@ -70,7 +68,6 @@ type NoHeadAccessDatabase interface {
 	DeleteBlock(ctx context.Context, root [32]byte) error
 	SaveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) error
 	SaveBlocks(ctx context.Context, blocks []interfaces.ReadOnlySignedBeaconBlock) error
-	SaveROBlocks(ctx context.Context, blks []blocks.ROBlock, cache bool) error
 	SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) error
 	// State related methods.
 	SaveState(ctx context.Context, state state.ReadOnlyBeaconState, blockRoot [32]byte) error
@@ -109,10 +106,9 @@ type HeadAccessDatabase interface {
 	SaveGenesisData(ctx context.Context, state state.BeaconState) error
 	EnsureEmbeddedGenesis(ctx context.Context) error
 
-	// Support for checkpoint sync and backfill.
+	// initialization method needed for origin checkpoint sync
 	SaveOrigin(ctx context.Context, serState, serBlock []byte) error
-	SaveBackfillStatus(context.Context, *dbval.BackfillStatus) error
-	BackfillFinalizedIndex(ctx context.Context, blocks []blocks.ROBlock, finalizedChildRoot [32]byte) error
+	SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error
 }
 
 // SlasherDatabase interface for persisting data related to detecting slashable offenses on Ethereum.

beacon-chain/db/kv/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "archived_point.go",
-        "backfill.go",
         "backup.go",
         "blocks.go",
         "checkpoint.go",
@@ -49,7 +48,6 @@ go_library(
         "//io/file:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//proto/dbval:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
@@ -75,7 +73,6 @@ go_test(
     name = "go_default_test",
     srcs = [
         "archived_point_test.go",
-        "backfill_test.go",
         "backup_test.go",
         "blocks_test.go",
         "checkpoint_test.go",
@@ -110,7 +107,6 @@ go_test(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",

beacon-chain/db/kv/backfill.go

@@ -1,44 +0,0 @@
-package kv
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/proto/dbval"
-	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
-	"google.golang.org/protobuf/proto"
-)
-
-// SaveBackfillStatus encodes the given BackfillStatus protobuf struct and writes it to a single key in the db.
-// This value is used by the backfill service to keep track of the range of blocks that need to be synced. It is also used by the
-// code that serves blocks or regenerates states to keep track of what range of blocks are available.
-func (s *Store) SaveBackfillStatus(ctx context.Context, bf *dbval.BackfillStatus) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveBackfillStatus")
-	defer span.End()
-	bfb, err := proto.Marshal(bf)
-	if err != nil {
-		return err
-	}
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(blocksBucket)
-		return bucket.Put(backfillStatusKey, bfb)
-	})
-}
-
-// BackfillStatus retrieves the most recently saved version of the BackfillStatus protobuf struct.
-// This is used to persist information about backfill status across restarts.
-func (s *Store) BackfillStatus(ctx context.Context) (*dbval.BackfillStatus, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.BackfillStatus")
-	defer span.End()
-	bf := &dbval.BackfillStatus{}
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(blocksBucket)
-		bs := bucket.Get(backfillStatusKey)
-		if len(bs) == 0 {
-			return errors.Wrap(ErrNotFound, "BackfillStatus not found")
-		}
-		return proto.Unmarshal(bs, bf)
-	})
-	return bf, err
-}

beacon-chain/db/kv/backfill_test.go

@@ -1,35 +0,0 @@
-package kv
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v4/proto/dbval"
-	"github.com/prysmaticlabs/prysm/v4/testing/require"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestBackfillRoundtrip(t *testing.T) {
-	db := setupDB(t)
-	b := &dbval.BackfillStatus{}
-	b.LowSlot = 23
-	b.LowRoot = bytesutil.PadTo([]byte("low"), 32)
-	b.LowParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-	m, err := proto.Marshal(b)
-	require.NoError(t, err)
-	ub := &dbval.BackfillStatus{}
-	require.NoError(t, proto.Unmarshal(m, ub))
-	require.Equal(t, b.LowSlot, ub.LowSlot)
-	require.DeepEqual(t, b.LowRoot, ub.LowRoot)
-	require.DeepEqual(t, b.LowParentRoot, ub.LowParentRoot)
-
-	ctx := context.Background()
-	require.NoError(t, db.SaveBackfillStatus(ctx, b))
-	dbub, err := db.BackfillStatus(ctx)
-	require.NoError(t, err)
-
-	require.Equal(t, b.LowSlot, dbub.LowSlot)
-	require.DeepEqual(t, b.LowRoot, dbub.LowRoot)
-	require.DeepEqual(t, b.LowParentRoot, dbub.LowParentRoot)
-}

beacon-chain/db/kv/blocks.go

@@ -70,6 +70,25 @@ func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	return root, err
 }
 
+// BackfillBlockRoot keeps track of the highest block available before the OriginCheckpointBlockRoot
+func (s *Store) BackfillBlockRoot(ctx context.Context) ([32]byte, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.BackfillBlockRoot")
+	defer span.End()
+
+	var root [32]byte
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(blocksBucket)
+		rootSlice := bkt.Get(backfillBlockRootKey)
+		if len(rootSlice) == 0 {
+			return ErrNotFoundBackfillBlockRoot
+		}
+		root = bytesutil.ToBytes32(rootSlice)
+		return nil
+	})
+
+	return root, err
+}
+
 // HeadBlock returns the latest canonical block in the Ethereum Beacon Chain.
 func (s *Store) HeadBlock(ctx context.Context) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.HeadBlock")
@@ -273,95 +292,55 @@ func (s *Store) SaveBlocks(ctx context.Context, blks []interfaces.ReadOnlySigned
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBlocks")
 	defer span.End()
 
-	robs := make([]blocks.ROBlock, len(blks))
-	for i := range blks {
-		rb, err := blocks.NewROBlock(blks[i])
+	// Performing marshaling, hashing, and indexing outside the bolt transaction
+	// to minimize the time we hold the DB lock.
+	blockRoots := make([][]byte, len(blks))
+	encodedBlocks := make([][]byte, len(blks))
+	indicesForBlocks := make([]map[string][]byte, len(blks))
+	for i, blk := range blks {
+		blockRoot, err := blk.Block().HashTreeRoot()
 		if err != nil {
-			return errors.Wrapf(err, "failed to make an ROBlock for a block in SaveBlocks")
+			return err
 		}
-		robs[i] = rb
-	}
-	return s.SaveROBlocks(ctx, robs, true)
-}
-
-type blockBatchEntry struct {
-	root    []byte
-	block   interfaces.ReadOnlySignedBeaconBlock
-	enc     []byte
-	updated bool
-	indices map[string][]byte
-}
-
-func prepareBlockBatch(blks []blocks.ROBlock, shouldBlind bool) ([]blockBatchEntry, error) {
-	batch := make([]blockBatchEntry, len(blks))
-	for i := range blks {
-		batch[i].root, batch[i].block = blks[i].RootSlice(), blks[i].ReadOnlySignedBeaconBlock
-		batch[i].indices = blockIndices(batch[i].block.Block().Slot(), batch[i].block.Block().ParentRoot())
-		if shouldBlind {
-			blinded, err := batch[i].block.ToBlinded()
-			if err != nil {
-				if !errors.Is(err, blocks.ErrUnsupportedVersion) {
-					return nil, errors.Wrapf(err, "could not convert block to blinded format for root %#x", batch[i].root)
-				}
-				// Pre-deneb blocks give ErrUnsupportedVersion; use the full block already in the batch entry.
-			} else {
-				batch[i].block = blinded
-			}
-		}
-		enc, err := encodeBlock(batch[i].block)
+		enc, err := s.marshalBlock(ctx, blk)
 		if err != nil {
-			return nil, errors.Wrapf(err, "failed to encode block for root %#x", batch[i].root)
+			return err
 		}
-		batch[i].enc = enc
+		blockRoots[i] = blockRoot[:]
+		encodedBlocks[i] = enc
+		indicesByBucket := createBlockIndicesFromBlock(ctx, blk.Block())
+		indicesForBlocks[i] = indicesByBucket
 	}
-	return batch, nil
-}
-
-func (s *Store) SaveROBlocks(ctx context.Context, blks []blocks.ROBlock, cache bool) error {
-	shouldBlind, err := s.shouldSaveBlinded(ctx)
+	saveBlinded, err := s.shouldSaveBlinded(ctx)
 	if err != nil {
 		return err
 	}
-	// Precompute expensive values outside the db transaction.
-	batch, err := prepareBlockBatch(blks, shouldBlind)
-	if err != nil {
-		return errors.Wrap(err, "failed to encode all blocks in batch for saving to the db")
-	}
-	err = s.db.Update(func(tx *bolt.Tx) error {
+	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
-		for i := range batch {
-			if exists := bkt.Get(batch[i].root); exists != nil {
+		for i, blk := range blks {
+			if existingBlock := bkt.Get(blockRoots[i]); existingBlock != nil {
 				continue
 			}
-			if err := bkt.Put(batch[i].root, batch[i].enc); err != nil {
-				return errors.Wrapf(err, "could write block to db with root %#x", batch[i].root)
+			if err := updateValueForIndices(ctx, indicesForBlocks[i], blockRoots[i], tx); err != nil {
+				return errors.Wrap(err, "could not update DB indices")
 			}
-			if err := updateValueForIndices(ctx, batch[i].indices, batch[i].root, tx); err != nil {
-				return errors.Wrapf(err, "could not update DB indices for root %#x", batch[i].root)
+			if saveBlinded {
+				blindedBlock, err := blk.ToBlinded()
+				if err != nil {
+					if !errors.Is(err, blocks.ErrUnsupportedVersion) {
+						return err
+					}
+				} else {
+					blk = blindedBlock
+				}
+			}
+			s.blockCache.Set(string(blockRoots[i]), blk, int64(len(encodedBlocks[i])))
+			if err := bkt.Put(blockRoots[i], encodedBlocks[i]); err != nil {
+				return err
 			}
-			batch[i].updated = true
 		}
 		return nil
 	})
-	if !cache {
-		return err
-	}
-	for i := range batch {
-		if batch[i].updated {
-			s.blockCache.Set(string(batch[i].root), batch[i].block, int64(len(batch[i].enc)))
-		}
-	}
-	return err
-}
-
-// blockIndices takes in a beacon block and returns
-// a map of bolt DB index buckets corresponding to each particular key for indices for
-// data, such as (shard indices bucket -> shard 5).
-func blockIndices(slot primitives.Slot, parentRoot [32]byte) map[string][]byte {
-	return map[string][]byte{
-		string(blockSlotIndicesBucket):       bytesutil.SlotToBytesBigEndian(slot),
-		string(blockParentRootIndicesBucket): parentRoot[:],
-	}
 }
 
 // SaveHeadBlockRoot to the db.
@@ -438,6 +417,17 @@ func (s *Store) SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32
 	})
 }
 
+// SaveBackfillBlockRoot is used to keep track of the most recently backfilled block root when
+// the node was initialized via checkpoint sync.
+func (s *Store) SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveBackfillBlockRoot")
+	defer span.End()
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(blocksBucket)
+		return bucket.Put(backfillBlockRootKey, blockRoot[:])
+	})
+}
+
 // HighestRootsBelowSlot returns roots from the database slot index from the highest slot below the input slot.
 // The slot value at the beginning of the return list is the slot where the roots were found. This is helpful so that
 // calling code can make decisions based on the slot without resolving the blocks to discover their slot (for instance
@@ -736,6 +726,31 @@ func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot primitives.Slot) ([
 	return [][32]byte{}, nil
 }
 
+// createBlockIndicesFromBlock takes in a beacon block and returns
+// a map of bolt DB index buckets corresponding to each particular key for indices for
+// data, such as (shard indices bucket -> shard 5).
+func createBlockIndicesFromBlock(ctx context.Context, block interfaces.ReadOnlyBeaconBlock) map[string][]byte {
+	_, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromBlock")
+	defer span.End()
+	indicesByBucket := make(map[string][]byte)
+	// Every index has a unique bucket for fast, binary-search
+	// range scans for filtering across keys.
+	buckets := [][]byte{
+		blockSlotIndicesBucket,
+	}
+	indices := [][]byte{
+		bytesutil.SlotToBytesBigEndian(block.Slot()),
+	}
+	buckets = append(buckets, blockParentRootIndicesBucket)
+	parentRoot := block.ParentRoot()
+	indices = append(indices, parentRoot[:])
+
+	for i := 0; i < len(buckets); i++ {
+		indicesByBucket[string(buckets[i])] = indices[i]
+	}
+	return indicesByBucket
+}
+
 // createBlockFiltersFromIndices takes in filter criteria and returns
 // a map with a single key-value pair: "block-parent-root-indices” -> parentRoot (array of bytes).
 //
@@ -823,44 +838,74 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 	return blocks.NewSignedBeaconBlock(rawBlock)
 }
 
-func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
-	key, err := keyForBlock(blk)
+func (s *Store) marshalBlock(
+	ctx context.Context,
+	blk interfaces.ReadOnlySignedBeaconBlock,
+) ([]byte, error) {
+	shouldBlind, err := s.shouldSaveBlinded(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not determine version encoding key for block")
+		return nil, err
 	}
-	enc, err := blk.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
+	if shouldBlind {
+		return marshalBlockBlinded(ctx, blk)
 	}
-	dbfmt := make([]byte, len(key)+len(enc))
-	if len(key) > 0 {
-		copy(dbfmt, key)
-	}
-	copy(dbfmt[len(key):], enc)
-	return snappy.Encode(nil, dbfmt), nil
+	return marshalBlockFull(ctx, blk)
 }
 
-func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+// Encodes a full beacon block to the DB with its associated key.
+func marshalBlockFull(
+	_ context.Context,
+	blk interfaces.ReadOnlySignedBeaconBlock,
+) ([]byte, error) {
+	var encodedBlock []byte
+	var err error
+	encodedBlock, err = blk.MarshalSSZ()
+	if err != nil {
+		return nil, err
+	}
 	switch blk.Version() {
 	case version.Deneb:
-		if blk.IsBlinded() {
-			return denebBlindKey, nil
-		}
-		return denebKey, nil
+		return snappy.Encode(nil, append(denebKey, encodedBlock...)), nil
 	case version.Capella:
-		if blk.IsBlinded() {
-			return capellaBlindKey, nil
-		}
-		return capellaKey, nil
+		return snappy.Encode(nil, append(capellaKey, encodedBlock...)), nil
 	case version.Bellatrix:
-		if blk.IsBlinded() {
-			return bellatrixBlindKey, nil
-		}
-		return bellatrixKey, nil
+		return snappy.Encode(nil, append(bellatrixKey, encodedBlock...)), nil
 	case version.Altair:
-		return altairKey, nil
+		return snappy.Encode(nil, append(altairKey, encodedBlock...)), nil
 	case version.Phase0:
-		return nil, nil
+		return snappy.Encode(nil, encodedBlock), nil
+	default:
+		return nil, errors.New("unknown block version")
+	}
+}
+
+// Encodes a blinded beacon block with its associated key.
+// If the block does not support blinding, we then encode it as a full
+// block with its associated key by calling marshalBlockFull.
+func marshalBlockBlinded(
+	ctx context.Context,
+	blk interfaces.ReadOnlySignedBeaconBlock,
+) ([]byte, error) {
+	blindedBlock, err := blk.ToBlinded()
+	if err != nil {
+		switch {
+		case errors.Is(err, blocks.ErrUnsupportedVersion):
+			return marshalBlockFull(ctx, blk)
+		default:
+			return nil, errors.Wrap(err, "could not convert block to blinded format")
+		}
+	}
+	encodedBlock, err := blindedBlock.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not marshal blinded block")
+	}
+	switch blk.Version() {
+	case version.Deneb:
+		return snappy.Encode(nil, append(denebBlindKey, encodedBlock...)), nil
+	case version.Capella:
+		return snappy.Encode(nil, append(capellaBlindKey, encodedBlock...)), nil
+	case version.Bellatrix:
+		return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil
 	default:
 		return nil, fmt.Errorf("unsupported block version: %v", blk.Version())
 	}

beacon-chain/db/kv/blocks_test.go

@@ -126,6 +126,23 @@ var blockTests = []struct {
 	},
 }
 
+func TestStore_SaveBackfillBlockRoot(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	_, err := db.BackfillBlockRoot(ctx)
+	require.ErrorIs(t, err, ErrNotFoundBackfillBlockRoot)
+
+	var expected [32]byte
+	copy(expected[:], []byte{0x23})
+	err = db.SaveBackfillBlockRoot(ctx, expected)
+	require.NoError(t, err)
+	actual, err := db.BackfillBlockRoot(ctx)
+	require.NoError(t, err)
+	require.Equal(t, expected, actual)
+
+}
+
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
 	BlockCacheSize = 1
 	slot := primitives.Slot(20)

beacon-chain/db/kv/error.go

@@ -21,8 +21,3 @@ var ErrNotFoundBackfillBlockRoot = errors.Wrap(ErrNotFound, "BackfillBlockRoot")
 
 // ErrNotFoundFeeRecipient is a not found error specifically for the fee recipient getter
 var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
-
-var errEmptyBlockSlice = errors.New("[]blocks.ROBlock is empty")
-var errIncorrectBlockParent = errors.New("unexpected missing or forked blocks in a []ROBlock")
-var errFinalizedChildNotFound = errors.New("unable to find finalized root descending from backfill batch")
-var errNotConnectedToFinalized = errors.New("unable to finalize backfill blocks, finalized parent_root does not match")

beacon-chain/db/kv/finalized_block_roots.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
@@ -164,83 +163,6 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 	return bkt.Put(previousFinalizedCheckpointKey, enc)
 }
 
-// BackfillFinalizedIndex updates the finalized index for a contiguous chain of blocks that are the ancestors of the
-// given finalized child root. This is needed to update the finalized index during backfill, because the usual
-// updateFinalizedBlockRoots has assumptions that are incompatible with backfill processing.
-func (s *Store) BackfillFinalizedIndex(ctx context.Context, blocks []blocks.ROBlock, finalizedChildRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.BackfillFinalizedIndex")
-	defer span.End()
-	if len(blocks) == 0 {
-		return errEmptyBlockSlice
-	}
-
-	fbrs := make([]*ethpb.FinalizedBlockRootContainer, len(blocks))
-	encs := make([][]byte, len(blocks))
-	for i := range blocks {
-		pr := blocks[i].Block().ParentRoot()
-		fbrs[i] = &ethpb.FinalizedBlockRootContainer{
-			ParentRoot: pr[:],
-			// ChildRoot: will be filled in on the next iteration when we look at the descendent block.
-		}
-		if i == 0 {
-			continue
-		}
-		if blocks[i-1].Root() != blocks[i].Block().ParentRoot() {
-			return errors.Wrapf(errIncorrectBlockParent, "previous root=%#x, slot=%d; child parent_root=%#x, root=%#x, slot=%d",
-				blocks[i-1].Root(), blocks[i-1].Block().Slot(), blocks[i].Block().ParentRoot(), blocks[i].Root(), blocks[i].Block().Slot())
-		}
-
-		// We know the previous index is the parent of this one thanks to the assertion above,
-		// so we can set the ChildRoot of the previous value to the root of the current value.
-		fbrs[i-1].ChildRoot = blocks[i].RootSlice()
-		// Now that the value for fbrs[i-1] is complete, perform encoding here to minimize time in Update,
-		// which holds the global db lock.
-		penc, err := encode(ctx, fbrs[i-1])
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return err
-		}
-		encs[i-1] = penc
-
-		// The final element is the parent of finalizedChildRoot. This is checked inside the db transaction using
-		// the parent_root value stored in the index data for finalizedChildRoot.
-		if i == len(blocks)-1 {
-			fbrs[i].ChildRoot = finalizedChildRoot[:]
-			// Final element is complete, so it is pre-encoded like the others.
-			enc, err := encode(ctx, fbrs[i])
-			if err != nil {
-				tracing.AnnotateError(span, err)
-				return err
-			}
-			encs[i] = enc
-		}
-	}
-
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(finalizedBlockRootsIndexBucket)
-		child := bkt.Get(finalizedChildRoot[:])
-		if len(child) == 0 {
-			return errFinalizedChildNotFound
-		}
-		fcc := &ethpb.FinalizedBlockRootContainer{}
-		if err := decode(ctx, child, fcc); err != nil {
-			return errors.Wrapf(err, "unable to decode finalized block root container for root=%#x", finalizedChildRoot)
-		}
-		// Ensure that the existing finalized chain descends from the new segment.
-		if !bytes.Equal(fcc.ParentRoot, blocks[len(blocks)-1].RootSlice()) {
-			return errors.Wrapf(errNotConnectedToFinalized, "finalized block root container for root=%#x has parent_root=%#x, not %#x",
-				finalizedChildRoot, fcc.ParentRoot, blocks[len(blocks)-1].RootSlice())
-		}
-		// Update the finalized index with entries for each block in the new segment.
-		for i := range fbrs {
-			if err := bkt.Put(blocks[i].RootSlice(), encs[i]); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}
-
 // IsFinalizedBlock returns true if the block root is present in the finalized block root index.
 // A beacon block root contained exists in this index if it is considered finalized and canonical.
 // Note: beacon blocks from the latest finalized epoch return true, whether or not they are

beacon-chain/db/kv/finalized_block_roots_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"bytes"
 	"context"
 	"testing"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
 	"github.com/prysmaticlabs/prysm/v4/testing/util"
-	bolt "go.etcd.io/bbolt"
 )
 
 var genesisBlockRoot = bytesutil.ToBytes32([]byte{'G', 'E', 'N', 'E', 'S', 'I', 'S'})
@@ -236,64 +234,3 @@ func makeBlocksAltair(t *testing.T, startIdx, num uint64, previousRoot [32]byte)
 	}
 	return ifaceBlocks
 }
-
-func TestStore_BackfillFinalizedIndex(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	require.ErrorIs(t, db.BackfillFinalizedIndex(ctx, []consensusblocks.ROBlock{}, [32]byte{}), errEmptyBlockSlice)
-	blks, err := consensusblocks.NewROBlockSlice(makeBlocks(t, 0, 66, [32]byte{}))
-	require.NoError(t, err)
-
-	// set up existing finalized block
-	ebpr := blks[64].Block().ParentRoot()
-	ebr := blks[64].Root()
-	chldr := blks[65].Root()
-	ebf := &ethpb.FinalizedBlockRootContainer{
-		ParentRoot: ebpr[:],
-		ChildRoot:  chldr[:],
-	}
-	disjoint := []consensusblocks.ROBlock{
-		blks[0],
-		blks[2],
-	}
-	enc, err := encode(ctx, ebf)
-	require.NoError(t, err)
-	err = db.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(finalizedBlockRootsIndexBucket)
-		return bkt.Put(ebr[:], enc)
-	})
-
-	// reslice to remove the existing blocks
-	blks = blks[0:64]
-	// check the other error conditions with a descendent root that really doesn't exist
-	require.NoError(t, err)
-	require.ErrorIs(t, db.BackfillFinalizedIndex(ctx, disjoint, [32]byte{}), errIncorrectBlockParent)
-	require.NoError(t, err)
-	require.ErrorIs(t, errFinalizedChildNotFound, db.BackfillFinalizedIndex(ctx, blks, [32]byte{}))
-
-	// use the real root so that it succeeds
-	require.NoError(t, db.BackfillFinalizedIndex(ctx, blks, ebr))
-	for i := range blks {
-		require.NoError(t, db.db.View(func(tx *bolt.Tx) error {
-			bkt := tx.Bucket(finalizedBlockRootsIndexBucket)
-			encfr := bkt.Get(blks[i].RootSlice())
-			require.Equal(t, true, len(encfr) > 0)
-			fr := &ethpb.FinalizedBlockRootContainer{}
-			require.NoError(t, decode(ctx, encfr, fr))
-			require.Equal(t, 32, len(fr.ParentRoot))
-			require.Equal(t, 32, len(fr.ChildRoot))
-			pr := blks[i].Block().ParentRoot()
-			require.Equal(t, true, bytes.Equal(fr.ParentRoot, pr[:]))
-			if i > 0 {
-				require.Equal(t, true, bytes.Equal(fr.ParentRoot, blks[i-1].RootSlice()))
-			}
-			if i < len(blks)-1 {
-				require.DeepEqual(t, fr.ChildRoot, blks[i+1].RootSlice())
-			}
-			if i == len(blks)-1 {
-				require.DeepEqual(t, fr.ChildRoot, ebr[:])
-			}
-			return nil
-		}))
-	}
-}

beacon-chain/db/kv/kv_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"testing"
@@ -117,25 +116,13 @@ func Test_setupBlockStorageType(t *testing.T) {
 		root, err = wrappedBlock.Block().HashTreeRoot()
 		require.NoError(t, err)
 		require.NoError(t, store.SaveBlock(ctx, wrappedBlock))
-		wrappedBlinded, err := wrappedBlock.ToBlinded()
-		require.NoError(t, err)
-
 		retrievedBlk, err = store.Block(ctx, root)
 		require.NoError(t, err)
+
 		require.Equal(t, true, retrievedBlk.IsBlinded())
-
-		// Compare retrieved value by root, and marshaled bytes.
-		mSrc, err := wrappedBlinded.MarshalSSZ()
+		wrappedBlinded, err := wrappedBlock.ToBlinded()
 		require.NoError(t, err)
-		mTgt, err := retrievedBlk.MarshalSSZ()
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(mSrc, mTgt))
-
-		rSrc, err := wrappedBlinded.Block().HashTreeRoot()
-		require.NoError(t, err)
-		rTgt, err := retrievedBlk.Block().HashTreeRoot()
-		require.NoError(t, err)
-		require.Equal(t, rSrc, rTgt)
+		require.DeepEqual(t, wrappedBlinded, retrievedBlk)
 	})
 	t.Run("existing database with full blocks type should continue storing full blocks", func(t *testing.T) {
 		store := setupDB(t)
@@ -168,21 +155,10 @@ func Test_setupBlockStorageType(t *testing.T) {
 		root, err = wrappedBlock.Block().HashTreeRoot()
 		require.NoError(t, err)
 		require.NoError(t, store.SaveBlock(ctx, wrappedBlock))
-
 		retrievedBlk, err = store.Block(ctx, root)
 		require.NoError(t, err)
 		require.Equal(t, false, retrievedBlk.IsBlinded())
-
-		// Compare retrieved value by root, and marshaled bytes.
-		mSrc, err := wrappedBlock.MarshalSSZ()
-		require.NoError(t, err)
-		mTgt, err := retrievedBlk.MarshalSSZ()
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(mSrc, mTgt))
-
-		rTgt, err := retrievedBlk.Block().HashTreeRoot()
-		require.NoError(t, err)
-		require.Equal(t, root, rTgt)
+		require.DeepEqual(t, wrappedBlock, retrievedBlk)
 	})
 	t.Run("existing database with blinded blocks type should error if user enables full blocks feature flag", func(t *testing.T) {
 		store := setupDB(t)

beacon-chain/db/kv/schema.go

@@ -47,6 +47,10 @@ var (
 	finalizedCheckpointKey     = []byte("finalized-checkpoint")
 	powchainDataKey            = []byte("powchain-data")
 	lastValidatedCheckpointKey = []byte("last-validated-checkpoint")
+	// blobRetentionEpochsKey determines the size of the blob circular buffer and how the keys in that buffer are
+	// determined. If this value changes, the existing data is invalidated, so storing it in the db
+	// allows us to assert at runtime that the db state is still consistent with the runtime state.
+	blobRetentionEpochsKey = []byte("blob-retention-epochs")
 
 	// Below keys are used to identify objects are to be fork compatible.
 	// Objects that are only compatible with specific forks should be prefixed with such keys.
@@ -61,8 +65,8 @@ var (
 
 	// block root included in the beacon state used by weak subjectivity initial sync
 	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")
-	// tracking data about an ongoing backfill
-	backfillStatusKey = []byte("backfill-status")
+	// block root tracking the progress of backfill, or pointing at genesis if backfill has not been initiated
+	backfillBlockRootKey = []byte("backfill-block-root")
 
 	// Deprecated: This index key was migrated in PR 6461. Do not use, except for migrations.
 	lastArchivedIndexKey = []byte("last-archived")

beacon-chain/db/kv/wss.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/ssz/detect"
-	"github.com/prysmaticlabs/prysm/v4/proto/dbval"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 )
@@ -18,6 +17,18 @@ import (
 // syncing, using the provided values as their point of origin. This is an alternative
 // to syncing from genesis, and should only be run on an empty database.
 func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error {
+	genesisRoot, err := s.GenesisBlockRoot(ctx)
+	if err != nil {
+		if errors.Is(err, ErrNotFoundGenesisBlockRoot) {
+			return errors.Wrap(err, "genesis block root not found: genesis must be provided for checkpoint sync")
+		}
+		return errors.Wrap(err, "genesis block root query error: checkpoint sync must verify genesis to proceed")
+	}
+	err = s.SaveBackfillBlockRoot(ctx, genesisRoot)
+	if err != nil {
+		return errors.Wrap(err, "unable to save genesis root as initial backfill starting point for checkpoint sync")
+	}
+
 	cf, err := detect.FromState(serState)
 	if err != nil {
 		return errors.Wrap(err, "could not sniff config+fork for origin state bytes")
@@ -39,24 +50,11 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 	}
 	blk := wblk.Block()
 
+	// save block
 	blockRoot, err := blk.HashTreeRoot()
 	if err != nil {
 		return errors.Wrap(err, "could not compute HashTreeRoot of checkpoint block")
 	}
-
-	pr := blk.ParentRoot()
-	bf := &dbval.BackfillStatus{
-		LowSlot:       uint64(wblk.Block().Slot()),
-		LowRoot:       blockRoot[:],
-		LowParentRoot: pr[:],
-		OriginRoot:    blockRoot[:],
-		OriginSlot:    uint64(wblk.Block().Slot()),
-	}
-
-	if err = s.SaveBackfillStatus(ctx, bf); err != nil {
-		return errors.Wrap(err, "unable to save backfill status data to db for checkpoint sync")
-	}
-
 	log.Infof("saving checkpoint block to db, w/ root=%#x", blockRoot)
 	if err := s.SaveBlock(ctx, wblk); err != nil {
 		return errors.Wrap(err, "could not save checkpoint block")

beacon-chain/execution/engine_client.go

@@ -761,8 +761,8 @@ func fullPayloadFromExecutionBlock(
 				BlockHash:     blockHash[:],
 				Transactions:  txs,
 				Withdrawals:   block.Withdrawals,
-				BlobGasUsed:   bgu,
 				ExcessBlobGas: ebg,
+				BlobGasUsed:   bgu,
 			}, 0) // We can't get the block value and don't care about the block value for this instance
 	default:
 		return nil, fmt.Errorf("unknown execution block version %d", block.Version)
@@ -941,10 +941,10 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 			LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 			PrevRandao:    make([]byte, fieldparams.RootLength),
-			ExtraData:     make([]byte, 0),
 			BaseFeePerGas: make([]byte, fieldparams.RootLength),
 			BlockHash:     make([]byte, fieldparams.RootLength),
 			Transactions:  make([][]byte, 0),
+			ExtraData:     make([]byte, 0),
 		}, nil
 	case version.Capella:
 		return &pb.ExecutionPayloadCapella{
@@ -954,10 +954,10 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 			LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 			PrevRandao:    make([]byte, fieldparams.RootLength),
-			ExtraData:     make([]byte, 0),
 			BaseFeePerGas: make([]byte, fieldparams.RootLength),
 			BlockHash:     make([]byte, fieldparams.RootLength),
 			Transactions:  make([][]byte, 0),
+			ExtraData:     make([]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
 	case version.Deneb:
@@ -968,10 +968,10 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 			LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 			PrevRandao:    make([]byte, fieldparams.RootLength),
-			ExtraData:     make([]byte, 0),
 			BaseFeePerGas: make([]byte, fieldparams.RootLength),
 			BlockHash:     make([]byte, fieldparams.RootLength),
 			Transactions:  make([][]byte, 0),
+			ExtraData:     make([]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
 	default:

beacon-chain/execution/engine_client_fuzz_test.go

@@ -85,7 +85,7 @@ func FuzzExecutionPayload(f *testing.F) {
 			GasLimit:      math.MaxUint64,
 			GasUsed:       math.MaxUint64,
 			Timestamp:     100,
-			ExtraData:     []byte{},
+			ExtraData:     nil,
 			BaseFeePerGas: big.NewInt(math.MaxInt),
 			BlockHash:     common.Hash([32]byte{0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01}),
 			Transactions:  [][]byte{{0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01}, {0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01}, {0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01}, {0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01}},

beacon-chain/execution/log.go

@@ -2,4 +2,4 @@ package execution
 
 import "github.com/sirupsen/logrus"
 
-var log = logrus.WithField("prefix", "execution")
+var log = logrus.WithField("prefix", "powchain")

beacon-chain/forkchoice/doubly-linked-tree/store.go

@@ -240,20 +240,6 @@ func (f *ForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	return f.store.highestReceivedNode.slot
 }
 
-// HighestReceivedBlockSlotDelay returns the number of slots that the highest
-// received block was late when receiving it
-func (f *ForkChoice) HighestReceivedBlockDelay() primitives.Slot {
-	n := f.store.highestReceivedNode
-	if n == nil {
-		return 0
-	}
-	secs, err := slots.SecondsSinceSlotStart(n.slot, f.store.genesisTime, n.timestamp)
-	if err != nil {
-		return 0
-	}
-	return primitives.Slot(secs / params.BeaconConfig().SecondsPerSlot)
-}
-
 // ReceivedBlocksLastEpoch returns the number of blocks received in the last epoch
 func (f *ForkChoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	count := uint64(0)

beacon-chain/forkchoice/doubly-linked-tree/store_test.go

@@ -333,29 +333,26 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
 	require.Equal(t, primitives.Slot(1), f.HighestReceivedBlockSlot())
-	require.Equal(t, primitives.Slot(0), f.HighestReceivedBlockDelay())
 
 	// 64
 	// Received block last epoch is 1
 	_, err = s.insert(context.Background(), 64, [32]byte{'A'}, b, b, 1, 1)
 	require.NoError(t, err)
-	s.genesisTime = uint64(time.Now().Add(time.Duration((-64*int64(params.BeaconConfig().SecondsPerSlot))-1) * time.Second).Unix())
+	s.genesisTime = uint64(time.Now().Add(time.Duration(-64*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second).Unix())
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
 	require.Equal(t, primitives.Slot(64), f.HighestReceivedBlockSlot())
-	require.Equal(t, primitives.Slot(0), f.HighestReceivedBlockDelay())
 
 	// 64 65
 	// Received block last epoch is 2
 	_, err = s.insert(context.Background(), 65, [32]byte{'B'}, b, b, 1, 1)
 	require.NoError(t, err)
-	s.genesisTime = uint64(time.Now().Add(time.Duration(-66*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second).Unix())
+	s.genesisTime = uint64(time.Now().Add(time.Duration(-65*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second).Unix())
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(2), count)
 	require.Equal(t, primitives.Slot(65), f.HighestReceivedBlockSlot())
-	require.Equal(t, primitives.Slot(1), f.HighestReceivedBlockDelay())
 
 	// 64 65 66
 	// Received block last epoch is 3

beacon-chain/forkchoice/interfaces.go

@@ -64,7 +64,6 @@ type FastGetter interface {
 	FinalizedPayloadBlockHash() [32]byte
 	HasNode([32]byte) bool
 	HighestReceivedBlockSlot() primitives.Slot
-	HighestReceivedBlockDelay() primitives.Slot
 	IsCanonical(root [32]byte) bool
 	IsOptimistic(root [32]byte) (bool, error)
 	IsViableForCheckpoint(*forkchoicetypes.Checkpoint) (bool, error)

beacon-chain/forkchoice/ro.go

@@ -114,13 +114,6 @@ func (ro *ROForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	return ro.getter.HighestReceivedBlockSlot()
 }
 
-// HighestReceivedBlockDelay delegates to the underlying forkchoice call, under a lock.
-func (ro *ROForkChoice) HighestReceivedBlockDelay() primitives.Slot {
-	ro.l.RLock()
-	defer ro.l.RUnlock()
-	return ro.getter.HighestReceivedBlockDelay()
-}
-
 // ReceivedBlocksLastEpoch delegates to the underlying forkchoice call, under a lock.
 func (ro *ROForkChoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	ro.l.RLock()

beacon-chain/forkchoice/ro_test.go

@@ -29,7 +29,6 @@ const (
 	unrealizedJustifiedPayloadBlockHashCalled
 	nodeCountCalled
 	highestReceivedBlockSlotCalled
-	highestReceivedBlockDelayCalled
 	receivedBlocksLastEpochCalled
 	weightCalled
 	isOptimisticCalled
@@ -114,11 +113,6 @@ func TestROLocking(t *testing.T) {
 			call: highestReceivedBlockSlotCalled,
 			cb:   func(g FastGetter) { g.HighestReceivedBlockSlot() },
 		},
-		{
-			name: "highestReceivedBlockDelayCalled",
-			call: highestReceivedBlockDelayCalled,
-			cb:   func(g FastGetter) { g.HighestReceivedBlockDelay() },
-		},
 		{
 			name: "receivedBlocksLastEpochCalled",
 			call: receivedBlocksLastEpochCalled,
@@ -251,11 +245,6 @@ func (ro *mockROForkchoice) HighestReceivedBlockSlot() primitives.Slot {
 	return 0
 }
 
-func (ro *mockROForkchoice) HighestReceivedBlockDelay() primitives.Slot {
-	ro.calls = append(ro.calls, highestReceivedBlockDelayCalled)
-	return 0
-}
-
 func (ro *mockROForkchoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	ro.calls = append(ro.calls, receivedBlocksLastEpochCalled)
 	return 0, nil

beacon-chain/gateway/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/gateway",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//api:go_default_library",
         "//api/gateway:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/gateway/helpers.go

@@ -2,7 +2,6 @@ package gateway
 
 import (
 	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"github.com/prysmaticlabs/prysm/v4/api"
 	"github.com/prysmaticlabs/prysm/v4/api/gateway"
 	"github.com/prysmaticlabs/prysm/v4/cmd/beacon-chain/flags"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
@@ -41,7 +40,7 @@ func DefaultConfig(enableDebugRPCEndpoints bool, httpModules string) MuxConfig {
 				},
 			}),
 			gwruntime.WithMarshalerOption(
-				api.EventStreamMediaType, &gwruntime.EventSourceJSONPb{},
+				"text/event-stream", &gwruntime.EventSourceJSONPb{},
 			),
 		)
 		v1AlphaPbHandler = &gateway.PbMux{

beacon-chain/node/BUILD.bazel

@@ -40,7 +40,6 @@ go_library(
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
-        "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/rpc:go_default_library",
         "//beacon-chain/slasher:go_default_library",
         "//beacon-chain/startup:go_default_library",
@@ -48,7 +47,6 @@ go_library(
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
         "//beacon-chain/sync/backfill:go_default_library",
-        "//beacon-chain/sync/backfill/coverage:go_default_library",
         "//beacon-chain/sync/checkpoint:go_default_library",
         "//beacon-chain/sync/genesis:go_default_library",
         "//beacon-chain/sync/initial-sync:go_default_library",

beacon-chain/node/node.go

@@ -42,7 +42,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/operations/synccommittee"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/peers"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/slasher"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/startup"
@@ -50,7 +49,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state/stategen"
 	regularsync "github.com/prysmaticlabs/prysm/v4/beacon-chain/sync"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/sync/backfill"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/sync/backfill/coverage"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/sync/checkpoint"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/sync/genesis"
 	initialsync "github.com/prysmaticlabs/prysm/v4/beacon-chain/sync/initial-sync"
@@ -115,7 +113,6 @@ type BeaconNode struct {
 	CheckpointInitializer   checkpoint.Initializer
 	forkChoicer             forkchoice.ForkChoicer
 	clockWaiter             startup.ClockWaiter
-	BackfillOpts            []backfill.ServiceOption
 	initialSyncComplete     chan struct{}
 	BlobStorage             *filesystem.BlobStorage
 	blobRetentionEpochs     primitives.Epoch
@@ -218,23 +215,10 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		return nil, err
 	}
 
-	log.Debugln("Registering P2P Service")
-	if err := beacon.registerP2P(cliCtx); err != nil {
-		return nil, err
-	}
-
-	bfs, err := backfill.NewUpdater(ctx, beacon.db)
-	if err != nil {
+	bfs := backfill.NewStatus(beacon.db)
+	if err := bfs.Reload(ctx); err != nil {
 		return nil, errors.Wrap(err, "backfill status initialization error")
 	}
-	pa := peers.NewAssigner(beacon.fetchP2P().Peers(), beacon.forkChoicer)
-	bf, err := backfill.NewService(ctx, bfs, beacon.clockWaiter, beacon.fetchP2P(), pa, beacon.BackfillOpts...)
-	if err != nil {
-		return nil, errors.Wrap(err, "error initializing backfill service")
-	}
-	if err := beacon.services.RegisterService(bf); err != nil {
-		return nil, errors.Wrap(err, "error registering backfill service")
-	}
 
 	log.Debugln("Starting State Gen")
 	if err := beacon.startStateGen(ctx, bfs, beacon.forkChoicer); err != nil {
@@ -249,6 +233,11 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	beacon.verifyInitWaiter = verification.NewInitializerWaiter(
 		beacon.clockWaiter, forkchoice.NewROForkChoice(beacon.forkChoicer), beacon.stateGen)
 
+	log.Debugln("Registering P2P Service")
+	if err := beacon.registerP2P(cliCtx); err != nil {
+		return nil, err
+	}
+
 	log.Debugln("Registering POW Chain Service")
 	if err := beacon.registerPOWChainService(); err != nil {
 		return nil, err
@@ -545,8 +534,8 @@ func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context) error {
 	return nil
 }
 
-func (b *BeaconNode) startStateGen(ctx context.Context, bfs coverage.AvailableBlocker, fc forkchoice.ForkChoicer) error {
-	opts := []stategen.Option{stategen.WithAvailableBlocker(bfs)}
+func (b *BeaconNode) startStateGen(ctx context.Context, bfs *backfill.Status, fc forkchoice.ForkChoicer) error {
+	opts := []stategen.Option{stategen.WithBackfillStatus(bfs)}
 	sg := stategen.New(b.db, fc, opts...)
 
 	cp, err := b.db.FinalizedCheckpoint(ctx)

beacon-chain/operations/attestations/prepare_forkchoice.go

@@ -42,7 +42,7 @@ func (s *Service) prepareForkChoiceAtts() {
 			switch slotInterval.Interval {
 			case 0:
 				duration := time.Since(t)
-				log.WithField("Duration", duration).Debug("Aggregated unaggregated attestations")
+				log.WithField("Duration", duration).Debug("aggregated unaggregated attestations")
 				batchForkChoiceAttsT1.Observe(float64(duration.Milliseconds()))
 			case 1:
 				batchForkChoiceAttsT2.Observe(float64(time.Since(t).Milliseconds()))

beacon-chain/p2p/message_id.go

@@ -83,7 +83,7 @@ func postAltairMsgID(pmsg *pubsubpb.Message, fEpoch primitives.Epoch) string {
 	decodedData, err := encoder.DecodeSnappy(pmsg.Data, gossipPubSubSize)
 	if err != nil {
 		totalLength, err := math.AddInt(
-			len(params.BeaconConfig().MessageDomainInvalidSnappy),
+			len(params.BeaconConfig().MessageDomainValidSnappy),
 			len(topicLenBytes),
 			topicLen,
 			len(pmsg.Data),

beacon-chain/p2p/peers/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "assigner.go",
         "log.go",
         "status.go",
     ],
@@ -13,10 +12,8 @@ go_library(
         "//cmd:__subpackages__",
     ],
     deps = [
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -31,7 +28,6 @@ go_library(
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_multiformats_go_multiaddr//:go_default_library",
         "@com_github_multiformats_go_multiaddr//net:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -40,7 +36,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "assigner_test.go",
         "benchmark_test.go",
         "peers_test.go",
         "status_test.go",

beacon-chain/p2p/peers/assigner.go

@@ -1,78 +0,0 @@
-package peers
-
-import (
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/pkg/errors"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
-	"github.com/prysmaticlabs/prysm/v4/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v4/config/params"
-	"github.com/sirupsen/logrus"
-)
-
-// FinalizedCheckpointer describes the minimum capability that Assigner needs from forkchoice.
-// That is, the ability to retrieve the latest finalized checkpoint to help with peer evaluation.
-type FinalizedCheckpointer interface {
-	FinalizedCheckpoint() *forkchoicetypes.Checkpoint
-}
-
-// NewAssigner assists in the correct construction of an Assigner by code in other packages,
-// assuring all the important private member fields are given values.
-// The FinalizedCheckpointer is used to retrieve the latest finalized checkpoint each time peers are requested.
-// Peers that report an older finalized checkpoint are filtered out.
-func NewAssigner(s *Status, fc FinalizedCheckpointer) *Assigner {
-	return &Assigner{
-		ps: s,
-		fc: fc,
-	}
-}
-
-// Assigner uses the "BestFinalized" peer scoring method to pick the next-best peer to receive rpc requests.
-type Assigner struct {
-	ps *Status
-	fc FinalizedCheckpointer
-}
-
-// ErrInsufficientSuitable is a sentinel error, signaling that a peer couldn't be assigned because there are currently
-// not enough peers that match our selection criteria to serve rpc requests. It is the responsibility of the caller to
-// look for this error and continue to try calling Assign with appropriate backoff logic.
-var ErrInsufficientSuitable = errors.New("no suitable peers")
-
-func (a *Assigner) freshPeers() ([]peer.ID, error) {
-	required := params.BeaconConfig().MaxPeersToSync
-	if flags.Get().MinimumSyncPeers < required {
-		required = flags.Get().MinimumSyncPeers
-	}
-	_, peers := a.ps.BestFinalized(params.BeaconConfig().MaxPeersToSync, a.fc.FinalizedCheckpoint().Epoch)
-	if len(peers) < required {
-		log.WithFields(logrus.Fields{
-			"suitable": len(peers),
-			"required": required}).Warn("Unable to assign peer while suitable peers < required ")
-		return nil, ErrInsufficientSuitable
-	}
-	return peers, nil
-}
-
-// Assign uses the "BestFinalized" method to select the best peers that agree on a canonical block
-// for the configured finalized epoch. At most `n` peers will be returned. The `busy` param can be used
-// to filter out peers that we know we don't want to connect to, for instance if we are trying to limit
-// the number of outbound requests to each peer from a given component.
-func (a *Assigner) Assign(busy map[peer.ID]bool, n int) ([]peer.ID, error) {
-	best, err := a.freshPeers()
-	if err != nil {
-		return nil, err
-	}
-	return pickBest(busy, n, best), nil
-}
-
-func pickBest(busy map[peer.ID]bool, n int, best []peer.ID) []peer.ID {
-	ps := make([]peer.ID, 0, n)
-	for _, p := range best {
-		if len(ps) == n {
-			return ps
-		}
-		if !busy[p] {
-			ps = append(ps, p)
-		}
-	}
-	return ps
-}

beacon-chain/p2p/peers/assigner_test.go

@@ -1,114 +0,0 @@
-package peers
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/prysmaticlabs/prysm/v4/testing/require"
-)
-
-func TestPickBest(t *testing.T) {
-	best := testPeerIds(10)
-	cases := []struct {
-		name     string
-		busy     map[peer.ID]bool
-		n        int
-		best     []peer.ID
-		expected []peer.ID
-	}{
-		{
-			name: "",
-			n:    0,
-		},
-		{
-			name:     "none busy",
-			n:        1,
-			expected: best[0:1],
-		},
-		{
-			name:     "all busy except last",
-			n:        1,
-			busy:     testBusyMap(best[0 : len(best)-1]),
-			expected: best[len(best)-1:],
-		},
-		{
-			name:     "all busy except i=5",
-			n:        1,
-			busy:     testBusyMap(append(append([]peer.ID{}, best[0:5]...), best[6:]...)),
-			expected: []peer.ID{best[5]},
-		},
-		{
-			name: "all busy - 0 results",
-			n:    1,
-			busy: testBusyMap(best),
-		},
-		{
-			name:     "first half busy",
-			n:        5,
-			busy:     testBusyMap(best[0:5]),
-			expected: best[5:],
-		},
-		{
-			name:     "back half busy",
-			n:        5,
-			busy:     testBusyMap(best[5:]),
-			expected: best[0:5],
-		},
-		{
-			name:     "pick all ",
-			n:        10,
-			expected: best,
-		},
-		{
-			name: "none available",
-			n:    10,
-			best: []peer.ID{},
-		},
-		{
-			name:     "not enough",
-			n:        10,
-			best:     best[0:1],
-			expected: best[0:1],
-		},
-		{
-			name:     "not enough, some busy",
-			n:        10,
-			best:     best[0:6],
-			busy:     testBusyMap(best[0:5]),
-			expected: best[5:6],
-		},
-	}
-	for _, c := range cases {
-		name := fmt.Sprintf("n=%d", c.n)
-		if c.name != "" {
-			name += " " + c.name
-		}
-		t.Run(name, func(t *testing.T) {
-			if c.best == nil {
-				c.best = best
-			}
-			pb := pickBest(c.busy, c.n, c.best)
-			require.Equal(t, len(c.expected), len(pb))
-			for i := range c.expected {
-				require.Equal(t, c.expected[i], pb[i])
-			}
-		})
-	}
-}
-
-func testBusyMap(b []peer.ID) map[peer.ID]bool {
-	m := make(map[peer.ID]bool)
-	for i := range b {
-		m[b[i]] = true
-	}
-	return m
-}
-
-func testPeerIds(n int) []peer.ID {
-	pids := make([]peer.ID, n)
-	for i := range pids {
-		pids[i] = peer.ID(fmt.Sprintf("%d", i))
-	}
-	return pids
-}

beacon-chain/rpc/core/BUILD.bazel

@@ -38,7 +38,6 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],

beacon-chain/rpc/core/service.go

@@ -11,15 +11,14 @@ import (
 )
 
 type Service struct {
-	HeadFetcher           blockchain.HeadFetcher
-	FinalizedFetcher      blockchain.FinalizationFetcher
-	GenesisTimeFetcher    blockchain.TimeFetcher
-	SyncChecker           sync.Checker
-	Broadcaster           p2p.Broadcaster
-	SyncCommitteePool     synccommittee.Pool
-	OperationNotifier     opfeed.Notifier
-	AttestationCache      *cache.AttestationCache
-	StateGen              stategen.StateManager
-	P2P                   p2p.Broadcaster
-	OptimisticModeFetcher blockchain.OptimisticModeFetcher
+	HeadFetcher        blockchain.HeadFetcher
+	FinalizedFetcher   blockchain.FinalizationFetcher
+	GenesisTimeFetcher blockchain.TimeFetcher
+	SyncChecker        sync.Checker
+	Broadcaster        p2p.Broadcaster
+	SyncCommitteePool  synccommittee.Pool
+	OperationNotifier  opfeed.Notifier
+	AttestationCache   *cache.AttestationCache
+	StateGen           stategen.StateManager
+	P2P                p2p.Broadcaster
 }

beacon-chain/rpc/core/validator.go

@@ -29,12 +29,9 @@ import (
 	prysmTime "github.com/prysmaticlabs/prysm/v4/time"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
 )
 
-var errOptimisticMode = errors.New("the node is currently optimistic and cannot serve validators")
-
 // AggregateBroadcastFailedError represents an error scenario where
 // broadcasting an aggregate selection proof failed.
 type AggregateBroadcastFailedError struct {
@@ -59,9 +56,6 @@ func (s *Service) ComputeValidatorPerformance(
 	ctx context.Context,
 	req *ethpb.ValidatorPerformanceRequest,
 ) (*ethpb.ValidatorPerformanceResponse, *RpcError) {
-	ctx, span := trace.StartSpan(ctx, "coreService.ComputeValidatorPerformance")
-	defer span.End()
-
 	if s.SyncChecker.Syncing() {
 		return nil, &RpcError{Reason: Unavailable, Err: errors.New("Syncing to latest head, not ready to respond")}
 	}
@@ -217,9 +211,6 @@ func (s *Service) SubmitSignedContributionAndProof(
 	ctx context.Context,
 	req *ethpb.SignedContributionAndProof,
 ) *RpcError {
-	ctx, span := trace.StartSpan(ctx, "coreService.SubmitSignedContributionAndProof")
-	defer span.End()
-
 	errs, ctx := errgroup.WithContext(ctx)
 
 	// Broadcasting and saving contribution into the pool in parallel. As one fail should not affect another.
@@ -252,9 +243,6 @@ func (s *Service) SubmitSignedAggregateSelectionProof(
 	ctx context.Context,
 	req *ethpb.SignedAggregateSubmitRequest,
 ) *RpcError {
-	ctx, span := trace.StartSpan(ctx, "coreService.SubmitSignedAggregateSelectionProof")
-	defer span.End()
-
 	if req.SignedAggregateAndProof == nil || req.SignedAggregateAndProof.Message == nil ||
 		req.SignedAggregateAndProof.Message.Aggregate == nil || req.SignedAggregateAndProof.Message.Aggregate.Data == nil {
 		return &RpcError{Err: errors.New("signed aggregate request can't be nil"), Reason: BadRequest}
@@ -327,9 +315,6 @@ func (s *Service) AggregatedSigAndAggregationBits(
 func (s *Service) GetAttestationData(
 	ctx context.Context, req *ethpb.AttestationDataRequest,
 ) (*ethpb.AttestationData, *RpcError) {
-	ctx, span := trace.StartSpan(ctx, "coreService.GetAttestationData")
-	defer span.End()
-
 	if req.Slot != s.GenesisTimeFetcher.CurrentSlot() {
 		return nil, &RpcError{Reason: BadRequest, Err: errors.Errorf("invalid request: slot %d is not the current slot %d", req.Slot, s.GenesisTimeFetcher.CurrentSlot())}
 	}
@@ -383,14 +368,6 @@ func (s *Service) GetAttestationData(
 			},
 		}, nil
 	}
-	// cache miss, we need to check for optimistic status before proceeding
-	optimistic, err := s.OptimisticModeFetcher.IsOptimistic(ctx)
-	if err != nil {
-		return nil, &RpcError{Reason: Internal, Err: err}
-	}
-	if optimistic {
-		return nil, &RpcError{Reason: Unavailable, Err: errOptimisticMode}
-	}
 
 	headRoot, err := s.HeadFetcher.HeadRoot(ctx)
 	if err != nil {
@@ -435,9 +412,6 @@ func (s *Service) GetAttestationData(
 // SubmitSyncMessage submits the sync committee message to the network.
 // It also saves the sync committee message into the pending pool for block inclusion.
 func (s *Service) SubmitSyncMessage(ctx context.Context, msg *ethpb.SyncCommitteeMessage) *RpcError {
-	ctx, span := trace.StartSpan(ctx, "coreService.SubmitSyncMessage")
-	defer span.End()
-
 	errs, ctx := errgroup.WithContext(ctx)
 
 	headSyncCommitteeIndices, err := s.HeadFetcher.HeadSyncCommitteeIndices(ctx, msg.ValidatorIndex, msg.Slot)

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

@@ -62,7 +62,7 @@ func (s *Server) GetBlock(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if httputil.RespondWithSsz(r) {
+	if httputil.SszRequested(r) {
 		s.getBlockSSZ(ctx, w, blk)
 	} else {
 		s.getBlock(ctx, w, blk)
@@ -105,7 +105,7 @@ func (s *Server) GetBlockV2(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if httputil.RespondWithSsz(r) {
+	if httputil.SszRequested(r) {
 		s.getBlockSSZV2(ctx, w, blk)
 	} else {
 		s.getBlockV2(ctx, w, blk)
@@ -205,7 +205,7 @@ func (s *Server) GetBlindedBlock(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if httputil.RespondWithSsz(r) {
+	if httputil.SszRequested(r) {
 		s.getBlindedBlockSSZ(ctx, w, blk)
 	} else {
 		s.getBlindedBlock(ctx, w, blk)
@@ -953,7 +953,8 @@ func (s *Server) PublishBlindedBlock(w http.ResponseWriter, r *http.Request) {
 	if shared.IsSyncing(r.Context(), w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
 		return
 	}
-	if httputil.IsRequestSsz(r) {
+	isSSZ := httputil.SszRequested(r)
+	if isSSZ {
 		s.publishBlindedBlockSSZ(ctx, w, r, false)
 	} else {
 		s.publishBlindedBlock(ctx, w, r, false)
@@ -977,7 +978,8 @@ func (s *Server) PublishBlindedBlockV2(w http.ResponseWriter, r *http.Request) {
 	if shared.IsSyncing(r.Context(), w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
 		return
 	}
-	if httputil.IsRequestSsz(r) {
+	isSSZ := httputil.SszRequested(r)
+	if isSSZ {
 		s.publishBlindedBlockSSZ(ctx, w, r, true)
 	} else {
 		s.publishBlindedBlock(ctx, w, r, true)
@@ -1248,7 +1250,8 @@ func (s *Server) PublishBlock(w http.ResponseWriter, r *http.Request) {
 	if shared.IsSyncing(r.Context(), w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
 		return
 	}
-	if httputil.IsRequestSsz(r) {
+	isSSZ := httputil.SszRequested(r)
+	if isSSZ {
 		s.publishBlockSSZ(ctx, w, r, false)
 	} else {
 		s.publishBlock(ctx, w, r, false)
@@ -1270,7 +1273,8 @@ func (s *Server) PublishBlockV2(w http.ResponseWriter, r *http.Request) {
 	if shared.IsSyncing(r.Context(), w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
 		return
 	}
-	if httputil.IsRequestSsz(r) {
+	isSSZ := httputil.SszRequested(r)
+	if isSSZ {
 		s.publishBlockSSZ(ctx, w, r, true)
 	} else {
 		s.publishBlock(ctx, w, r, true)

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

@@ -1169,7 +1169,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetPhase0().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Phase0))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1199,7 +1199,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetAltair().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Altair))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1224,7 +1224,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1250,7 +1250,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetCapella().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1276,7 +1276,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetDeneb().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Deneb))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1296,7 +1296,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1317,7 +1317,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1335,7 +1335,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte("foo")))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
@@ -1531,7 +1531,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetPhase0().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Phase0))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1561,7 +1561,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetAltair().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Altair))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1587,7 +1587,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1613,7 +1613,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedCapella().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1639,7 +1639,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedDeneb().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Deneb))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1672,7 +1672,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1690,7 +1690,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte("foo")))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
@@ -1899,7 +1899,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetPhase0().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Phase0))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1929,7 +1929,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetAltair().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Altair))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1954,7 +1954,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -1980,7 +1980,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetCapella().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2006,7 +2006,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetDeneb().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Deneb))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2026,7 +2026,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2047,7 +2047,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2061,7 +2061,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.CapellaBlock)))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
@@ -2078,7 +2078,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte("foo")))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
@@ -2286,7 +2286,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetPhase0().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Phase0))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2316,7 +2316,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetAltair().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Altair))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2342,7 +2342,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Bellatrix))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2368,7 +2368,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedCapella().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2394,7 +2394,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedDeneb().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Deneb))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2427,7 +2427,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		ssz, err := genericBlock.GetBlindedBellatrix().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		request.Header.Set(api.VersionHeader, version.String(version.Capella))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2441,7 +2441,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedCapellaBlock)))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
@@ -2458,7 +2458,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		}
 
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte("foo")))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlockV2(writer, request)

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

@@ -46,7 +46,8 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	for i := range verifiedBlobs {
 		sidecars = append(sidecars, verifiedBlobs[i].BlobSidecar)
 	}
-	if httputil.RespondWithSsz(r) {
+	ssz := httputil.SszRequested(r)
+	if ssz {
 		sidecarResp := &eth.BlobSidecars{
 			Sidecars: sidecars,
 		}

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

@@ -12,5 +12,5 @@ type Sidecar struct {
 	SignedBeaconBlockHeader  *shared.SignedBeaconBlockHeader `json:"signed_block_header"`
 	KzgCommitment            string                          `json:"kzg_commitment"`
 	KzgProof                 string                          `json:"kzg_proof"`
-	CommitmentInclusionProof []string                        `json:"kzg_commitment_inclusion_proof"`
+	CommitmentInclusionProof []string                        `json:"commitment_inclusion_proof"`
 }

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

@@ -54,7 +54,7 @@ func (s *Server) GetBeaconStateV2(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if httputil.RespondWithSsz(r) {
+	if httputil.SszRequested(r) {
 		s.getBeaconStateSSZV2(ctx, w, []byte(stateId))
 	} else {
 		s.getBeaconStateV2(ctx, w, []byte(stateId))

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

@@ -471,7 +471,7 @@ func TestGetForkChoice(t *testing.T) {
 	require.NoError(t, store.UpdateFinalizedCheckpoint(fc))
 	s := &Server{ForkchoiceFetcher: &blockchainmock.ChainService{ForkChoiceStore: store}}
 
-	request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/debug/fork_choice", nil)
+	request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/fork_choice", nil)
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 

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

@@ -8,9 +8,8 @@ go_library(
         "structs.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/events",
-    visibility = ["//visibility:public"],
+    visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//api:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
@@ -19,10 +18,8 @@ go_library(
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
-        "//config/params:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

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

@@ -5,10 +5,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	time2 "time"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/prysmaticlabs/prysm/v4/api"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/operation"
@@ -17,10 +15,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared"
-	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	log "github.com/sirupsen/logrus"
@@ -52,10 +48,6 @@ const (
 	ProposerSlashingTopic = "proposer_slashing"
 	// AttesterSlashingTopic represents a new attester slashing event topic
 	AttesterSlashingTopic = "attester_slashing"
-	// LightClientFinalityUpdateTopic represents a new light client finality update event topic.
-	LightClientFinalityUpdateTopic = "light_client_finality_update"
-	// LightClientOptimisticUpdateTopic represents a new light client optimistic update event topic.
-	LightClientOptimisticUpdateTopic = "light_client_optimistic_update"
 )
 
 const topicDataMismatch = "Event data type %T does not correspond to event topic %s"
@@ -63,20 +55,18 @@ const topicDataMismatch = "Event data type %T does not correspond to event topic
 const chanBuffer = 1000
 
 var casesHandled = map[string]bool{
-	HeadTopic:                        true,
-	BlockTopic:                       true,
-	AttestationTopic:                 true,
-	VoluntaryExitTopic:               true,
-	FinalizedCheckpointTopic:         true,
-	ChainReorgTopic:                  true,
-	SyncCommitteeContributionTopic:   true,
-	BLSToExecutionChangeTopic:        true,
-	PayloadAttributesTopic:           true,
-	BlobSidecarTopic:                 true,
-	ProposerSlashingTopic:            true,
-	AttesterSlashingTopic:            true,
-	LightClientFinalityUpdateTopic:   true,
-	LightClientOptimisticUpdateTopic: true,
+	HeadTopic:                      true,
+	BlockTopic:                     true,
+	AttestationTopic:               true,
+	VoluntaryExitTopic:             true,
+	FinalizedCheckpointTopic:       true,
+	ChainReorgTopic:                true,
+	SyncCommitteeContributionTopic: true,
+	BLSToExecutionChangeTopic:      true,
+	PayloadAttributesTopic:         true,
+	BlobSidecarTopic:               true,
+	ProposerSlashingTopic:          true,
+	AttesterSlashingTopic:          true,
 }
 
 // StreamEvents provides an endpoint to subscribe to the beacon node Server-Sent-Events stream.
@@ -116,24 +106,16 @@ func (s *Server) StreamEvents(w http.ResponseWriter, r *http.Request) {
 	defer stateSub.Unsubscribe()
 
 	// Set up SSE response headers
-	w.Header().Set("Content-Type", api.EventStreamMediaType)
-	w.Header().Set("Connection", api.KeepAlive)
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Connection", "keep-alive")
 
 	// Handle each event received and context cancellation.
-	// We send a keepalive dummy message immediately to prevent clients
-	// stalling while waiting for the first response chunk.
-	// After that we send a keepalive dummy message every SECONDS_PER_SLOT
-	// to prevent anyone (e.g. proxy servers) from closing connections.
-	sendKeepalive(w, flusher)
-	keepaliveTicker := time2.NewTicker(time2.Duration(params.BeaconConfig().SecondsPerSlot) * time2.Second)
 	for {
 		select {
 		case event := <-opsChan:
 			handleBlockOperationEvents(w, flusher, topicsMap, event)
 		case event := <-stateChan:
 			s.handleStateEvents(ctx, w, flusher, topicsMap, event)
-		case <-keepaliveTicker.C:
-			sendKeepalive(w, flusher)
 		case <-ctx.Done():
 			return
 		}
@@ -280,72 +262,6 @@ func (s *Server) handleStateEvents(ctx context.Context, w http.ResponseWriter, f
 			ExecutionOptimistic: checkpointData.ExecutionOptimistic,
 		}
 		send(w, flusher, FinalizedCheckpointTopic, checkpoint)
-	case statefeed.LightClientFinalityUpdate:
-		if _, ok := requestedTopics[LightClientFinalityUpdateTopic]; !ok {
-			return
-		}
-		updateData, ok := event.Data.(*ethpbv2.LightClientFinalityUpdateWithVersion)
-		if !ok {
-			write(w, flusher, topicDataMismatch, event.Data, LightClientFinalityUpdateTopic)
-			return
-		}
-
-		var finalityBranch []string
-		for _, b := range updateData.Data.FinalityBranch {
-			finalityBranch = append(finalityBranch, hexutil.Encode(b))
-		}
-		update := &LightClientFinalityUpdateEvent{
-			Version: version.String(int(updateData.Version)),
-			Data: &LightClientFinalityUpdate{
-				AttestedHeader: &shared.BeaconBlockHeader{
-					Slot:          fmt.Sprintf("%d", updateData.Data.AttestedHeader.Slot),
-					ProposerIndex: fmt.Sprintf("%d", updateData.Data.AttestedHeader.ProposerIndex),
-					ParentRoot:    hexutil.Encode(updateData.Data.AttestedHeader.ParentRoot),
-					StateRoot:     hexutil.Encode(updateData.Data.AttestedHeader.StateRoot),
-					BodyRoot:      hexutil.Encode(updateData.Data.AttestedHeader.BodyRoot),
-				},
-				FinalizedHeader: &shared.BeaconBlockHeader{
-					Slot:          fmt.Sprintf("%d", updateData.Data.FinalizedHeader.Slot),
-					ProposerIndex: fmt.Sprintf("%d", updateData.Data.FinalizedHeader.ProposerIndex),
-					ParentRoot:    hexutil.Encode(updateData.Data.FinalizedHeader.ParentRoot),
-					StateRoot:     hexutil.Encode(updateData.Data.FinalizedHeader.StateRoot),
-				},
-				FinalityBranch: finalityBranch,
-				SyncAggregate: &shared.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeSignature),
-				},
-				SignatureSlot: fmt.Sprintf("%d", updateData.Data.SignatureSlot),
-			},
-		}
-		send(w, flusher, LightClientFinalityUpdateTopic, update)
-	case statefeed.LightClientOptimisticUpdate:
-		if _, ok := requestedTopics[LightClientOptimisticUpdateTopic]; !ok {
-			return
-		}
-		updateData, ok := event.Data.(*ethpbv2.LightClientOptimisticUpdateWithVersion)
-		if !ok {
-			write(w, flusher, topicDataMismatch, event.Data, LightClientOptimisticUpdateTopic)
-			return
-		}
-		update := &LightClientOptimisticUpdateEvent{
-			Version: version.String(int(updateData.Version)),
-			Data: &LightClientOptimisticUpdate{
-				AttestedHeader: &shared.BeaconBlockHeader{
-					Slot:          fmt.Sprintf("%d", updateData.Data.AttestedHeader.Slot),
-					ProposerIndex: fmt.Sprintf("%d", updateData.Data.AttestedHeader.ProposerIndex),
-					ParentRoot:    hexutil.Encode(updateData.Data.AttestedHeader.ParentRoot),
-					StateRoot:     hexutil.Encode(updateData.Data.AttestedHeader.StateRoot),
-					BodyRoot:      hexutil.Encode(updateData.Data.AttestedHeader.BodyRoot),
-				},
-				SyncAggregate: &shared.SyncAggregate{
-					SyncCommitteeBits:      hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeBits),
-					SyncCommitteeSignature: hexutil.Encode(updateData.Data.SyncAggregate.SyncCommitteeSignature),
-				},
-				SignatureSlot: fmt.Sprintf("%d", updateData.Data.SignatureSlot),
-			},
-		}
-		send(w, flusher, LightClientOptimisticUpdateTopic, update)
 	case statefeed.Reorg:
 		if _, ok := requestedTopics[ChainReorgTopic]; !ok {
 			return
@@ -515,10 +431,6 @@ func send(w http.ResponseWriter, flusher http.Flusher, name string, data interfa
 	write(w, flusher, "event: %s\ndata: %s\n\n", name, string(j))
 }
 
-func sendKeepalive(w http.ResponseWriter, flusher http.Flusher) {
-	write(w, flusher, ":\n\n")
-}
-
 func write(w http.ResponseWriter, flusher http.Flusher, format string, a ...any) {
 	_, err := fmt.Fprintf(w, format, a...)
 	if err != nil {

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

@@ -375,9 +375,7 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 	})
 }
 
-const operationsResult = `:
-
-event: attestation
+const operationsResult = `event: attestation
 data: {"aggregation_bits":"0x00","data":{"slot":"0","index":"0","beacon_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","source":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"target":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"}},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
 
 event: attestation
@@ -403,9 +401,7 @@ data: {"signed_header_1":{"message":{"slot":"0","proposer_index":"0","parent_roo
 
 `
 
-const stateResult = `:
-
-event: head
+const stateResult = `event: head
 data: {"slot":"0","block":"0x0000000000000000000000000000000000000000000000000000000000000000","state":"0x0000000000000000000000000000000000000000000000000000000000000000","epoch_transition":true,"execution_optimistic":false,"previous_duty_dependent_root":"0x0000000000000000000000000000000000000000000000000000000000000000","current_duty_dependent_root":"0x0000000000000000000000000000000000000000000000000000000000000000"}
 
 event: finalized_checkpoint
@@ -419,23 +415,17 @@ data: {"slot":"0","block":"0xeade62f0457b2fdf48e7d3fc4b60736688286be7c7a3ac4c9a1
 
 `
 
-const payloadAttributesBellatrixResult = `:
-
-event: payload_attributes
+const payloadAttributesBellatrixResult = `event: payload_attributes
 data: {"version":"bellatrix","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0x0000000000000000000000000000000000000000"}}}
 
 `
 
-const payloadAttributesCapellaResult = `:
-
-event: payload_attributes
+const payloadAttributesCapellaResult = `event: payload_attributes
 data: {"version":"capella","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0x0000000000000000000000000000000000000000","withdrawals":[]}}}
 
 `
 
-const payloadAttributesDenebResult = `:
-
-event: payload_attributes
+const payloadAttributesDenebResult = `event: payload_attributes
 data: {"version":"deneb","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0x0000000000000000000000000000000000000000","withdrawals":[],"parent_beacon_block_root":"0xbef96cb938fd48b2403d3e662664325abb0102ed12737cbb80d717520e50cf4a"}}}
 
 `

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

@@ -92,27 +92,3 @@ type BlobSidecarEvent struct {
 	KzgCommitment string `json:"kzg_commitment"`
 	VersionedHash string `json:"versioned_hash"`
 }
-
-type LightClientFinalityUpdateEvent struct {
-	Version string                     `json:"version"`
-	Data    *LightClientFinalityUpdate `json:"data"`
-}
-
-type LightClientFinalityUpdate struct {
-	AttestedHeader  *shared.BeaconBlockHeader `json:"attested_header"`
-	FinalizedHeader *shared.BeaconBlockHeader `json:"finalized_header"`
-	FinalityBranch  []string                  `json:"finality_branch"`
-	SyncAggregate   *shared.SyncAggregate     `json:"sync_aggregate"`
-	SignatureSlot   string                    `json:"signature_slot"`
-}
-
-type LightClientOptimisticUpdateEvent struct {
-	Version string                       `json:"version"`
-	Data    *LightClientOptimisticUpdate `json:"data"`
-}
-
-type LightClientOptimisticUpdate struct {
-	AttestedHeader *shared.BeaconBlockHeader `json:"attested_header"`
-	SyncAggregate  *shared.SyncAggregate     `json:"sync_aggregate"`
-	SignatureSlot  string                    `json:"signature_slot"`
-}

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

@@ -8,9 +8,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/gorilla/mux"
-	"go.opencensus.io/trace"
-
 	"github.com/wealdtech/go-bytesutil"
+	"go.opencensus.io/trace"
 
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
@@ -220,7 +219,11 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 		return
 	}
 
-	httputil.WriteJson(w, updates)
+	response := &LightClientUpdatesByRangeResponse{
+		Updates: updates,
+	}
+
+	httputil.WriteJson(w, response)
 }
 
 // GetLightClientFinalityUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/finality_update.yaml

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

@@ -171,12 +171,12 @@ func TestLightClientHandler_GetLightClientUpdatesByRange(t *testing.T) {
 	s.GetLightClientUpdatesByRange(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp []LightClientUpdateWithVersion
-	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
-	require.Equal(t, 1, len(resp))
-	require.Equal(t, "capella", resp[0].Version)
-	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp[0].Data.AttestedHeader.BodyRoot)
-	require.NotNil(t, resp)
+	resp := &LightClientUpdatesByRangeResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, 1, len(resp.Updates))
+	require.Equal(t, "capella", resp.Updates[0].Version)
+	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp.Updates[0].Data.AttestedHeader.BodyRoot)
+	require.NotNil(t, resp.Updates)
 }
 
 func TestLightClientHandler_GetLightClientUpdatesByRange_TooBigInputCount(t *testing.T) {
@@ -274,12 +274,12 @@ func TestLightClientHandler_GetLightClientUpdatesByRange_TooBigInputCount(t *tes
 	s.GetLightClientUpdatesByRange(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp []LightClientUpdateWithVersion
-	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
-	require.Equal(t, 1, len(resp)) // Even with big count input, the response is still the max available period, which is 1 in test case.
-	require.Equal(t, "capella", resp[0].Version)
-	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp[0].Data.AttestedHeader.BodyRoot)
-	require.NotNil(t, resp)
+	resp := &LightClientUpdatesByRangeResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, 1, len(resp.Updates)) // Even with big count input, the response is still the max available period, which is 1 in test case.
+	require.Equal(t, "capella", resp.Updates[0].Version)
+	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp.Updates[0].Data.AttestedHeader.BodyRoot)
+	require.NotNil(t, resp.Updates)
 }
 
 func TestLightClientHandler_GetLightClientUpdatesByRange_TooEarlyPeriod(t *testing.T) {
@@ -377,12 +377,12 @@ func TestLightClientHandler_GetLightClientUpdatesByRange_TooEarlyPeriod(t *testi
 	s.GetLightClientUpdatesByRange(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp []LightClientUpdateWithVersion
-	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
-	require.Equal(t, 1, len(resp))
-	require.Equal(t, "capella", resp[0].Version)
-	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp[0].Data.AttestedHeader.BodyRoot)
-	require.NotNil(t, resp)
+	resp := &LightClientUpdatesByRangeResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, 1, len(resp.Updates))
+	require.Equal(t, "capella", resp.Updates[0].Version)
+	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp.Updates[0].Data.AttestedHeader.BodyRoot)
+	require.NotNil(t, resp.Updates)
 }
 
 func TestLightClientHandler_GetLightClientUpdatesByRange_TooBigCount(t *testing.T) {
@@ -480,12 +480,12 @@ func TestLightClientHandler_GetLightClientUpdatesByRange_TooBigCount(t *testing.
 	s.GetLightClientUpdatesByRange(writer, request)
 
 	require.Equal(t, http.StatusOK, writer.Code)
-	var resp []LightClientUpdateWithVersion
-	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
-	require.Equal(t, 1, len(resp))
-	require.Equal(t, "capella", resp[0].Version)
-	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp[0].Data.AttestedHeader.BodyRoot)
-	require.NotNil(t, resp)
+	resp := &LightClientUpdatesByRangeResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, 1, len(resp.Updates))
+	require.Equal(t, "capella", resp.Updates[0].Version)
+	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), resp.Updates[0].Data.AttestedHeader.BodyRoot)
+	require.NotNil(t, resp.Updates)
 }
 
 func TestLightClientHandler_GetLightClientUpdatesByRange_BeforeAltair(t *testing.T) {
@@ -583,6 +583,9 @@ func TestLightClientHandler_GetLightClientUpdatesByRange_BeforeAltair(t *testing
 	s.GetLightClientUpdatesByRange(writer, request)
 
 	require.Equal(t, http.StatusNotFound, writer.Code)
+	resp := &LightClientUpdatesByRangeResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, 0, len(resp.Updates))
 }
 
 func TestLightClientHandler_GetLightClientFinalityUpdate(t *testing.T) {

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

@@ -296,16 +296,11 @@ func newLightClientUpdateToJSON(input *v2.LightClientUpdate) *LightClientUpdate
 		nextSyncCommittee = shared.SyncCommitteeFromConsensus(migration.V2SyncCommitteeToV1Alpha1(input.NextSyncCommittee))
 	}
 
-	var finalizedHeader *shared.BeaconBlockHeader
-	if input.FinalizedHeader != nil {
-		finalizedHeader = shared.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(input.FinalizedHeader))
-	}
-
 	return &LightClientUpdate{
 		AttestedHeader:          shared.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(input.AttestedHeader)),
 		NextSyncCommittee:       nextSyncCommittee,
 		NextSyncCommitteeBranch: branchToJSON(input.NextSyncCommitteeBranch),
-		FinalizedHeader:         finalizedHeader,
+		FinalizedHeader:         shared.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(input.FinalizedHeader)),
 		FinalityBranch:          branchToJSON(input.FinalityBranch),
 		SyncAggregate:           syncAggregateToJSON(input.SyncAggregate),
 		SignatureSlot:           strconv.FormatUint(uint64(input.SignatureSlot), 10),

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

@@ -17,11 +17,11 @@ type LightClientBootstrap struct {
 
 type LightClientUpdate struct {
 	AttestedHeader          *shared.BeaconBlockHeader `json:"attested_header"`
-	NextSyncCommittee       *shared.SyncCommittee     `json:"next_sync_committee,omitempty"`
-	FinalizedHeader         *shared.BeaconBlockHeader `json:"finalized_header,omitempty"`
+	NextSyncCommittee       *shared.SyncCommittee     `json:"next_sync_committee"`
+	FinalizedHeader         *shared.BeaconBlockHeader `json:"finalized_header"`
 	SyncAggregate           *shared.SyncAggregate     `json:"sync_aggregate"`
-	NextSyncCommitteeBranch []string                  `json:"next_sync_committee_branch,omitempty"`
-	FinalityBranch          []string                  `json:"finality_branch,omitempty"`
+	NextSyncCommitteeBranch []string                  `json:"next_sync_committee_branch"`
+	FinalityBranch          []string                  `json:"finality_branch"`
 	SignatureSlot           string                    `json:"signature_slot"`
 }
 

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

@@ -62,6 +62,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 
 // AttestationRewards retrieves attestation reward info for validators specified by array of public keys or validator index.
 // If no array is provided, return reward info for every validator.
+// TODO: Inclusion delay
 func (s *Server) AttestationRewards(w http.ResponseWriter, r *http.Request) {
 	st, ok := s.attRewardsState(w, r)
 	if !ok {
@@ -276,10 +277,7 @@ func idealAttRewards(
 					IsPrevEpochTargetAttester:    true,
 					IsPrevEpochHeadAttester:      true,
 				})
-				idealRewards = append(idealRewards, IdealAttestationReward{
-					EffectiveBalance: strconv.FormatUint(effectiveBalance, 10),
-					Inactivity:       strconv.FormatUint(0, 10),
-				})
+				idealRewards = append(idealRewards, IdealAttestationReward{EffectiveBalance: strconv.FormatUint(effectiveBalance, 10)})
 				break
 			}
 		}
@@ -301,11 +299,6 @@ func idealAttRewards(
 		} else {
 			idealRewards[i].Target = strconv.FormatUint(d.TargetReward, 10)
 		}
-		if d.InactivityPenalty > 0 {
-			idealRewards[i].Inactivity = fmt.Sprintf("-%s", strconv.FormatUint(d.InactivityPenalty, 10))
-		} else {
-			idealRewards[i].Inactivity = strconv.FormatUint(d.InactivityPenalty, 10)
-		}
 	}
 	return idealRewards, true
 }
@@ -338,11 +331,6 @@ func totalAttRewards(
 		} else {
 			totalRewards[i].Target = strconv.FormatUint(d.TargetReward, 10)
 		}
-		if d.InactivityPenalty > 0 {
-			totalRewards[i].Inactivity = fmt.Sprintf("-%s", strconv.FormatUint(d.InactivityPenalty, 10))
-		} else {
-			totalRewards[i].Inactivity = strconv.FormatUint(d.InactivityPenalty, 10)
-		}
 	}
 	return totalRewards, true
 }

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

@@ -396,7 +396,7 @@ func TestAttestationRewards(t *testing.T) {
 		FinalizationFetcher:   mockChainService,
 	}
 
-	t.Run("ideal rewards", func(t *testing.T) {
+	t.Run("ok - ideal rewards", func(t *testing.T) {
 		url := "http://only.the.epoch.number.at.the.end.is.important/1"
 		request := httptest.NewRequest("POST", url, nil)
 		writer := httptest.NewRecorder()
@@ -419,7 +419,7 @@ func TestAttestationRewards(t *testing.T) {
 		}
 		assert.Equal(t, uint64(20756849), sum)
 	})
-	t.Run("filtered vals", func(t *testing.T) {
+	t.Run("ok - filtered vals", func(t *testing.T) {
 		url := "http://only.the.epoch.number.at.the.end.is.important/1"
 		var body bytes.Buffer
 		pubkey := fmt.Sprintf("%#x", secretKeys[10].PublicKey().Marshal())
@@ -448,7 +448,7 @@ func TestAttestationRewards(t *testing.T) {
 		}
 		assert.Equal(t, uint64(794265), sum)
 	})
-	t.Run("all vals", func(t *testing.T) {
+	t.Run("ok - all vals", func(t *testing.T) {
 		url := "http://only.the.epoch.number.at.the.end.is.important/1"
 		request := httptest.NewRequest("POST", url, nil)
 		writer := httptest.NewRecorder()
@@ -471,12 +471,36 @@ func TestAttestationRewards(t *testing.T) {
 		}
 		assert.Equal(t, uint64(54221955), sum)
 	})
-	t.Run("penalty", func(t *testing.T) {
-		st := st.Copy()
-		validators := st.Validators()
+	t.Run("ok - penalty", func(t *testing.T) {
+		st, err := util.NewBeaconStateCapella()
+		require.NoError(t, err)
+		require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*3-1))
+		validators := make([]*eth.Validator, 0, valCount)
+		balances := make([]uint64, 0, valCount)
+		for i := 0; i < valCount; i++ {
+			blsKey, err := bls.RandKey()
+			require.NoError(t, err)
+			validators = append(validators, &eth.Validator{
+				PublicKey:         blsKey.PublicKey().Marshal(),
+				ExitEpoch:         params.BeaconConfig().FarFutureEpoch,
+				WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+				EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance / 64 * uint64(i),
+			})
+			balances = append(balances, params.BeaconConfig().MaxEffectiveBalance/64*uint64(i))
+		}
 		validators[63].Slashed = true
 		require.NoError(t, st.SetValidators(validators))
+		require.NoError(t, st.SetBalances(balances))
+		require.NoError(t, st.SetInactivityScores(make([]uint64, len(validators))))
+		participation := make([]byte, len(validators))
+		for i := range participation {
+			participation[i] = 0b111
+		}
+		require.NoError(t, st.SetCurrentParticipationBits(participation))
+		require.NoError(t, st.SetPreviousParticipationBits(participation))
 
+		currentSlot := params.BeaconConfig().SlotsPerEpoch * 3
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &currentSlot}
 		s := &Server{
 			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
 				params.BeaconConfig().SlotsPerEpoch*3 - 1: st,
@@ -501,44 +525,8 @@ func TestAttestationRewards(t *testing.T) {
 		resp := &AttestationRewardsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		assert.Equal(t, "0", resp.Data.TotalRewards[0].Head)
-		assert.Equal(t, "-439299", resp.Data.TotalRewards[0].Source)
-		assert.Equal(t, "-815841", resp.Data.TotalRewards[0].Target)
-		assert.Equal(t, "0", resp.Data.TotalRewards[0].Inactivity)
-	})
-	t.Run("inactivity", func(t *testing.T) {
-		st := st.Copy()
-		validators := st.Validators()
-		validators[63].Slashed = true
-		require.NoError(t, st.SetValidators(validators))
-		inactivityScores, err := st.InactivityScores()
-		require.NoError(t, err)
-		inactivityScores[63] = 10
-		require.NoError(t, st.SetInactivityScores(inactivityScores))
-
-		s := &Server{
-			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-				params.BeaconConfig().SlotsPerEpoch*3 - 1: st,
-			}},
-			TimeFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-		}
-
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		var body bytes.Buffer
-		valIds, err := json.Marshal([]string{"63"})
-		require.NoError(t, err)
-		_, err = body.Write(valIds)
-		require.NoError(t, err)
-		request := httptest.NewRequest("POST", url, &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &AttestationRewardsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, "-4768", resp.Data.TotalRewards[0].Inactivity)
+		assert.Equal(t, "-432270", resp.Data.TotalRewards[0].Source)
+		assert.Equal(t, "-802788", resp.Data.TotalRewards[0].Target)
 	})
 	t.Run("invalid validator index/pubkey", func(t *testing.T) {
 		url := "http://only.the.epoch.number.at.the.end.is.important/1"

beacon-chain/rpc/eth/rewards/structs.go

@@ -31,7 +31,6 @@ type IdealAttestationReward struct {
 	Head             string `json:"head"`
 	Target           string `json:"target"`
 	Source           string `json:"source"`
-	Inactivity       string `json:"inactivity"`
 }
 
 type TotalAttestationReward struct {
@@ -39,7 +38,7 @@ type TotalAttestationReward struct {
 	Head           string `json:"head"`
 	Target         string `json:"target"`
 	Source         string `json:"source"`
-	Inactivity     string `json:"inactivity"`
+	InclusionDelay string `json:"inclusion_delay"`
 }
 
 type SyncCommitteeRewardsResponse struct {

beacon-chain/rpc/eth/shared/conversions_block.go

@@ -2333,10 +2333,10 @@ func ExecutionPayloadHeaderDenebFromConsensus(payload *enginev1.ExecutionPayload
 		Timestamp:        fmt.Sprintf("%d", payload.Timestamp),
 		ExtraData:        hexutil.Encode(payload.ExtraData),
 		BaseFeePerGas:    baseFeePerGas,
+		BlobGasUsed:      fmt.Sprintf("%d", payload.BlobGasUsed),
+		ExcessBlobGas:    fmt.Sprintf("%d", payload.ExcessBlobGas),
 		BlockHash:        hexutil.Encode(payload.BlockHash),
 		TransactionsRoot: hexutil.Encode(payload.TransactionsRoot),
 		WithdrawalsRoot:  hexutil.Encode(payload.WithdrawalsRoot),
-		BlobGasUsed:      fmt.Sprintf("%d", payload.BlobGasUsed),
-		ExcessBlobGas:    fmt.Sprintf("%d", payload.ExcessBlobGas),
 	}, nil
 }

beacon-chain/rpc/eth/shared/structs_block.go

@@ -325,11 +325,11 @@ type ExecutionPayloadDeneb struct {
 	Timestamp     string        `json:"timestamp"`
 	ExtraData     string        `json:"extra_data"`
 	BaseFeePerGas string        `json:"base_fee_per_gas"`
+	BlobGasUsed   string        `json:"blob_gas_used"`
+	ExcessBlobGas string        `json:"excess_blob_gas"`
 	BlockHash     string        `json:"block_hash"`
 	Transactions  []string      `json:"transactions"`
 	Withdrawals   []*Withdrawal `json:"withdrawals"`
-	BlobGasUsed   string        `json:"blob_gas_used"`
-	ExcessBlobGas string        `json:"excess_blob_gas"`
 }
 
 type ExecutionPayloadHeaderDeneb struct {
@@ -345,9 +345,9 @@ type ExecutionPayloadHeaderDeneb struct {
 	Timestamp        string `json:"timestamp"`
 	ExtraData        string `json:"extra_data"`
 	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlobGasUsed      string `json:"blob_gas_used"`
+	ExcessBlobGas    string `json:"excess_blob_gas"`
 	BlockHash        string `json:"block_hash"`
 	TransactionsRoot string `json:"transactions_root"`
 	WithdrawalsRoot  string `json:"withdrawals_root"`
-	BlobGasUsed      string `json:"blob_gas_used"`
-	ExcessBlobGas    string `json:"excess_blob_gas"`
 }

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

@@ -388,6 +388,10 @@ func (s *Server) GetAttestationData(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if isOptimistic, err := shared.IsOptimistic(ctx, w, s.OptimisticModeFetcher); isOptimistic || err != nil {
+		return
+	}
+
 	_, slot, ok := shared.UintFromQuery(w, r, "slot", true)
 	if !ok {
 		return

beacon-chain/rpc/eth/validator/handlers_block.go

@@ -201,7 +201,7 @@ func (s *Server) ProduceBlockV3(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) produceBlockV3(ctx context.Context, w http.ResponseWriter, r *http.Request, v1alpha1req *eth.BlockRequest, requiredType blockType) {
-	isSSZ := httputil.RespondWithSsz(r)
+	isSSZ := httputil.SszRequested(r)
 	v1alpha1resp, err := s.V1Alpha1Server.GetBeaconBlock(ctx, v1alpha1req)
 	if err != nil {
 		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)

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

@@ -831,11 +831,10 @@ func TestGetAttestationData(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			CoreService: &core.Service{
-				HeadFetcher:           chain,
-				GenesisTimeFetcher:    chain,
-				FinalizedFetcher:      chain,
-				AttestationCache:      cache.NewAttestationCache(),
-				OptimisticModeFetcher: chain,
+				HeadFetcher:        chain,
+				GenesisTimeFetcher: chain,
+				FinalizedFetcher:   chain,
+				AttestationCache:   cache.NewAttestationCache(),
 			},
 		}
 
@@ -915,11 +914,10 @@ func TestGetAttestationData(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			CoreService: &core.Service{
-				AttestationCache:      cache.NewAttestationCache(),
-				GenesisTimeFetcher:    chain,
-				HeadFetcher:           chain,
-				FinalizedFetcher:      chain,
-				OptimisticModeFetcher: chain,
+				AttestationCache:   cache.NewAttestationCache(),
+				GenesisTimeFetcher: chain,
+				HeadFetcher:        chain,
+				FinalizedFetcher:   chain,
 			},
 		}
 
@@ -961,9 +959,8 @@ func TestGetAttestationData(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			CoreService: &core.Service{
-				GenesisTimeFetcher:    chain,
-				OptimisticModeFetcher: chain,
-				FinalizedFetcher:      chain,
+				GenesisTimeFetcher: chain,
+				FinalizedFetcher:   chain,
 			},
 		}
 
@@ -1020,11 +1017,10 @@ func TestGetAttestationData(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			CoreService: &core.Service{
-				HeadFetcher:           chain,
-				GenesisTimeFetcher:    chain,
-				OptimisticModeFetcher: chain,
-				StateGen:              stategen.New(db, doublylinkedtree.New()),
-				FinalizedFetcher:      chain,
+				HeadFetcher:        chain,
+				GenesisTimeFetcher: chain,
+				StateGen:           stategen.New(db, doublylinkedtree.New()),
+				FinalizedFetcher:   chain,
 			},
 		}
 
@@ -1069,11 +1065,10 @@ func TestGetAttestationData(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			CoreService: &core.Service{
-				AttestationCache:      cache.NewAttestationCache(),
-				OptimisticModeFetcher: chain,
-				HeadFetcher:           chain,
-				GenesisTimeFetcher:    chain,
-				FinalizedFetcher:      chain,
+				AttestationCache:   cache.NewAttestationCache(),
+				HeadFetcher:        chain,
+				GenesisTimeFetcher: chain,
+				FinalizedFetcher:   chain,
 			},
 		}
 
@@ -1156,11 +1151,10 @@ func TestGetAttestationData(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			CoreService: &core.Service{
-				AttestationCache:      cache.NewAttestationCache(),
-				OptimisticModeFetcher: chain,
-				HeadFetcher:           chain,
-				GenesisTimeFetcher:    chain,
-				FinalizedFetcher:      chain,
+				AttestationCache:   cache.NewAttestationCache(),
+				HeadFetcher:        chain,
+				GenesisTimeFetcher: chain,
+				FinalizedFetcher:   chain,
 			},
 		}
 
@@ -1198,14 +1192,14 @@ func TestGetAttestationData(t *testing.T) {
 func TestProduceSyncCommitteeContribution(t *testing.T) {
 	root := bytesutil.PadTo([]byte("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"), 32)
 	sig := bls.NewAggregateSignature().Marshal()
-	message := &ethpbalpha.SyncCommitteeMessage{
+	messsage := &ethpbalpha.SyncCommitteeMessage{
 		Slot:           1,
 		BlockRoot:      root,
 		ValidatorIndex: 0,
 		Signature:      sig,
 	}
 	syncCommitteePool := synccommittee.NewStore()
-	require.NoError(t, syncCommitteePool.SaveSyncCommitteeMessage(message))
+	require.NoError(t, syncCommitteePool.SaveSyncCommitteeMessage(messsage))
 	server := Server{
 		CoreService: &core.Service{
 			HeadFetcher: &mockChain.ChainService{

beacon-chain/rpc/lookup/BUILD.bazel

@@ -24,7 +24,6 @@ go_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/rpc/lookup/blocker.go

@@ -19,7 +19,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
-	log "github.com/sirupsen/logrus"
 )
 
 // BlockIdParseError represents an error scenario where a block ID could not be parsed.
@@ -211,10 +210,7 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []uint64
 	if len(indices) == 0 {
 		m, err := p.BlobStorage.Indices(bytesutil.ToBytes32(root))
 		if err != nil {
-			log.WithFields(log.Fields{
-				"block root": hexutil.Encode(root),
-			}).Error(errors.Wrapf(err, "could not retrieve blob indices for root %#x", root))
-			return nil, &core.RpcError{Err: fmt.Errorf("could not retrieve blob indices for root %#x", root), Reason: core.Internal}
+			return nil, &core.RpcError{Err: errors.Wrapf(err, "could not retrieve blob indices for root %#x", root), Reason: core.Internal}
 		}
 		for k, v := range m {
 			if v {
@@ -227,11 +223,7 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []uint64
 	for i, index := range indices {
 		vblob, err := p.BlobStorage.Get(bytesutil.ToBytes32(root), index)
 		if err != nil {
-			log.WithFields(log.Fields{
-				"block root": hexutil.Encode(root),
-				"blob index": index,
-			}).Error(errors.Wrapf(err, "could not retrieve blob for block root %#x at index %d", root, index))
-			return nil, &core.RpcError{Err: fmt.Errorf("could not retrieve blob for block root %#x at index %d", root, index), Reason: core.Internal}
+			return nil, &core.RpcError{Err: errors.Wrapf(err, "could not retrieve blob for block root %#x at index %d", root, index), Reason: core.Internal}
 		}
 		blobs[i] = &vblob
 	}

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -4,7 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "aggregator.go",
-        "duties.go",
+        "assignments.go",
         "attester.go",
         "blocks.go",
         "construct_generic_block.go",
@@ -38,6 +38,7 @@ go_library(
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
+        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
@@ -65,6 +66,7 @@ go_library(
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/payload-attribute:go_default_library",
@@ -89,13 +91,13 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_golang_protobuf//ptypes/empty",
         "@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_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_bazel_rules_go//proto/wkt:empty_go_proto",
         "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
@@ -139,7 +141,6 @@ common_deps = [
     "//beacon-chain/sync/initial-sync/testing:go_default_library",
     "//config/fieldparams:go_default_library",
     "//config/params:go_default_library",
-    "//consensus-types:go_default_library",
     "//consensus-types/blocks:go_default_library",
     "//consensus-types/interfaces:go_default_library",
     "//consensus-types/primitives:go_default_library",
@@ -178,7 +179,7 @@ go_test(
     timeout = "moderate",
     srcs = [
         "aggregator_test.go",
-        "duties_test.go",
+        "assignments_test.go",
         "attester_test.go",
         "blocks_test.go",
         "construct_generic_block_test.go",