Revert "Call FCU in the background (#16149)"

This reverts commit d4ea8fafd6.

BUILD.bazel

@@ -193,7 +193,7 @@ nogo(
         "//tools/analyzers/featureconfig:go_default_library",
         "//tools/analyzers/gocognit:go_default_library",
         "//tools/analyzers/ineffassign:go_default_library",
-        "//tools/analyzers/httperror:go_default_library",
+        "//tools/analyzers/httpwriter:go_default_library",
         "//tools/analyzers/interfacechecker:go_default_library",
         "//tools/analyzers/logcapitalization:go_default_library",
         "//tools/analyzers/logruswitherror:go_default_library",

beacon-chain/blockchain/execution_engine.go

@@ -323,14 +323,17 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 	var ok bool
 	e := slots.ToEpoch(slot)
 	stateEpoch := slots.ToEpoch(st.Slot())
-	if e == stateEpoch {
+	fuluAndNextEpoch := st.Version() >= version.Fulu && e == stateEpoch+1
+	if e == stateEpoch || fuluAndNextEpoch {
 		val, ok = s.trackedProposer(st, slot)
 		if !ok {
 			return emptyAttri
 		}
 	}
-	st = st.Copy()
 	if slot > st.Slot() {
+		// At this point either we know we are proposing on a future slot or we need to still compute the
+		// right proposer index pre-Fulu, either way we need to copy the state to process it.
+		st = st.Copy()
 		var err error
 		st, err = transition.ProcessSlotsUsingNextSlotCache(ctx, st, headRoot, slot)
 		if err != nil {
@@ -338,7 +341,7 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			return emptyAttri
 		}
 	}
-	if e > stateEpoch {
+	if e > stateEpoch && !fuluAndNextEpoch {
 		emptyAttri := payloadattribute.EmptyWithVersion(st.Version())
 		val, ok = s.trackedProposer(st, slot)
 		if !ok {

beacon-chain/blockchain/process_attestation_helpers.go

@@ -22,7 +22,7 @@ import (
 // The caller of this function must have a lock on forkchoice.
 func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) state.ReadOnlyBeaconState {
 	headEpoch := slots.ToEpoch(s.HeadSlot())
-	if c.Epoch < headEpoch || c.Epoch == 0 {
+	if c.Epoch+1 < headEpoch || c.Epoch == 0 {
 		return nil
 	}
 	// Only use head state if the head state is compatible with the target checkpoint.
@@ -30,11 +30,13 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 	if err != nil {
 		return nil
 	}
-	headDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(headRoot), c.Epoch-1)
+	// headEpoch - 1 equals c.Epoch if c is from the previous epoch and equals c.Epoch - 1 if c is from the current epoch.
+	// We don't use the smaller c.Epoch - 1 because forkchoice would not have the data to answer that.
+	headDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(headRoot), headEpoch-1)
 	if err != nil {
 		return nil
 	}
-	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), c.Epoch-1)
+	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), headEpoch-1)
 	if err != nil {
 		return nil
 	}
@@ -43,7 +45,7 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 	}
 
 	// If the head state alone is enough, we can return it directly read only.
-	if c.Epoch == headEpoch {
+	if c.Epoch <= headEpoch {
 		st, err := s.HeadStateReadOnly(ctx)
 		if err != nil {
 			return nil

beacon-chain/blockchain/process_attestation_test.go

@@ -170,12 +170,13 @@ func TestService_GetRecentPreState(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, blk, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
+		block: blk,
 		slot:  31,
 	}
 	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 1, Root: ckRoot}))
@@ -197,12 +198,13 @@ func TestService_GetRecentPreState_Old_Checkpoint(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, root, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, blk, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
+		block: blk,
 		slot:  33,
 	}
 	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))
@@ -227,6 +229,7 @@ func TestService_GetRecentPreState_Same_DependentRoots(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'T'}, blk.Root(), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
+	headBlock := blk
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 33, [32]byte{'U'}, [32]byte(ckRoot), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
@@ -235,8 +238,9 @@ func TestService_GetRecentPreState_Same_DependentRoots(t *testing.T) {
 
 	service.head = &head{
 		root:  [32]byte{'T'},
-		state: s,
+		block: headBlock,
 		slot:  64,
+		state: s,
 	}
 	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 2, Root: cpRoot[:]}))
 }
