Fix validator can specify gas limit

* add checks for finalized checkpoint

* implement `EmptyExecutionPayloadHeader()` function

* changelog

* fix error message

* revert `process_block.go`

* fix error message

* testing

* Update CHANGELOG.md

Co-authored-by: Radosław Kapka <radoslaw.kapka@gmail.com>

* revert "testing"

---------

Co-authored-by: Radosław Kapka <radoslaw.kapka@gmail.com>
Co-authored-by: Radosław Kapka <rkapka@wp.pl>

CHANGELOG.md

@@ -33,6 +33,8 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Added a Prometheus error counter metric for SSE requests.
 - Save light client updates and bootstraps in DB.
 - Added more comprehensive tests for `BlockToLightClientHeader`. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
+- Added an error field to log `Finished building block`.
+- Implemented a new `EmptyExecutionPayloadHeader` function.
 
 ### Changed
 
@@ -75,8 +77,9 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Updated `Blobs` endpoint to return additional metadata fields.
 - Made QUIC the default method to connect with peers.
 - Check kzg commitments align with blobs and proofs for beacon api end point.
-- Increase Max Payload Size in Gossip.
 - Revert "Proposer checks gas limit before accepting builder's bid".
+- Updated quic-go to v0.48.2 .
+- Process light client finality updates only for new finalized epochs instead of doing it for every block.
 
 ### Deprecated
 
@@ -114,9 +117,11 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - P2P: Avoid infinite loop when looking for peers in small networks.
 - Fixed another rollback bug due to a context deadline.
 - Fix checkpoint sync bug on holesky. [pr](https://github.com/prysmaticlabs/prysm/pull/14689)
+- Fix proposer boost spec tests being flakey by adjusting start time from 3 to 2s into slot.
 - Fix segmentation fault in E2E when light-client feature flag is enabled. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
 - Fix `searchForPeers` infinite loop in small networks.
-
+- Fix slashing pool behavior to enforce MaxAttesterSlashings limit in Electra version.
+- Fix validator gas limit usage through flag and file.
 
 ### Security
 

beacon-chain/blockchain/process_block_helpers.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"time"
@@ -240,6 +241,11 @@ func (s *Service) processLightClientFinalityUpdate(
 		}
 	}
 
+	// Check if the finalized checkpoint has changed
+	if finalizedCheckPoint == nil || bytes.Equal(finalizedCheckPoint.GetRoot(), postState.FinalizedCheckpoint().Root) {
+		return nil
+	}
+
 	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
 		postState.Slot(),

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

@@ -6,6 +6,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/execution:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -33,6 +34,7 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",

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