@@ -263,6 +267,7 @@ func TestService_GetRecentPreState_Different_DependentRoots(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'U'}, blk.Root(), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
+	headBlock := blk
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 33, [32]byte{'V'}, [32]byte(ckRoot), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
@@ -270,7 +275,8 @@ func TestService_GetRecentPreState_Different_DependentRoots(t *testing.T) {
 	cpRoot := blk.Root()
 
 	service.head = &head{
-		root:  [32]byte{'T'},
+		root:  [32]byte{'U'},
+		block: headBlock,
 		state: s,
 		slot:  64,
 	}
@@ -287,12 +293,13 @@ func TestService_GetRecentPreState_Different(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, root, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, blk, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
+		block: blk,
 		slot:  33,
 	}
 	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))

beacon-chain/blockchain/process_block.go

@@ -295,14 +295,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
-	arg := &fcuConfig{
-		headState: preState,
-		headRoot:  lastBR,
-		headBlock: lastB,
-	}
-	if _, err := s.notifyForkchoiceUpdate(ctx, arg); err != nil {
-		return err
-	}
 	return s.saveHeadNoDB(ctx, lastB, lastBR, preState, !isValidPayload)
 }
 

beacon-chain/blockchain/process_block_test.go

@@ -820,24 +820,6 @@ func TestOnBlock_NilBlock(t *testing.T) {
 	require.Equal(t, true, IsInvalidBlock(err))
 }
 
-func TestOnBlock_InvalidSignature(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
-
-	gs, keys := util.DeterministicGenesisState(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-
-	blk, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	blk.Signature = []byte{'a'} // Mutate the signature.
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	preState, err := service.getBlockPreState(ctx, wsb.Block())
-	require.NoError(t, err)
-	_, err = service.validateStateTransition(ctx, preState, wsb)
-	require.Equal(t, true, IsInvalidBlock(err))
-}
-
 func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	config := params.BeaconConfig()

beacon-chain/core/blocks/header_test.go

@@ -290,52 +290,3 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	}
 	assert.Equal(t, true, proto.Equal(nsh, expected), "Expected %v, received %v", expected, nsh)
 }
-
-func TestBlockSignatureSet_OK(t *testing.T) {
-	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
-		validators[i] = &ethpb.Validator{
-			PublicKey:             make([]byte, 32),
-			WithdrawalCredentials: make([]byte, 32),
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			Slashed:               true,
-		}
-	}
-
-	state, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, state.SetValidators(validators))
-	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(util.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
-		Slot:          9,
-		ProposerIndex: 0,
-	})))
-
-	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
-	require.NoError(t, err)
-
-	currentEpoch := time.CurrentEpoch(state)
-	priv, err := bls.RandKey()
-	require.NoError(t, err)
-	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
-	require.NoError(t, err)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 10
-	block.Block.ProposerIndex = pID
-	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
-	block.Block.ParentRoot = latestBlockSignedRoot[:]
-	block.Signature, err = signing.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
-	require.NoError(t, err)
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), state)
-	require.NoError(t, err)
-	validators[proposerIdx].Slashed = false
-	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
-	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
-	require.NoError(t, err)
-	set, err := blocks.BlockSignatureBatch(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
-	require.NoError(t, err)
-
-	verified, err := set.Verify()
-	require.NoError(t, err)
-	assert.Equal(t, true, verified, "Block signature set returned a set which was unable to be verified")
-}

beacon-chain/core/blocks/signature.go

@@ -122,24 +122,6 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	return nil
 }
 