@@ -7,6 +7,7 @@ import (
 	"reflect"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -404,18 +405,15 @@ func BlockToLightClientHeader(
 		var payloadProof [][]byte
 
 		if blockEpoch < params.BeaconConfig().CapellaForkEpoch {
-			payloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
-				ParentHash:       make([]byte, fieldparams.RootLength),
-				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-				StateRoot:        make([]byte, fieldparams.RootLength),
-				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),
+			var ok bool
+
+			p, err := execution.EmptyExecutionPayloadHeader(version.Capella)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get payload header")
+			}
+			payloadHeader, ok = p.(*enginev1.ExecutionPayloadHeaderCapella)
+			if !ok {
+				return nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderCapella{})
 			}
 			payloadProof = emptyPayloadProof()
 		} else {
@@ -472,18 +470,15 @@ func BlockToLightClientHeader(
 		var payloadProof [][]byte
 
 		if blockEpoch < params.BeaconConfig().CapellaForkEpoch {
-			payloadHeader = &enginev1.ExecutionPayloadHeaderDeneb{
-				ParentHash:       make([]byte, fieldparams.RootLength),
-				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-				StateRoot:        make([]byte, fieldparams.RootLength),
-				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),
+			var ok bool
+
+			p, err := execution.EmptyExecutionPayloadHeader(version.Deneb)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get payload header")
+			}
+			payloadHeader, ok = p.(*enginev1.ExecutionPayloadHeaderDeneb)
+			if !ok {
+				return nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderDeneb{})
 			}
 			payloadProof = emptyPayloadProof()
 		} else {

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

@@ -2,15 +2,18 @@ package light_client_test
 
 import (
 	"reflect"
+	"strings"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	light_client "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+
 	"github.com/pkg/errors"
 	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -972,3 +975,667 @@ func convertArrayToSlice(arr [4][32]uint8) [][]uint8 {
 	}
 	return slice
 }
+
+// When the update has relevant sync committee
+func createNonEmptySyncCommitteeBranch() [][]byte {
+	res := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
+	res[0] = []byte(strings.Repeat("x", 32))
+	for i := 1; i < len(res); i++ {
+		res[i] = make([]byte, fieldparams.RootLength)
+	}
+	return res
+}
+
+// When the update has finality
+func createNonEmptyFinalityBranch() [][]byte {
+	res := make([][]byte, fieldparams.FinalityBranchDepth)
+	res[0] = []byte(strings.Repeat("x", 32))
+	for i := 1; i < fieldparams.FinalityBranchDepth; i++ {
+		res[i] = make([]byte, 32)
+	}
+	return res
+}
+
+func TestIsBetterUpdate(t *testing.T) {
+	config := params.BeaconConfig()
+	st, err := util.NewBeaconStateAltair()
+	require.NoError(t, err)
+
+	t.Run("new has supermajority but old doesn't", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
+		})
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b11111100, 0b1}, // [0,0,1,1,1,1,1,1]
+		})
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("old has supermajority but new doesn't", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b11111100, 0b1}, // [0,0,1,1,1,1,1,1]
+		})
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
+		})
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("new doesn't have supermajority and newNumActiveParticipants is greater than oldNumActiveParticipants", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
+		})
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("new doesn't have supermajority and newNumActiveParticipants is lesser than oldNumActiveParticipants", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
+		})
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("new has relevant sync committee but old doesn't", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000001,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(1000000)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("old has relevant sync committee but new doesn't", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000001,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(1000000)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("new has finality but old doesn't", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("old has finality but new doesn't", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("new has finality and sync committee finality both but old doesn't have sync committee finality", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(999999)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 999999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("new has finality but doesn't have sync committee finality and old has sync committee finality", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(999999)
+		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 999999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("new has more active participants than old", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,1,1,1,1,1,0,0]
+		})
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("new has less active participants than old", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,1,1,1,1,1,0,0]
+		})
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("new's attested header's slot is lesser than old's attested header's slot", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 999999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("new's attested header's slot is greater than old's attested header's slot", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 999999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+
+	t.Run("none of the above conditions are met and new signature's slot is less than old signature's slot", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9999)
+		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9998)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, true, result)
+	})
+
+	t.Run("none of the above conditions are met and new signature's slot is greater than old signature's slot", func(t *testing.T) {
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		require.NoError(t, err)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		require.NoError(t, err)
+
+		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
+		require.NoError(t, err)
+		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		oldUpdate.SetSignatureSlot(9998)
+		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
+		require.NoError(t, err)
+
+		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
+			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
+		})
+		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 1000000,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetAttestedHeader(newAttestedHeader)
+		require.NoError(t, err)
+		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
+		require.NoError(t, err)
+		newUpdate.SetSignatureSlot(9999)
+		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
+		require.NoError(t, err)
+		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot: 9999,
+			},
+		})
+		require.NoError(t, err)
+		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
+		require.NoError(t, err)
+
+		result, err := lightClient.IsBetterUpdate(newUpdate, oldUpdate)
+		require.NoError(t, err)
+		require.Equal(t, false, result)
+	})
+}

beacon-chain/execution/engine_client.go

@@ -849,6 +849,53 @@ func EmptyExecutionPayload(v int) (proto.Message, error) {
 	}
 }
 
+func EmptyExecutionPayloadHeader(v int) (proto.Message, error) {
+	switch v {
+	case version.Bellatrix:
+		return &pb.ExecutionPayloadHeader{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			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),
+		}, nil
+	case version.Capella:
+		return &pb.ExecutionPayloadHeaderCapella{
+			ParentHash:       make([]byte, fieldparams.RootLength),
+			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:        make([]byte, fieldparams.RootLength),
+			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),
+		}, nil
+	case version.Deneb, version.Electra:
+		return &pb.ExecutionPayloadHeaderDeneb{
+			ParentHash:       make([]byte, fieldparams.RootLength),
+			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:        make([]byte, fieldparams.RootLength),
+			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),
+		}, nil
+	default:
+		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
+	}
+}
+
 func toBlockNumArg(number *big.Int) string {
 	if number == nil {
 		return "latest"

beacon-chain/operations/slashings/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//container/slice:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/operations/slashings/service.go

@@ -15,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/trailofbits/go-mutexasserts"
 )
 
@@ -43,6 +44,11 @@ func (p *Pool) PendingAttesterSlashings(ctx context.Context, state state.ReadOnl
 
 	// Allocate pending slice with a capacity of maxAttesterSlashings or len(p.pendingAttesterSlashing)) depending on the request.
 	maxSlashings := params.BeaconConfig().MaxAttesterSlashings
+
+	// EIP-7549: Beginning from Electra, the max attester slashings is reduced to 1.
+	if state.Version() >= version.Electra {
+		maxSlashings = params.BeaconConfig().MaxAttesterSlashingsElectra
+	}
 	if noLimit {
 		maxSlashings = uint64(len(p.pendingAttesterSlashing))
 	}

beacon-chain/operations/slashings/service_attester_test.go

@@ -516,6 +516,70 @@ func TestPool_PendingAttesterSlashings(t *testing.T) {
 	}
 }
 
+func TestPool_PendingAttesterSlashings_AfterElectra(t *testing.T) {
+	type fields struct {
+		pending []*PendingAttesterSlashing
+		all     bool
+	}
+	params.SetupTestConfigCleanup(t)
+	beaconState, privKeys := util.DeterministicGenesisStateElectra(t, 64)
+
+	pendingSlashings := make([]*PendingAttesterSlashing, 20)
+	slashings := make([]ethpb.AttSlashing, 20)
+	for i := 0; i < len(pendingSlashings); i++ {
+		sl, err := util.GenerateAttesterSlashingForValidator(beaconState, privKeys[i], primitives.ValidatorIndex(i))
+		require.NoError(t, err)
+		pendingSlashings[i] = &PendingAttesterSlashing{
+			attesterSlashing: sl,
+			validatorToSlash: primitives.ValidatorIndex(i),
+		}
+		slashings[i] = sl
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []ethpb.AttSlashing
+	}{
+		{
+			name: "Empty list",
+			fields: fields{
+				pending: []*PendingAttesterSlashing{},
+			},
+			want: []ethpb.AttSlashing{},
+		},
+		{
+			name: "All pending",
+			fields: fields{
+				pending: pendingSlashings,
+				all:     true,
+			},
+			want: slashings,
+		},
+		{
+			name: "All eligible",
+			fields: fields{
+				pending: pendingSlashings,
+			},
+			want: slashings[0:1],
+		},
+		{
+			name: "Multiple indices",
+			fields: fields{
+				pending: pendingSlashings[3:6],
+			},
+			want: slashings[3:4],
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &Pool{
+				pendingAttesterSlashing: tt.fields.pending,
+			}
+			assert.DeepEqual(t, tt.want, p.PendingAttesterSlashings(context.Background(), beaconState, tt.fields.all))
+		})
+	}
+}
+
 func TestPool_PendingAttesterSlashings_Slashed(t *testing.T) {
 	type fields struct {
 		pending []*PendingAttesterSlashing

beacon-chain/p2p/encoder/ssz.go

@@ -18,7 +18,6 @@ var _ NetworkEncoding = (*SszNetworkEncoder)(nil)
 // MaxGossipSize allowed for gossip messages.
 var MaxGossipSize = params.BeaconConfig().GossipMaxSize // 10 Mib.
 var MaxChunkSize = params.BeaconConfig().MaxChunkSize   // 10 Mib.
-var MaxUncompressedPayloadSize = 2 * MaxGossipSize      // 20 Mib.
 
 // This pool defines the sync pool for our buffered snappy writers, so that they
 // can be constantly reused.
@@ -44,8 +43,8 @@ func (_ SszNetworkEncoder) EncodeGossip(w io.Writer, msg fastssz.Marshaler) (int
 	if err != nil {
 		return 0, err
 	}
-	if uint64(len(b)) > MaxUncompressedPayloadSize {
-		return 0, errors.Errorf("gossip message exceeds max gossip size: %d bytes > %d bytes", len(b), MaxUncompressedPayloadSize)
+	if uint64(len(b)) > MaxGossipSize {
+		return 0, errors.Errorf("gossip message exceeds max gossip size: %d bytes > %d bytes", len(b), MaxGossipSize)
 	}
 	b = snappy.Encode(nil /*dst*/, b)
 	return w.Write(b)
@@ -82,7 +81,7 @@ func doDecode(b []byte, to fastssz.Unmarshaler) error {
 
 // DecodeGossip decodes the bytes to the protobuf gossip message provided.
 func (_ SszNetworkEncoder) DecodeGossip(b []byte, to fastssz.Unmarshaler) error {
-	b, err := DecodeSnappy(b, MaxUncompressedPayloadSize)
+	b, err := DecodeSnappy(b, MaxGossipSize)
 	if err != nil {
 		return err
 	}

beacon-chain/p2p/encoder/ssz_test.go

@@ -555,7 +555,7 @@ func TestSszNetworkEncoder_FailsSnappyLength(t *testing.T) {
 	e := &encoder.SszNetworkEncoder{}
 	att := &ethpb.Fork{}
 	data := make([]byte, 32)
-	binary.PutUvarint(data, encoder.MaxUncompressedPayloadSize+32)
+	binary.PutUvarint(data, encoder.MaxGossipSize+32)
 	err := e.DecodeGossip(data, att)
 	require.ErrorContains(t, "snappy message exceeds max size", err)
 }

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

@@ -54,7 +54,6 @@ go_test(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
-        "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

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

@@ -1,680 +1 @@
 package lightclient
-
-import (
-	"strings"
-	"testing"
-
-	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	light_client "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-)
-
-// When the update has relevant sync committee
-func createNonEmptySyncCommitteeBranch() [][]byte {
-	res := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
-	res[0] = []byte(strings.Repeat("x", 32))
-	for i := 1; i < len(res); i++ {
-		res[i] = make([]byte, fieldparams.RootLength)
-	}
-	return res
-}
-
-// When the update has finality
-func createNonEmptyFinalityBranch() [][]byte {
-	res := make([][]byte, fieldparams.FinalityBranchDepth)
-	res[0] = []byte(strings.Repeat("x", 32))
-	for i := 1; i < fieldparams.FinalityBranchDepth; i++ {
-		res[i] = make([]byte, 32)
-	}
-	return res
-}
-
-func TestIsBetterUpdate(t *testing.T) {
-	config := params.BeaconConfig()
-	st, err := util.NewBeaconStateAltair()
-	require.NoError(t, err)
-
-	t.Run("new has supermajority but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-		})
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b11111100, 0b1}, // [0,0,1,1,1,1,1,1]
-		})
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("old has supermajority but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b11111100, 0b1}, // [0,0,1,1,1,1,1,1]
-		})
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-		})
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("new doesn't have supermajority and newNumActiveParticipants is greater than oldNumActiveParticipants", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-		})
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("new doesn't have supermajority and newNumActiveParticipants is lesser than oldNumActiveParticipants", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-		})
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("new has relevant sync committee but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000001,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(1000000)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("old has relevant sync committee but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000001,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(1000000)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("new has finality but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("old has finality but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("new has finality and sync committee finality both but old doesn't have sync committee finality", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(999999)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 999999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("new has finality but doesn't have sync committee finality and old has sync committee finality", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(999999)
-		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 999999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("new has more active participants than old", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,1,1,1,1,1,0,0]
-		})
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("new has less active participants than old", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,1,1,1,1,1,0,0]
-		})
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("new's attested header's slot is lesser than old's attested header's slot", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 999999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("new's attested header's slot is greater than old's attested header's slot", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 999999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("none of the above conditions are met and new signature's slot is less than old signature's slot", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9999)
-		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9998)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("none of the above conditions are met and new signature's slot is greater than old signature's slot", func(t *testing.T) {
-		oldUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
-		assert.NoError(t, err)
-		newUpdate, err := lightclient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
-		assert.NoError(t, err)
-
-		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		oldAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetAttestedHeader(oldAttestedHeader)
-		assert.NoError(t, err)
-		err = oldUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		oldUpdate.SetSignatureSlot(9998)
-		oldFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = oldUpdate.SetFinalizedHeader(oldFinalizedHeader)
-		assert.NoError(t, err)
-
-		newUpdate.SetSyncAggregate(&pb.SyncAggregate{
-			SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-		})
-		newAttestedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 1000000,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetAttestedHeader(newAttestedHeader)
-		assert.NoError(t, err)
-		err = newUpdate.SetNextSyncCommitteeBranch(createNonEmptySyncCommitteeBranch())
-		assert.NoError(t, err)
-		newUpdate.SetSignatureSlot(9999)
-		err = newUpdate.SetFinalityBranch(createNonEmptyFinalityBranch())
-		assert.NoError(t, err)
-		newFinalizedHeader, err := light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot: 9999,
-			},
-		})
-		assert.NoError(t, err)
-		err = newUpdate.SetFinalizedHeader(newFinalizedHeader)
-		assert.NoError(t, err)
-
-		result, err := lightclient.IsBetterUpdate(newUpdate, oldUpdate)
-		assert.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -103,6 +103,7 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 		"slot":               req.Slot,
 		"sinceSlotStartTime": time.Since(t),
 		"validator":          sBlk.Block().ProposerIndex(),
+		"err":                err,
 	}).Info("Finished building block")
 	if err != nil {
 		return nil, errors.Wrap(err, "could not build block in parallel")

config/proposer/loader/BUILD.bazel

@@ -13,6 +13,7 @@ go_test(
         "//config/proposer:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//validator/db/iface:go_default_library",

config/proposer/loader/loader.go

@@ -265,6 +265,9 @@ func (psl *settingsLoader) processProposerSettings(loadedSettings, dbSettings *v
 	// process any overrides for proposer config
 	for _, option := range newSettings.ProposerConfig {
 		if option != nil {
+			if loadedSettings != nil && option.Builder != nil {
+				gasLimitOnly = &option.Builder.GasLimit
+			}
 			option.Builder = processBuilderConfig(option.Builder, builderConfig, gasLimitOnly)
 		}
 	}

config/proposer/loader/loader_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/proposer"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	validatorpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/validator-client"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/validator/db/iface"
@@ -499,7 +500,7 @@ func TestProposerSettingsLoader(t *testing.T) {
 							},
 							BuilderConfig: &proposer.BuilderConfig{
 								Enabled:  true,
-								GasLimit: 50000000,
+								GasLimit: 40000000,
 							},
 						},
 					},
@@ -1003,3 +1004,27 @@ func Test_ProposerSettingsLoaderWithOnlyBuilder_DoesNotSaveInDB(t *testing.T) {
 		})
 	}
 }