-// BlockSignatureBatch retrieves the block signature batch from the provided block and its corresponding state.
-func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
-	proposerIndex primitives.ValidatorIndex,
-	sig []byte,
-	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
-	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
-	if err != nil {
-		return nil, err
-	}
-	proposer, err := beaconState.ValidatorAtIndex(proposerIndex)
-	if err != nil {
-		return nil, err
-	}
-	proposerPubKey := proposer.PublicKey
-	return signing.BlockSignatureBatch(proposerPubKey, sig, domain, rootFunc)
-}
-
 // RandaoSignatureBatch retrieves the relevant randao specific signature batch object
 // from a block and its corresponding state.
 func RandaoSignatureBatch(

beacon-chain/core/electra/consolidations.go

@@ -278,12 +278,12 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if uint64(curEpoch) < e {
 			continue
 		}
-		bal, err := st.PendingBalanceToWithdraw(srcIdx)
+		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
 		if err != nil {
 			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
 			continue
 		}
-		if bal > 0 {
+		if hasBal {
 			continue
 		}
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -182,12 +182,6 @@ func ProcessBlockNoVerifyAnySig(
 		return nil, nil, err
 	}
 
-	sig := signed.Signature()
-	bSet, err := b.BlockSignatureBatch(st, blk.ProposerIndex(), sig[:], blk.HashTreeRoot)
-	if err != nil {
-		tracing.AnnotateError(span, err)
-		return nil, nil, errors.Wrap(err, "could not retrieve block signature set")
-	}
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	rSet, err := b.RandaoSignatureBatch(ctx, st, randaoReveal[:])
 	if err != nil {
@@ -201,7 +195,7 @@ func ProcessBlockNoVerifyAnySig(
 
 	// Merge beacon block, randao and attestations signatures into a set.
 	set := bls.NewSet()
-	set.Join(bSet).Join(rSet).Join(aSet)
+	set.Join(rSet).Join(aSet)
 
 	if blk.Version() >= version.Capella {
 		changes, err := signed.Block().Body().BLSToExecutionChanges()

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -157,9 +157,8 @@ func TestProcessBlockNoVerify_SigSetContainsDescriptions(t *testing.T) {
 	set, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
 	require.NoError(t, err)
 	assert.Equal(t, len(set.Signatures), len(set.Descriptions), "Signatures and descriptions do not match up")
-	assert.Equal(t, "block signature", set.Descriptions[0])
-	assert.Equal(t, "randao signature", set.Descriptions[1])
-	assert.Equal(t, "attestation signature", set.Descriptions[2])
+	assert.Equal(t, "randao signature", set.Descriptions[0])
+	assert.Equal(t, "attestation signature", set.Descriptions[1])
 }
 
 func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {

beacon-chain/das/needs.go

@@ -67,9 +67,9 @@ func NewSyncNeeds(current CurrentSlotter, oldestSlotFlagPtr *primitives.Slot, bl
 
 	// Override spec minimum block retention with user-provided flag only if it is lower than the spec minimum.
 	sn.blockRetention = primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
+
 	if oldestSlotFlagPtr != nil {
-		oldestEpoch := slots.ToEpoch(*oldestSlotFlagPtr)
-		if oldestEpoch < sn.blockRetention {
+		if *oldestSlotFlagPtr <= syncEpochOffset(current(), sn.blockRetention) {
 			sn.validOldestSlotPtr = oldestSlotFlagPtr
 		} else {
 			log.WithField("backfill-oldest-slot", *oldestSlotFlagPtr).

beacon-chain/das/needs_test.go

@@ -128,6 +128,9 @@ func TestSyncNeedsInitialize(t *testing.T) {
 	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
 	minBlobEpochs := params.BeaconConfig().MinEpochsForBlobsSidecarsRequest
 	minColEpochs := params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest
+	denebSlot := slots.UnsafeEpochStart(params.BeaconConfig().DenebForkEpoch)
+	fuluSlot := slots.UnsafeEpochStart(params.BeaconConfig().FuluForkEpoch)
+	minSlots := slots.UnsafeEpochStart(primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests))
 
 	currentSlot := primitives.Slot(10000)
 	currentFunc := func() primitives.Slot { return currentSlot }
@@ -141,6 +144,7 @@ func TestSyncNeedsInitialize(t *testing.T) {
 		expectedCol       primitives.Epoch
 		name              string
 		input             SyncNeeds
+		current           func() primitives.Slot
 	}{
 		{
 			name:              "basic initialization with no flags",
@@ -174,13 +178,13 @@ func TestSyncNeedsInitialize(t *testing.T) {
 		{
 			name:              "valid oldestSlotFlagPtr (earlier than spec minimum)",
 			blobRetentionFlag: 0,
-			oldestSlotFlagPtr: func() *primitives.Slot {
-				slot := primitives.Slot(10)
-				return &slot
-			}(),
+			oldestSlotFlagPtr: &denebSlot,
 			expectValidOldest: true,
 			expectedBlob:      minBlobEpochs,
 			expectedCol:       minColEpochs,
+			current: func() primitives.Slot {
+				return fuluSlot + minSlots
+			},
 		},
 		{
 			name:              "invalid oldestSlotFlagPtr (later than spec minimum)",
@@ -210,6 +214,9 @@ func TestSyncNeedsInitialize(t *testing.T) {
 		{
 			name:              "both blob retention flag and oldest slot set",
 			blobRetentionFlag: minBlobEpochs + 5,
+			current: func() primitives.Slot {
+				return fuluSlot + minSlots
+			},
 			oldestSlotFlagPtr: func() *primitives.Slot {
 				slot := primitives.Slot(100)
 				return &slot
@@ -232,16 +239,27 @@ func TestSyncNeedsInitialize(t *testing.T) {
 			expectedBlob:      5000,
 			expectedCol:       5000,
 		},
+		{
+			name:              "regression for deneb start",
+			blobRetentionFlag: 8212500,
+			expectValidOldest: true,
+			oldestSlotFlagPtr: &denebSlot,
+			current: func() primitives.Slot {
+				return fuluSlot + minSlots
+			},
+			expectedBlob: 8212500,
+			expectedCol:  8212500,
+		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			result, err := NewSyncNeeds(currentFunc, tc.oldestSlotFlagPtr, tc.blobRetentionFlag)
+			if tc.current == nil {
+				tc.current = currentFunc
+			}
+			result, err := NewSyncNeeds(tc.current, tc.oldestSlotFlagPtr, tc.blobRetentionFlag)
 			require.NoError(t, err)
 
-			// Check that current, deneb, fulu are set correctly
-			require.Equal(t, currentSlot, result.current())
-
 			// Check retention calculations
 			require.Equal(t, tc.expectedBlob, result.blobRetention)
 			require.Equal(t, tc.expectedCol, result.colRetention)

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

@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
+	coreblocks "github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	corehelpers "github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filters"
@@ -957,6 +958,13 @@ func (s *Server) validateConsensus(ctx context.Context, b *eth.GenericSignedBeac
 			}
 		}
 	}
+	blockRoot, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not hash block")
+	}
+	if err := coreblocks.VerifyBlockSignatureUsingCurrentFork(parentState, blk, blockRoot); err != nil {
+		return errors.Wrap(err, "could not verify block signature")
+	}
 	_, err = transition.ExecuteStateTransition(ctx, parentState, blk)
 	if err != nil {
 		return errors.Wrap(err, "could not execute state transition")

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

@@ -40,6 +40,7 @@ func GetForkSchedule(w http.ResponseWriter, r *http.Request) {
 		httputil.WriteJson(w, &structs.GetForkScheduleResponse{
 			Data: data,
 		})
+		return
 	}
 	previous := schedule[0]
 	for _, entry := range schedule {

changelog/builder-index.md

@@ -0,0 +1,3 @@
+### Added
+
+- `primitives.BuilderIndex`: SSZ `uint64` wrapper for builder registry indices.

changelog/kasey_fix-backfill-flag.md

@@ -0,0 +1,2 @@
+#### Fixed
+- Fix validation logic for `--backfill-oldest-slot`, which was rejecting slots newer than 1056767.

changelog/manu-revert-16149.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Revert #16149

changelog/potuz_next_epoch_attributes.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Do not process slots and copy states for next epoch proposers after Fulu

changelog/potuz_no_fcu_on_batches.md

@@ -0,0 +1,2 @@
+### Ignored
+- D  not send FCU on block batches. 

changelog/potuz_remove_signature_check.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Do not check block signature on state transition. 

changelog/potuz_use_head_previous_epoch.md

@@ -0,0 +1,3 @@
+### Added
+
+- Use the head state to validate attestations for the previous epoch if head is compatible with the target checkpoint.

changelog/radek_extend-http-analyzer.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Extend `httperror` analyzer to more functions.

changelog/sashass1315_fix-panic.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- avoid panic when fork schedule is empty [#16175](https://github.com/OffchainLabs/prysm/pull/16175)

changelog/satushh-consolidation.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Performance improvement in ProcessConsolidationRequests: Use more performance HasPendingBalanceToWithdraw instead of PendingBalanceToWithdraw as no need to calculate full total pending balance. 

consensus-types/primitives/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "basis_points.go",
+        "builder_index.go",
         "committee_bits_mainnet.go",
         "committee_bits_minimal.go",  # keep
         "committee_index.go",
@@ -31,6 +32,7 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
+        "builder_index_test.go",
         "committee_index_test.go",
         "domain_test.go",
         "epoch_test.go",

consensus-types/primitives/builder_index.go

@@ -0,0 +1,54 @@
+package primitives
+
+import (
+	"fmt"
+
+	fssz "github.com/prysmaticlabs/fastssz"
+)
+
+var _ fssz.HashRoot = (BuilderIndex)(0)
+var _ fssz.Marshaler = (*BuilderIndex)(nil)
+var _ fssz.Unmarshaler = (*BuilderIndex)(nil)
+
+// BuilderIndex is an index into the builder registry.
+type BuilderIndex uint64
+
+// HashTreeRoot returns the SSZ hash tree root of the index.
+func (b BuilderIndex) HashTreeRoot() ([32]byte, error) {
+	return fssz.HashWithDefaultHasher(b)
+}
+
+// HashTreeRootWith appends the SSZ uint64 representation of the index to the given hasher.
+func (b BuilderIndex) HashTreeRootWith(hh *fssz.Hasher) error {
+	hh.PutUint64(uint64(b))
+	return nil
+}
+
+// UnmarshalSSZ decodes the SSZ-encoded uint64 index from buf.
+func (b *BuilderIndex) UnmarshalSSZ(buf []byte) error {
+	if len(buf) != b.SizeSSZ() {
+		return fmt.Errorf("expected buffer of length %d received %d", b.SizeSSZ(), len(buf))
+	}
+	*b = BuilderIndex(fssz.UnmarshallUint64(buf))
+	return nil
+}
+
+// MarshalSSZTo appends the SSZ-encoded index to dst and returns the extended buffer.
+func (b *BuilderIndex) MarshalSSZTo(dst []byte) ([]byte, error) {
+	marshalled, err := b.MarshalSSZ()
+	if err != nil {
+		return nil, err
+	}
+	return append(dst, marshalled...), nil
+}
+
+// MarshalSSZ encodes the index as an SSZ uint64.
+func (b *BuilderIndex) MarshalSSZ() ([]byte, error) {
+	marshalled := fssz.MarshalUint64([]byte{}, uint64(*b))
+	return marshalled, nil
+}
+
+// SizeSSZ returns the size of the SSZ-encoded index in bytes.
+func (b *BuilderIndex) SizeSSZ() int {
+	return 8
+}

consensus-types/primitives/builder_index_test.go

@@ -0,0 +1,86 @@
+package primitives_test
+
+import (
+	"encoding/binary"
+	"slices"
+	"strconv"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestBuilderIndex_SSZRoundTripAndHashRoot(t *testing.T) {
+	cases := []uint64{
+		0,
+		1,
+		42,
+		(1 << 32) - 1,
+		1 << 32,
+		^uint64(0),
+	}
+
+	for _, v := range cases {
+		t.Run("v="+u64name(v), func(t *testing.T) {
+			t.Parallel()
+
+			val := primitives.BuilderIndex(v)
+			require.Equal(t, 8, (&val).SizeSSZ())
+
+			enc, err := (&val).MarshalSSZ()
+			require.NoError(t, err)
+			require.Equal(t, 8, len(enc))
+
+			wantEnc := make([]byte, 8)
+			binary.LittleEndian.PutUint64(wantEnc, v)
+			require.DeepEqual(t, wantEnc, enc)
+
+			dstPrefix := []byte("prefix:")
+			dst, err := (&val).MarshalSSZTo(slices.Clone(dstPrefix))
+			require.NoError(t, err)
+			wantDst := append(dstPrefix, wantEnc...)
+			require.DeepEqual(t, wantDst, dst)
+
+			var decoded primitives.BuilderIndex
+			require.NoError(t, (&decoded).UnmarshalSSZ(enc))
+			require.Equal(t, val, decoded)
+
+			root, err := val.HashTreeRoot()
+			require.NoError(t, err)
+
+			var wantRoot [32]byte
+			binary.LittleEndian.PutUint64(wantRoot[:8], v)
+			require.Equal(t, wantRoot, root)
+		})
+	}
+}
+
+func TestBuilderIndex_UnmarshalSSZRejectsWrongSize(t *testing.T) {
+	for _, size := range []int{7, 9} {
+		t.Run("size="+strconv.Itoa(size), func(t *testing.T) {
+			t.Parallel()
+			var v primitives.BuilderIndex
+			err := (&v).UnmarshalSSZ(make([]byte, size))
+			require.ErrorContains(t, "expected buffer of length 8", err)
+		})
+	}
+}
+
+func u64name(v uint64) string {
+	switch v {
+	case 0:
+		return "0"
+	case 1:
+		return "1"
+	case 42:
+		return "42"
+	case (1 << 32) - 1:
+		return "2^32-1"
+	case 1 << 32:
+		return "2^32"
+	case ^uint64(0):
+		return "max"
+	default:
+		return "custom"
+	}
+}

network/httputil/writer.go

@@ -43,6 +43,7 @@ func WriteJson(w http.ResponseWriter, v any) {
 func WriteSsz(w http.ResponseWriter, respSsz []byte) {
 	w.Header().Set("Content-Length", strconv.Itoa(len(respSsz)))
 	w.Header().Set("Content-Type", api.OctetStreamMediaType)
+	w.WriteHeader(http.StatusOK)
 	if _, err := io.Copy(w, io.NopCloser(bytes.NewReader(respSsz))); err != nil {
 		log.WithError(err).Error("Could not write response message")
 	}

tools/analyzers/httpwriter/BUILD.bazel

@@ -3,7 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = ["analyzer.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/tools/analyzers/httperror",
+    importpath = "github.com/OffchainLabs/prysm/v7/tools/analyzers/httpwriter",
     visibility = ["//visibility:public"],
     deps = [
         "@org_golang_x_tools//go/analysis:go_default_library",

tools/analyzers/httpwriter/analyzer.go

@@ -1,4 +1,4 @@
-package httperror
+package httpwriter
 
 import (
 	"go/ast"
@@ -9,8 +9,8 @@ import (
 )
 
 var Analyzer = &analysis.Analyzer{
-	Name: "httperror",
-	Doc:  "Ensures calls to httputil.HandleError are immediately followed by a return statement.",
+	Name: "httpwriter",
+	Doc:  "Ensures that httputil functions which make use of the writer are immediately followed by a return statement.",
 	Requires: []*analysis.Analyzer{
 		inspect.Analyzer,
 	},
@@ -99,7 +99,7 @@ func checkBlock(pass *analysis.Pass, fn *ast.FuncDecl, block *ast.BlockStmt, nex
 
 		// Now check the current statement itself: is it (or does it contain) a direct call to httputil.HandleError?
 		// We only consider ExprStmt that are direct CallExpr to httputil.HandleError.
-		call := findHandleErrorCall(stmt)
+		call, name := findHandleErrorCall(stmt)
 		if call == nil {
 			continue
 		}
@@ -121,7 +121,7 @@ func checkBlock(pass *analysis.Pass, fn *ast.FuncDecl, block *ast.BlockStmt, nex
 				continue
 			}
 			// otherwise it's not a return (even if it's an if/for etc) -> violation
-			pass.Reportf(stmt.Pos(), "call to httputil.HandleError must be immediately followed by a return statement")
+			pass.Reportf(stmt.Pos(), "call to httputil.%s must be immediately followed by a return statement", name)
 			continue
 		}
 
@@ -133,31 +133,33 @@ func checkBlock(pass *analysis.Pass, fn *ast.FuncDecl, block *ast.BlockStmt, nex
 		}
 
 		// Non-void function and it's the last statement → violation
-		pass.Reportf(stmt.Pos(), "call to httputil.HandleError must be followed by return because function has return values")
+		pass.Reportf(stmt.Pos(), "call to httputil.%s must be immediately followed by a return statement", name)
 	}
 }
 
 // findHandleErrorCall returns the call expression if stmt is a direct call to httputil.HandleError(...),
 // otherwise nil. We only match direct ExprStmt -> CallExpr -> SelectorExpr where selector is httputil.HandleError.
-func findHandleErrorCall(stmt ast.Stmt) *ast.CallExpr {
+func findHandleErrorCall(stmt ast.Stmt) (*ast.CallExpr, string) {
 	es, ok := stmt.(*ast.ExprStmt)
 	if !ok {
-		return nil
+		return nil, ""
 	}
 	call, ok := es.X.(*ast.CallExpr)
 	if !ok {
-		return nil
+		return nil, ""
 	}
 	sel, ok := call.Fun.(*ast.SelectorExpr)
 	if !ok {
-		return nil
+		return nil, ""
 	}
 	pkgIdent, ok := sel.X.(*ast.Ident)
 	if !ok {
-		return nil
+		return nil, ""
 	}
-	if pkgIdent.Name == "httputil" && sel.Sel.Name == "HandleError" {
-		return call
+	selectorName := sel.Sel.Name
+	if pkgIdent.Name == "httputil" &&
+		(selectorName == "HandleError" || selectorName == "WriteError" || selectorName == "WriteJson" || selectorName == "WriteSSZ") {
+		return call, selectorName
 	}
-	return nil
+	return nil, ""
 }