+
+func Test_settingsLoader_processProposerSettings(t *testing.T) {
+	limit := validator.Uint64(30_000_000)
+	psl := &settingsLoader{
+		options: &flagOptions{
+			gasLimit: &limit,
+		},
+	}
+	loaded := &validatorpb.ProposerSettingsPayload{
+		ProposerConfig: map[string]*validatorpb.ProposerOptionPayload{
+			"bob": {
+				Builder: &validatorpb.BuilderConfig{
+					GasLimit: 40_000_000,
+				},
+			},
+		},
+	}
+	var db *validatorpb.ProposerSettingsPayload
+	got := psl.processProposerSettings(loaded, db)
+	require.NotNil(t, got)
+	for _, payload := range got.ProposerConfig {
+		require.Equal(t, validator.Uint64(40_000_000), payload.Builder.GasLimit)
+	}
+}

deps.bzl

@@ -2824,8 +2824,8 @@ def prysm_deps():
             "gazelle:exclude tools.go",
         ],
         importpath = "github.com/quic-go/quic-go",
-        sum = "h1:2TCyvBrMu1Z25rvIAlnp2dPT4lgh/uTqLqiXVpp5AeU=",
-        version = "v0.48.0",
+        sum = "h1:wsKXZPeGWpMpCGSWqOcqpW2wZYic/8T3aqiOID0/KWE=",
+        version = "v0.48.2",
     )
     go_repository(
         name = "com_github_quic_go_webtransport_go",

go.mod

@@ -233,7 +233,7 @@ require (
 	github.com/prometheus/common v0.55.0 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/quic-go/qpack v0.5.1 // indirect
-	github.com/quic-go/quic-go v0.48.0 // indirect
+	github.com/quic-go/quic-go v0.48.2 // indirect
 	github.com/quic-go/webtransport-go v0.8.1-0.20241018022711-4ac2c9250e66 // indirect
 	github.com/raulk/go-watchdog v1.3.0 // indirect
 	github.com/rivo/uniseg v0.4.4 // indirect

go.sum

@@ -907,8 +907,8 @@ github.com/prysmaticlabs/protoc-gen-go-cast v0.0.0-20230228205207-28762a7b9294 h
 github.com/prysmaticlabs/protoc-gen-go-cast v0.0.0-20230228205207-28762a7b9294/go.mod h1:ZVEbRdnMkGhp/pu35zq4SXxtvUwWK0J1MATtekZpH2Y=
 github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
 github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
-github.com/quic-go/quic-go v0.48.0 h1:2TCyvBrMu1Z25rvIAlnp2dPT4lgh/uTqLqiXVpp5AeU=
-github.com/quic-go/quic-go v0.48.0/go.mod h1:yBgs3rWBOADpga7F+jJsb6Ybg1LSYiQvwWlLX+/6HMs=
+github.com/quic-go/quic-go v0.48.2 h1:wsKXZPeGWpMpCGSWqOcqpW2wZYic/8T3aqiOID0/KWE=
+github.com/quic-go/quic-go v0.48.2/go.mod h1:yBgs3rWBOADpga7F+jJsb6Ybg1LSYiQvwWlLX+/6HMs=
 github.com/quic-go/webtransport-go v0.8.1-0.20241018022711-4ac2c9250e66 h1:4WFk6u3sOT6pLa1kQ50ZVdm8BQFgJNA117cepZxtLIg=
 github.com/quic-go/webtransport-go v0.8.1-0.20241018022711-4ac2c9250e66/go.mod h1:Vp72IJajgeOL6ddqrAhmp7IM9zbTcgkQxD/YdxrVwMw=
 github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0=

testing/spectest/shared/common/forkchoice/runner.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"slices"
 	"strings"
 	"testing"
 
@@ -16,6 +17,7 @@ import (
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -25,6 +27,13 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
+// These are proposer boost spec tests that assume the clock starts 3 seconds into the slot.
+// Example: Tick is 51, which corresponds to 3 seconds into slot 4.
+var proposerBoostTests3s = []string{
+	"proposer_boost_is_first_block",
+	"proposer_boost",
+}
+
 func init() {
 	transition.SkipSlotCache.Disable()
 }
@@ -97,7 +106,18 @@ func runTest(t *testing.T, config string, fork int, basePath string) { // nolint
 
 				for _, step := range steps {
 					if step.Tick != nil {
-						builder.Tick(t, int64(*step.Tick))
+						tick := int64(*step.Tick)
+						// If the test is for proposer boost starting 3 seconds into the slot and the tick aligns with this,
+						// we provide an additional second buffer. Instead of starting 3 seconds into the slot, we start 2 seconds in to avoid missing the proposer boost.
+						// A 1-second buffer has proven insufficient during parallel spec test runs, as the likelihood of missing the proposer boost increases significantly,
+						// often extending to 4 seconds. Starting 2 seconds into the slot ensures close to a 100% pass rate.
+						if slices.Contains(proposerBoostTests3s, folder.Name()) {
+							deadline := params.BeaconConfig().SecondsPerSlot / params.BeaconConfig().IntervalsPerSlot
+							if uint64(tick)%params.BeaconConfig().SecondsPerSlot == deadline-1 {
+								tick--
+							}
+						}
+						builder.Tick(t, tick)
 					}
 					var beaconBlock interfaces.ReadOnlySignedBeaconBlock
 					if step.Block != nil {