Merge branch 'develop' of https://github.com/prysmaticlabs/geth-sharding into exitReconstructionEarly

* refactored code and added in checks for blinded endpoints

* changelog

* cleaning up some comments and error messages

* fixing linting

* adding clarifying comment

beacon-chain/operations/slashings/BUILD.bazel

@@ -6,8 +6,8 @@ go_library(
         "doc.go",
         "log.go",
         "metrics.go",
+        "pool.go",
         "service.go",
-        "service_new.go",
         "types.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/slashings",

beacon-chain/operations/slashings/pool.go

@@ -0,0 +1,324 @@
+package slashings
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	coretime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/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"
+)
+
+// NewPool returns an initialized attester slashing and proposer slashing pool.
+func NewPool() *Pool {
+	return &Pool{
+		pendingProposerSlashing: make([]*ethpb.ProposerSlashing, 0),
+		pendingAttesterSlashing: make([]*PendingAttesterSlashing, 0),
+		included:                make(map[primitives.ValidatorIndex]bool),
+	}
+}
+
+// PendingAttesterSlashings returns attester slashings that are able to be included into a block.
+// This method will return the amount of pending attester slashings for a block transition unless parameter `noLimit` is true
+// to indicate the request is for noLimit pending items.
+func (p *Pool) PendingAttesterSlashings(ctx context.Context, state state.ReadOnlyBeaconState, noLimit bool) []ethpb.AttSlashing {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	_, span := trace.StartSpan(ctx, "operations.PendingAttesterSlashing")
+	defer span.End()
+
+	// Update prom metric.
+	numPendingAttesterSlashings.Set(float64(len(p.pendingAttesterSlashing)))
+
+	included := make(map[primitives.ValidatorIndex]bool)
+
+	// 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))
+	}
+	pending := make([]ethpb.AttSlashing, 0, maxSlashings)
+	for i := 0; i < len(p.pendingAttesterSlashing); i++ {
+		if uint64(len(pending)) >= maxSlashings {
+			break
+		}
+		slashing := p.pendingAttesterSlashing[i]
+		valid, err := p.validatorSlashingPreconditionCheck(state, slashing.validatorToSlash)
+		if err != nil {
+			log.WithError(err).Error("could not validate attester slashing")
+			continue
+		}
+		if included[slashing.validatorToSlash] || !valid {
+			p.pendingAttesterSlashing = append(p.pendingAttesterSlashing[:i], p.pendingAttesterSlashing[i+1:]...)
+			i--
+			continue
+		}
+		attSlashing := slashing.attesterSlashing
+		slashedVal := slice.IntersectionUint64(
+			attSlashing.FirstAttestation().GetAttestingIndices(),
+			attSlashing.SecondAttestation().GetAttestingIndices(),
+		)
+		for _, idx := range slashedVal {
+			included[primitives.ValidatorIndex(idx)] = true
+		}
+
+		pending = append(pending, attSlashing)
+	}
+
+	return pending
+}
+
+// PendingProposerSlashings returns proposer slashings that are able to be included into a block.
+// This method will return the amount of pending proposer slashings for a block transition unless the `noLimit` parameter
+// is set to true to indicate the request is for noLimit pending items.
+func (p *Pool) PendingProposerSlashings(ctx context.Context, state state.ReadOnlyBeaconState, noLimit bool) []*ethpb.ProposerSlashing {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	_, span := trace.StartSpan(ctx, "operations.PendingProposerSlashing")
+	defer span.End()
+
+	// Update prom metric.
+	numPendingProposerSlashings.Set(float64(len(p.pendingProposerSlashing)))
+
+	// Allocate pending slice with a capacity of len(p.pendingProposerSlashing) or maxProposerSlashings depending on the request.
+	maxSlashings := params.BeaconConfig().MaxProposerSlashings
+	if noLimit {
+		maxSlashings = uint64(len(p.pendingProposerSlashing))
+	}
+	pending := make([]*ethpb.ProposerSlashing, 0, maxSlashings)
+	for i := 0; i < len(p.pendingProposerSlashing); i++ {
+		if uint64(len(pending)) >= maxSlashings {
+			break
+		}
+		slashing := p.pendingProposerSlashing[i]
+		valid, err := p.validatorSlashingPreconditionCheck(state, slashing.Header_1.Header.ProposerIndex)
+		if err != nil {
+			log.WithError(err).Error("could not validate proposer slashing")
+			continue
+		}
+		if !valid {
+			p.pendingProposerSlashing = append(p.pendingProposerSlashing[:i], p.pendingProposerSlashing[i+1:]...)
+			i--
+			continue
+		}
+
+		pending = append(pending, slashing)
+	}
+	return pending
+}
+
+// InsertAttesterSlashing into the pool. This method is a no-op if the attester slashing already exists in the pool,
+// has been included into a block recently, or the validator is already exited.
+func (p *Pool) InsertAttesterSlashing(
+	ctx context.Context,
+	state state.ReadOnlyBeaconState,
+	slashing ethpb.AttSlashing,
+) error {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	ctx, span := trace.StartSpan(ctx, "operations.InsertAttesterSlashing")
+	defer span.End()
+
+	if err := blocks.VerifyAttesterSlashing(ctx, state, slashing); err != nil {
+		return errors.Wrap(err, "could not verify attester slashing")
+	}
+
+	slashedVal := slice.IntersectionUint64(slashing.FirstAttestation().GetAttestingIndices(), slashing.SecondAttestation().GetAttestingIndices())
+	cantSlash := make([]uint64, 0, len(slashedVal))
+	slashingReason := ""
+	for _, val := range slashedVal {
+		// Has this validator index been included recently?
+		ok, err := p.validatorSlashingPreconditionCheck(state, primitives.ValidatorIndex(val))
+		if err != nil {
+			return err
+		}
+		// If the validator has already exited, has already been slashed, or if its index
+		// has been recently included in the pool of slashings, skip including this indice.
+		if !ok {
+			slashingReason = "validator already exited/slashed or already recently included in slashings pool"
+			cantSlash = append(cantSlash, val)
+			continue
+		}
+
+		// Check if the validator already exists in the list of slashings.
+		// Use binary search to find the answer.
+		found := sort.Search(len(p.pendingAttesterSlashing), func(i int) bool {
+			return uint64(p.pendingAttesterSlashing[i].validatorToSlash) >= val
+		})
+		if found != len(p.pendingAttesterSlashing) && uint64(p.pendingAttesterSlashing[found].validatorToSlash) == val {
+			slashingReason = "validator already exist in list of pending slashings, no need to attempt to slash again"
+			cantSlash = append(cantSlash, val)
+			continue
+		}
+
+		pendingSlashing := &PendingAttesterSlashing{
+			attesterSlashing: slashing,
+			validatorToSlash: primitives.ValidatorIndex(val),
+		}
+		// Insert into pending list and sort again.
+		p.pendingAttesterSlashing = append(p.pendingAttesterSlashing, pendingSlashing)
+		sort.Slice(p.pendingAttesterSlashing, func(i, j int) bool {
+			return p.pendingAttesterSlashing[i].validatorToSlash < p.pendingAttesterSlashing[j].validatorToSlash
+		})
+		numPendingAttesterSlashings.Set(float64(len(p.pendingAttesterSlashing)))
+	}
+	if len(cantSlash) == len(slashedVal) {
+		return fmt.Errorf(
+			"could not slash any of %d validators in submitted slashing: %s",
+			len(slashedVal),
+			slashingReason,
+		)
+	}
+	return nil
+}
+
+// InsertProposerSlashing into the pool. This method is a no-op if the pending slashing already exists,
+// has been included recently, the validator is already exited, or the validator was already slashed.
+func (p *Pool) InsertProposerSlashing(
+	ctx context.Context,
+	state state.ReadOnlyBeaconState,
+	slashing *ethpb.ProposerSlashing,
+) error {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	_, span := trace.StartSpan(ctx, "operations.InsertProposerSlashing")
+	defer span.End()
+
+	if err := blocks.VerifyProposerSlashing(state, slashing); err != nil {
+		return errors.Wrap(err, "could not verify proposer slashing")
+	}
+
+	idx := slashing.Header_1.Header.ProposerIndex
+	ok, err := p.validatorSlashingPreconditionCheck(state, idx)
+	if err != nil {
+		return err
+	}
+	// If the validator has already exited, has already been slashed, or if its index
+	// has been recently included in the pool of slashings, do not process this new
+	// slashing.
+	if !ok {
+		return fmt.Errorf("validator at index %d cannot be slashed", idx)
+	}
+
+	// Check if the validator already exists in the list of slashings.
+	// Use binary search to find the answer.
+	found := sort.Search(len(p.pendingProposerSlashing), func(i int) bool {
+		return p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex >= slashing.Header_1.Header.ProposerIndex
+	})
+	if found != len(p.pendingProposerSlashing) && p.pendingProposerSlashing[found].Header_1.Header.ProposerIndex ==
+		slashing.Header_1.Header.ProposerIndex {
+		return errors.New("slashing object already exists in pending proposer slashings")
+	}
+
+	// Insert into pending list and sort again.
+	p.pendingProposerSlashing = append(p.pendingProposerSlashing, slashing)
+	sort.Slice(p.pendingProposerSlashing, func(i, j int) bool {
+		return p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex < p.pendingProposerSlashing[j].Header_1.Header.ProposerIndex
+	})
+	numPendingProposerSlashings.Set(float64(len(p.pendingProposerSlashing)))
+
+	return nil
+}
+
+// MarkIncludedAttesterSlashing is used when an attester slashing has been included in a beacon block.
+// Every block seen by this node that contains proposer slashings should call this method to include
+// the proposer slashings.
+func (p *Pool) MarkIncludedAttesterSlashing(as ethpb.AttSlashing) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	slashedVal := slice.IntersectionUint64(as.FirstAttestation().GetAttestingIndices(), as.SecondAttestation().GetAttestingIndices())
+	for _, val := range slashedVal {
+		i := sort.Search(len(p.pendingAttesterSlashing), func(i int) bool {
+			return uint64(p.pendingAttesterSlashing[i].validatorToSlash) >= val
+		})
+		if i != len(p.pendingAttesterSlashing) && uint64(p.pendingAttesterSlashing[i].validatorToSlash) == val {
+			p.pendingAttesterSlashing = append(p.pendingAttesterSlashing[:i], p.pendingAttesterSlashing[i+1:]...)
+		}
+		p.included[primitives.ValidatorIndex(val)] = true
+		numAttesterSlashingsIncluded.Inc()
+	}
+}
+
+// MarkIncludedProposerSlashing is used when an proposer slashing has been included in a beacon block.
+// Every block seen by this node that contains proposer slashings should call this method to include
+// the proposer slashings.
+func (p *Pool) MarkIncludedProposerSlashing(ps *ethpb.ProposerSlashing) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	i := sort.Search(len(p.pendingProposerSlashing), func(i int) bool {
+		return p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex >= ps.Header_1.Header.ProposerIndex
+	})
+	if i != len(p.pendingProposerSlashing) && p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex == ps.Header_1.Header.ProposerIndex {
+		p.pendingProposerSlashing = append(p.pendingProposerSlashing[:i], p.pendingProposerSlashing[i+1:]...)
+	}
+	p.included[ps.Header_1.Header.ProposerIndex] = true
+	numProposerSlashingsIncluded.Inc()
+}
+
+// ConvertToElectra converts all Phase0 attester slashings to Electra attester slashings.
+// This functionality is needed at the time of the Electra fork.
+func (p *Pool) ConvertToElectra() {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+
+	for _, pas := range p.pendingAttesterSlashing {
+		if pas.attesterSlashing.Version() == version.Phase0 {
+			first := pas.attesterSlashing.FirstAttestation()
+			second := pas.attesterSlashing.SecondAttestation()
+			pas.attesterSlashing = &ethpb.AttesterSlashingElectra{
+				Attestation_1: &ethpb.IndexedAttestationElectra{
+					AttestingIndices: first.GetAttestingIndices(),
+					Data:             first.GetData(),
+					Signature:        first.GetSignature(),
+				},
+				Attestation_2: &ethpb.IndexedAttestationElectra{
+					AttestingIndices: second.GetAttestingIndices(),
+					Data:             second.GetData(),
+					Signature:        second.GetSignature(),
+				},
+			}
+		}
+	}
+}
+
+// this function checks a few items about a validator before proceeding with inserting
+// a proposer/attester slashing into the pool. First, it checks if the validator
+// has been recently included in the pool, then it checks if the validator is slashable.
+// Note: this method requires caller to hold the lock.
+func (p *Pool) validatorSlashingPreconditionCheck(
+	state state.ReadOnlyBeaconState,
+	valIdx primitives.ValidatorIndex,
+) (bool, error) {
+	if !mutexasserts.RWMutexLocked(&p.lock) && !mutexasserts.RWMutexRLocked(&p.lock) {
+		return false, errors.New("pool.validatorSlashingPreconditionCheck: caller must hold read/write lock")
+	}
+
+	// Check if the validator index has been included recently.
+	if p.included[valIdx] {
+		return false, nil
+	}
+	validator, err := state.ValidatorAtIndexReadOnly(valIdx)
+	if err != nil {
+		return false, err
+	}
+	// Checking if the validator is slashable.
+	if !helpers.IsSlashableValidatorUsingTrie(validator, coretime.CurrentEpoch(state)) {
+		return false, nil
+	}
+	return true, nil
+}

beacon-chain/operations/slashings/service.go

@@ -2,323 +2,102 @@ package slashings
 
 import (
 	"context"
-	"fmt"
-	"sort"
+	"time"
 
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	coretime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/container/slice"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"github.com/trailofbits/go-mutexasserts"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
-// NewPool returns an initialized attester slashing and proposer slashing pool.
-func NewPool() *Pool {
-	return &Pool{
-		pendingProposerSlashing: make([]*ethpb.ProposerSlashing, 0),
-		pendingAttesterSlashing: make([]*PendingAttesterSlashing, 0),
-		included:                make(map[primitives.ValidatorIndex]bool),
+// WithElectraTimer includes functional options for the blockchain service related to CLI flags.
+func WithElectraTimer(cw startup.ClockWaiter, currentSlotFn func() primitives.Slot) Option {
+	return func(p *PoolService) error {
+		p.runElectraTimer = true
+		p.cw = cw
+		p.currentSlotFn = currentSlotFn
+		return nil
 	}
 }
 
-// PendingAttesterSlashings returns attester slashings that are able to be included into a block.
-// This method will return the amount of pending attester slashings for a block transition unless parameter `noLimit` is true
-// to indicate the request is for noLimit pending items.
-func (p *Pool) PendingAttesterSlashings(ctx context.Context, state state.ReadOnlyBeaconState, noLimit bool) []ethpb.AttSlashing {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	_, span := trace.StartSpan(ctx, "operations.PendingAttesterSlashing")
-	defer span.End()
-
-	// Update prom metric.
-	numPendingAttesterSlashings.Set(float64(len(p.pendingAttesterSlashing)))
-
-	included := make(map[primitives.ValidatorIndex]bool)
-
-	// 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))
-	}
-	pending := make([]ethpb.AttSlashing, 0, maxSlashings)
-	for i := 0; i < len(p.pendingAttesterSlashing); i++ {
-		if uint64(len(pending)) >= maxSlashings {
-			break
-		}
-		slashing := p.pendingAttesterSlashing[i]
-		valid, err := p.validatorSlashingPreconditionCheck(state, slashing.validatorToSlash)
-		if err != nil {
-			log.WithError(err).Error("could not validate attester slashing")
-			continue
-		}
-		if included[slashing.validatorToSlash] || !valid {
-			p.pendingAttesterSlashing = append(p.pendingAttesterSlashing[:i], p.pendingAttesterSlashing[i+1:]...)
-			i--
-			continue
-		}
-		attSlashing := slashing.attesterSlashing
-		slashedVal := slice.IntersectionUint64(
-			attSlashing.FirstAttestation().GetAttestingIndices(),
-			attSlashing.SecondAttestation().GetAttestingIndices(),
-		)
-		for _, idx := range slashedVal {
-			included[primitives.ValidatorIndex(idx)] = true
-		}
-
-		pending = append(pending, attSlashing)
+// NewPoolService returns a service that manages the Pool.
+func NewPoolService(ctx context.Context, pool PoolManager, opts ...Option) *PoolService {
+	ctx, cancel := context.WithCancel(ctx)
+	p := &PoolService{
+		ctx:         ctx,
+		cancel:      cancel,
+		poolManager: pool,
 	}
 
-	return pending
+	for _, opt := range opts {
+		if err := opt(p); err != nil {
+			return nil
+		}
+	}
+
+	return p
 }
 
-// PendingProposerSlashings returns proposer slashings that are able to be included into a block.
-// This method will return the amount of pending proposer slashings for a block transition unless the `noLimit` parameter
-// is set to true to indicate the request is for noLimit pending items.
-func (p *Pool) PendingProposerSlashings(ctx context.Context, state state.ReadOnlyBeaconState, noLimit bool) []*ethpb.ProposerSlashing {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	_, span := trace.StartSpan(ctx, "operations.PendingProposerSlashing")
-	defer span.End()
-
-	// Update prom metric.
-	numPendingProposerSlashings.Set(float64(len(p.pendingProposerSlashing)))
-
-	// Allocate pending slice with a capacity of len(p.pendingProposerSlashing) or maxProposerSlashings depending on the request.
-	maxSlashings := params.BeaconConfig().MaxProposerSlashings
-	if noLimit {
-		maxSlashings = uint64(len(p.pendingProposerSlashing))
-	}
-	pending := make([]*ethpb.ProposerSlashing, 0, maxSlashings)
-	for i := 0; i < len(p.pendingProposerSlashing); i++ {
-		if uint64(len(pending)) >= maxSlashings {
-			break
-		}
-		slashing := p.pendingProposerSlashing[i]
-		valid, err := p.validatorSlashingPreconditionCheck(state, slashing.Header_1.Header.ProposerIndex)
-		if err != nil {
-			log.WithError(err).Error("could not validate proposer slashing")
-			continue
-		}
-		if !valid {
-			p.pendingProposerSlashing = append(p.pendingProposerSlashing[:i], p.pendingProposerSlashing[i+1:]...)
-			i--
-			continue
-		}
-
-		pending = append(pending, slashing)
-	}
-	return pending
+// Start the slashing pool service.
+func (p *PoolService) Start() {
+	go p.run()
 }
 
-// InsertAttesterSlashing into the pool. This method is a no-op if the attester slashing already exists in the pool,
-// has been included into a block recently, or the validator is already exited.
-func (p *Pool) InsertAttesterSlashing(
-	ctx context.Context,
-	state state.ReadOnlyBeaconState,
-	slashing ethpb.AttSlashing,
-) error {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	ctx, span := trace.StartSpan(ctx, "operations.InsertAttesterSlashing")
-	defer span.End()
-
-	if err := blocks.VerifyAttesterSlashing(ctx, state, slashing); err != nil {
-		return errors.Wrap(err, "could not verify attester slashing")
+func (p *PoolService) run() {
+	if !p.runElectraTimer {
+		return
 	}
 
-	slashedVal := slice.IntersectionUint64(slashing.FirstAttestation().GetAttestingIndices(), slashing.SecondAttestation().GetAttestingIndices())
-	cantSlash := make([]uint64, 0, len(slashedVal))
-	slashingReason := ""
-	for _, val := range slashedVal {
-		// Has this validator index been included recently?
-		ok, err := p.validatorSlashingPreconditionCheck(state, primitives.ValidatorIndex(val))
-		if err != nil {
-			return err
-		}
-		// If the validator has already exited, has already been slashed, or if its index
-		// has been recently included in the pool of slashings, skip including this indice.
-		if !ok {
-			slashingReason = "validator already exited/slashed or already recently included in slashings pool"
-			cantSlash = append(cantSlash, val)
-			continue
-		}
-
-		// Check if the validator already exists in the list of slashings.
-		// Use binary search to find the answer.
-		found := sort.Search(len(p.pendingAttesterSlashing), func(i int) bool {
-			return uint64(p.pendingAttesterSlashing[i].validatorToSlash) >= val
-		})
-		if found != len(p.pendingAttesterSlashing) && uint64(p.pendingAttesterSlashing[found].validatorToSlash) == val {
-			slashingReason = "validator already exist in list of pending slashings, no need to attempt to slash again"
-			cantSlash = append(cantSlash, val)
-			continue
-		}
-
-		pendingSlashing := &PendingAttesterSlashing{
-			attesterSlashing: slashing,
-			validatorToSlash: primitives.ValidatorIndex(val),
-		}
-		// Insert into pending list and sort again.
-		p.pendingAttesterSlashing = append(p.pendingAttesterSlashing, pendingSlashing)
-		sort.Slice(p.pendingAttesterSlashing, func(i, j int) bool {
-			return p.pendingAttesterSlashing[i].validatorToSlash < p.pendingAttesterSlashing[j].validatorToSlash
-		})
-		numPendingAttesterSlashings.Set(float64(len(p.pendingAttesterSlashing)))
+	electraSlot, err := slots.EpochStart(params.BeaconConfig().ElectraForkEpoch)
+	if err != nil {
+		return
 	}
-	if len(cantSlash) == len(slashedVal) {
-		return fmt.Errorf(
-			"could not slash any of %d validators in submitted slashing: %s",
-			len(slashedVal),
-			slashingReason,
-		)
+
+	// If run() is executed after the transition to Electra has already happened,
+	// there is nothing to convert because the slashing pool is empty at startup.
+	if p.currentSlotFn() >= electraSlot {
+		return
 	}
+
+	p.waitForChainInitialization()
+
+	electraTime, err := slots.ToTime(uint64(p.clock.GenesisTime().Unix()), electraSlot)
+	if err != nil {
+		return
+	}
+
+	t := time.NewTimer(electraTime.Sub(p.clock.Now()))
+	defer t.Stop()
+
+	select {
+	case <-t.C:
+		log.Info("Converting Phase0 slashings to Electra slashings")
+		p.poolManager.ConvertToElectra()
+		return
+	case <-p.ctx.Done():
+		log.Warn("Context cancelled, ConvertToElectra timer will not execute")
+		return
+	}
+}
+
+func (p *PoolService) waitForChainInitialization() {
+	clock, err := p.cw.WaitForClock(p.ctx)
+	if err != nil {
+		log.WithError(err).Error("Could not receive chain start notification")
+	}
+	p.clock = clock
+	log.WithField("genesisTime", clock.GenesisTime()).Info(
+		"Slashing pool service received chain initialization event",
+	)
+}
+
+// Stop the slashing pool service.
+func (p *PoolService) Stop() error {
+	p.cancel()
 	return nil
 }
 
-// InsertProposerSlashing into the pool. This method is a no-op if the pending slashing already exists,
-// has been included recently, the validator is already exited, or the validator was already slashed.
-func (p *Pool) InsertProposerSlashing(
-	ctx context.Context,
-	state state.ReadOnlyBeaconState,
-	slashing *ethpb.ProposerSlashing,
-) error {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	_, span := trace.StartSpan(ctx, "operations.InsertProposerSlashing")
-	defer span.End()
-
-	if err := blocks.VerifyProposerSlashing(state, slashing); err != nil {
-		return errors.Wrap(err, "could not verify proposer slashing")
-	}
-
-	idx := slashing.Header_1.Header.ProposerIndex
-	ok, err := p.validatorSlashingPreconditionCheck(state, idx)
-	if err != nil {
-		return err
-	}
-	// If the validator has already exited, has already been slashed, or if its index
-	// has been recently included in the pool of slashings, do not process this new
-	// slashing.
-	if !ok {
-		return fmt.Errorf("validator at index %d cannot be slashed", idx)
-	}
-
-	// Check if the validator already exists in the list of slashings.
-	// Use binary search to find the answer.
-	found := sort.Search(len(p.pendingProposerSlashing), func(i int) bool {
-		return p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex >= slashing.Header_1.Header.ProposerIndex
-	})
-	if found != len(p.pendingProposerSlashing) && p.pendingProposerSlashing[found].Header_1.Header.ProposerIndex ==
-		slashing.Header_1.Header.ProposerIndex {
-		return errors.New("slashing object already exists in pending proposer slashings")
-	}
-
-	// Insert into pending list and sort again.
-	p.pendingProposerSlashing = append(p.pendingProposerSlashing, slashing)
-	sort.Slice(p.pendingProposerSlashing, func(i, j int) bool {
-		return p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex < p.pendingProposerSlashing[j].Header_1.Header.ProposerIndex
-	})
-	numPendingProposerSlashings.Set(float64(len(p.pendingProposerSlashing)))
-
+// Status of the slashing pool service.
+func (p *PoolService) Status() error {
 	return nil
 }
-
-// MarkIncludedAttesterSlashing is used when an attester slashing has been included in a beacon block.
-// Every block seen by this node that contains proposer slashings should call this method to include
-// the proposer slashings.
-func (p *Pool) MarkIncludedAttesterSlashing(as ethpb.AttSlashing) {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	slashedVal := slice.IntersectionUint64(as.FirstAttestation().GetAttestingIndices(), as.SecondAttestation().GetAttestingIndices())
-	for _, val := range slashedVal {
-		i := sort.Search(len(p.pendingAttesterSlashing), func(i int) bool {
-			return uint64(p.pendingAttesterSlashing[i].validatorToSlash) >= val
-		})
-		if i != len(p.pendingAttesterSlashing) && uint64(p.pendingAttesterSlashing[i].validatorToSlash) == val {
-			p.pendingAttesterSlashing = append(p.pendingAttesterSlashing[:i], p.pendingAttesterSlashing[i+1:]...)
-		}
-		p.included[primitives.ValidatorIndex(val)] = true
-		numAttesterSlashingsIncluded.Inc()
-	}
-}
-
-// MarkIncludedProposerSlashing is used when an proposer slashing has been included in a beacon block.
-// Every block seen by this node that contains proposer slashings should call this method to include
-// the proposer slashings.
-func (p *Pool) MarkIncludedProposerSlashing(ps *ethpb.ProposerSlashing) {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	i := sort.Search(len(p.pendingProposerSlashing), func(i int) bool {
-		return p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex >= ps.Header_1.Header.ProposerIndex
-	})
-	if i != len(p.pendingProposerSlashing) && p.pendingProposerSlashing[i].Header_1.Header.ProposerIndex == ps.Header_1.Header.ProposerIndex {
-		p.pendingProposerSlashing = append(p.pendingProposerSlashing[:i], p.pendingProposerSlashing[i+1:]...)
-	}
-	p.included[ps.Header_1.Header.ProposerIndex] = true
-	numProposerSlashingsIncluded.Inc()
-}
-
-// ConvertToElectra converts all Phase0 attester slashings to Electra attester slashings.
-// This functionality is needed at the time of the Electra fork.
-func (p *Pool) ConvertToElectra() {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	for _, pas := range p.pendingAttesterSlashing {
-		if pas.attesterSlashing.Version() == version.Phase0 {
-			first := pas.attesterSlashing.FirstAttestation()
-			second := pas.attesterSlashing.SecondAttestation()
-			pas.attesterSlashing = &ethpb.AttesterSlashingElectra{
-				Attestation_1: &ethpb.IndexedAttestationElectra{
-					AttestingIndices: first.GetAttestingIndices(),
-					Data:             first.GetData(),
-					Signature:        first.GetSignature(),
-				},
-				Attestation_2: &ethpb.IndexedAttestationElectra{
-					AttestingIndices: second.GetAttestingIndices(),
-					Data:             second.GetData(),
-					Signature:        second.GetSignature(),
-				},
-			}
-		}
-	}
-}
-
-// this function checks a few items about a validator before proceeding with inserting
-// a proposer/attester slashing into the pool. First, it checks if the validator
-// has been recently included in the pool, then it checks if the validator is slashable.
-// Note: this method requires caller to hold the lock.
-func (p *Pool) validatorSlashingPreconditionCheck(
-	state state.ReadOnlyBeaconState,
-	valIdx primitives.ValidatorIndex,
-) (bool, error) {
-	if !mutexasserts.RWMutexLocked(&p.lock) && !mutexasserts.RWMutexRLocked(&p.lock) {
-		return false, errors.New("pool.validatorSlashingPreconditionCheck: caller must hold read/write lock")
-	}
-
-	// Check if the validator index has been included recently.
-	if p.included[valIdx] {
-		return false, nil
-	}
-	validator, err := state.ValidatorAtIndexReadOnly(valIdx)
-	if err != nil {
-		return false, err
-	}
-	// Checking if the validator is slashable.
-	if !helpers.IsSlashableValidatorUsingTrie(validator, coretime.CurrentEpoch(state)) {
-		return false, nil
-	}
-	return true, nil
-}

beacon-chain/operations/slashings/service_new.go

@@ -1,103 +0,0 @@
-package slashings
-
-import (
-	"context"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-)
-
-// WithElectraTimer includes functional options for the blockchain service related to CLI flags.
-func WithElectraTimer(cw startup.ClockWaiter, currentSlotFn func() primitives.Slot) Option {
-	return func(p *PoolService) error {
-		p.runElectraTimer = true
-		p.cw = cw
-		p.currentSlotFn = currentSlotFn
-		return nil
-	}
-}
-
-// NewPoolService returns a service that manages the Pool.
-func NewPoolService(ctx context.Context, pool PoolManager, opts ...Option) *PoolService {
-	ctx, cancel := context.WithCancel(ctx)
-	p := &PoolService{
-		ctx:         ctx,
-		cancel:      cancel,
-		poolManager: pool,
-	}
-
-	for _, opt := range opts {
-		if err := opt(p); err != nil {
-			return nil
-		}
-	}
-
-	return p
-}
-
-// Start the slashing pool service.
-func (p *PoolService) Start() {
-	go p.run()
-}
-
-func (p *PoolService) run() {
-	if !p.runElectraTimer {
-		return
-	}
-
-	electraSlot, err := slots.EpochStart(params.BeaconConfig().ElectraForkEpoch)
-	if err != nil {
-		return
-	}
-
-	// If run() is executed after the transition to Electra has already happened,
-	// there is nothing to convert because the slashing pool is empty at startup.
-	if p.currentSlotFn() >= electraSlot {
-		return
-	}
-
-	p.waitForChainInitialization()
-
-	electraTime, err := slots.ToTime(uint64(p.clock.GenesisTime().Unix()), electraSlot)
-	if err != nil {
-		return
-	}
-
-	t := time.NewTimer(electraTime.Sub(p.clock.Now()))
-	defer t.Stop()
-
-	select {
-	case <-t.C:
-		log.Info("Converting Phase0 slashings to Electra slashings")
-		p.poolManager.ConvertToElectra()
-		return
-	case <-p.ctx.Done():
-		log.Warn("Context cancelled, ConvertToElectra timer will not execute")
-		return
-	}
-}
-
-func (p *PoolService) waitForChainInitialization() {
-	clock, err := p.cw.WaitForClock(p.ctx)
-	if err != nil {
-		log.WithError(err).Error("Could not receive chain start notification")
-	}
-	p.clock = clock
-	log.WithField("genesisTime", clock.GenesisTime()).Info(
-		"Slashing pool service received chain initialization event",
-	)
-}
-
-// Stop the slashing pool service.
-func (p *PoolService) Stop() error {
-	p.cancel()
-	return nil
-}
-
-// Status of the slashing pool service.
-func (p *PoolService) Status() error {
-	return nil
-}

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

@@ -1528,7 +1528,7 @@ func TestPublishBlock(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Phase0)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Phase0)), writer.Body.String())
 	})
 	t.Run("Fulu", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
@@ -1564,7 +1564,7 @@ func TestPublishBlock(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -1577,7 +1577,7 @@ func TestPublishBlock(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("syncing", func(t *testing.T) {
 		chainService := &chainMock.ChainService{}
@@ -1612,6 +1612,20 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, version.String(version.Fulu), versionHead)
 	})
+	t.Run("Blinded Fulu block returns fulu header", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.FuluForkEpoch = 7
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+		var signedblock *structs.SignedBlindedBeaconBlockFulu
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock))
+		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().FuluForkEpoch))
+		newBlock, err := json.Marshal(signedblock)
+		require.NoError(t, err)
+		versionHead, err := versionHeaderFromRequest(newBlock)
+		require.NoError(t, err)
+		require.Equal(t, version.String(version.Fulu), versionHead)
+	})
 	t.Run("Electra block contents returns electra header", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
 		cfg.ElectraForkEpoch = 6
@@ -1626,6 +1640,20 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, version.String(version.Electra), versionHead)
 	})
+	t.Run("Blinded Electra block returns electra header", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.ElectraForkEpoch = 6
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+		var signedblock *structs.SignedBlindedBeaconBlockElectra
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock))
+		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().ElectraForkEpoch))
+		newBlock, err := json.Marshal(signedblock)
+		require.NoError(t, err)
+		versionHead, err := versionHeaderFromRequest(newBlock)
+		require.NoError(t, err)
+		require.Equal(t, version.String(version.Electra), versionHead)
+	})
 	t.Run("Deneb block contents returns deneb header", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
 		cfg.DenebForkEpoch = 5
@@ -1640,7 +1668,21 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, version.String(version.Deneb), versionHead)
 	})
-	t.Run("Capella block returns capella header", func(t *testing.T) {
+	t.Run("Blinded Deneb block returns Deneb header", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.DenebForkEpoch = 5
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+		var signedblock *structs.SignedBlindedBeaconBlockDeneb
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedDenebBlock), &signedblock))
+		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().DenebForkEpoch))
+		newBlock, err := json.Marshal(signedblock)
+		require.NoError(t, err)
+		versionHead, err := versionHeaderFromRequest(newBlock)
+		require.NoError(t, err)
+		require.Equal(t, version.String(version.Deneb), versionHead)
+	})
+	t.Run("Capella block returns Capella header", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
 		cfg.CapellaForkEpoch = 4
 		params.OverrideBeaconConfig(cfg)
@@ -1654,6 +1696,20 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, version.String(version.Capella), versionHead)
 	})
+	t.Run("Blinded Capella block returns Capella header", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.CapellaForkEpoch = 4
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+		var signedblock *structs.SignedBlindedBeaconBlockCapella
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedCapellaBlock), &signedblock))
+		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().CapellaForkEpoch))
+		newBlock, err := json.Marshal(signedblock)
+		require.NoError(t, err)
+		versionHead, err := versionHeaderFromRequest(newBlock)
+		require.NoError(t, err)
+		require.Equal(t, version.String(version.Capella), versionHead)
+	})
 	t.Run("Bellatrix block returns capella header", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
 		cfg.BellatrixForkEpoch = 3
@@ -1668,6 +1724,20 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, version.String(version.Bellatrix), versionHead)
 	})
+	t.Run("Blinded Capella block returns Capella header", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.BellatrixForkEpoch = 3
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+		var signedblock *structs.SignedBlindedBeaconBlockBellatrix
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedBellatrixBlock), &signedblock))
+		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().BellatrixForkEpoch))
+		newBlock, err := json.Marshal(signedblock)
+		require.NoError(t, err)
+		versionHead, err := versionHeaderFromRequest(newBlock)
+		require.NoError(t, err)
+		require.Equal(t, version.String(version.Bellatrix), versionHead)
+	})
 	t.Run("Altair block returns capella header", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
 		cfg.AltairForkEpoch = 2
@@ -1909,7 +1979,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -1930,7 +2000,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("syncing", func(t *testing.T) {
 		chainService := &chainMock.ChainService{}
@@ -2072,12 +2142,11 @@ func TestPublishBlindedBlock(t *testing.T) {
 	t.Run("Blinded Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock.Message)
 			return ok
@@ -2094,6 +2163,52 @@ func TestPublishBlindedBlock(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Blinded Electra block without version header succeeds", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.ElectraForkEpoch = 6
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+		var signedblock *structs.SignedBlindedBeaconBlockElectra
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock))
+		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().ElectraForkEpoch))
+		newBlock, err := json.Marshal(signedblock)
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal(newBlock, &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock.Message)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(newBlock))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
+	t.Run("Blinded Electra block without version header on wrong fork", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		// block is sent with slot == 1 which means it's in the phase0 fork
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Phase0)), writer.Body.String())
+	})
 	t.Run("Blinded Fulu", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
@@ -2129,7 +2244,7 @@ func TestPublishBlindedBlock(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -2142,7 +2257,7 @@ func TestPublishBlindedBlock(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("syncing", func(t *testing.T) {
 		chainService := &chainMock.ChainService{}
@@ -2366,7 +2481,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -2387,7 +2502,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("syncing", func(t *testing.T) {
 		chainService := &chainMock.ChainService{}
@@ -2585,7 +2700,7 @@ func TestPublishBlockV2(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block:", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block:", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -2598,7 +2713,7 @@ func TestPublishBlockV2(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block:", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block:", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("missing version header", func(t *testing.T) {
 		server := &Server{
@@ -2842,7 +2957,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -2863,7 +2978,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("missing version header", func(t *testing.T) {
 		server := &Server{
@@ -3018,12 +3133,11 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 	t.Run("Blinded Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock.Message)
 			return ok
@@ -3075,7 +3189,7 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block:", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block:", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -3088,7 +3202,7 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("missing version header", func(t *testing.T) {
 		server := &Server{
@@ -3324,7 +3438,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Bellatrix)), writer.Body.String())
 	})
 	t.Run("wrong version header", func(t *testing.T) {
 		server := &Server{
@@ -3345,7 +3459,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		assert.StringContains(t, fmt.Sprintf("Could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
+		assert.StringContains(t, fmt.Sprintf("could not decode request body into %s consensus block", version.String(version.Capella)), writer.Body.String())
 	})
 	t.Run("missing version header", func(t *testing.T) {
 		server := &Server{

beacon-chain/sync/rpc_send_request_test.go

@@ -810,4 +810,70 @@ func TestSendBlobsByRangeRequest(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, int(totalExpectedBlobs), len(blobs))
 	})
+
+	t.Run("Starting from Electra", func(t *testing.T) {
+		cfg := params.BeaconConfig()
+		cfg.ElectraForkEpoch = cfg.DenebForkEpoch + 1
+		undo, err := params.SetActiveWithUndo(cfg)
+		require.NoError(t, err)
+		defer func() {
+			require.NoError(t, undo())
+		}()
+
+		s := uint64(slots.UnsafeEpochStart(params.BeaconConfig().ElectraForkEpoch)) * params.BeaconConfig().SecondsPerSlot
+		clock := startup.NewClock(time.Now().Add(-time.Second*time.Duration(s)), [32]byte{})
+		ctxByte, err := ContextByteVersionsForValRoot(clock.GenesisValidatorsRoot())
+		require.NoError(t, err)
+		// Setup peers
+		p1 := p2ptest.NewTestP2P(t)
+		p2 := p2ptest.NewTestP2P(t)
+		p1.Connect(p2)
+
+		slot := slots.UnsafeEpochStart(params.BeaconConfig().ElectraForkEpoch)
+		// Create a simple handler that will return a valid response.
+		p2.SetStreamHandler(topic, func(stream network.Stream) {
+			defer func() {
+				assert.NoError(t, stream.Close())
+			}()
+
+			req := &ethpb.BlobSidecarsByRangeRequest{}
+			assert.NoError(t, p2.Encoding().DecodeWithMaxLength(stream, req))
+			assert.Equal(t, slot, req.StartSlot)
+			assert.Equal(t, uint64(params.BeaconConfig().SlotsPerEpoch)*3, req.Count)
+
+			// Create a sequential set of blobs with the appropriate header information.
+			var prevRoot [32]byte
+			for i := req.StartSlot; i < req.StartSlot+primitives.Slot(req.Count); i++ {
+				maxBlobsForSlot := cfg.MaxBlobsPerBlock(i)
+				parentRoot := prevRoot
+				header := util.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{})
+				header.Header.Slot = i
+				header.Header.ParentRoot = parentRoot[:]
+				bRoot, err := header.Header.HashTreeRoot()
+				require.NoError(t, err)
+				prevRoot = bRoot
+				// Send the maximum possible blobs per slot.
+				for j := 0; j < maxBlobsForSlot; j++ {
+					b := util.HydrateBlobSidecar(&ethpb.BlobSidecar{})
+					b.SignedBlockHeader = header
+					b.Index = uint64(j)
+					ro, err := blocks.NewROBlob(b)
+					require.NoError(t, err)
+					vro := blocks.NewVerifiedROBlob(ro)
+					assert.NoError(t, WriteBlobSidecarChunk(stream, clock, p2.Encoding(), vro))
+				}
+			}
+		})
+		req := &ethpb.BlobSidecarsByRangeRequest{
+			StartSlot: slot,
+			Count:     uint64(params.BeaconConfig().SlotsPerEpoch) * 3,
+		}
+
+		maxElectraBlobs := cfg.MaxBlobsPerBlockAtEpoch(cfg.ElectraForkEpoch)
+		totalElectraBlobs := primitives.Slot(maxElectraBlobs) * 3 * params.BeaconConfig().SlotsPerEpoch
+
+		blobs, err := SendBlobsByRangeRequest(ctx, clock, p1, p2.PeerID(), ctxByte, req)
+		assert.NoError(t, err)
+		assert.Equal(t, int(totalElectraBlobs), len(blobs))
+	})
 }

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -87,11 +87,24 @@ func (s *Service) reconstructAndBroadcastBlobs(ctx context.Context, block interf
 		log.WithError(err).Error("Failed to read commitments from block")
 		return
 	}
+	// Exit early if there are no commitments in block.
+	if len(cmts) == 0 {
+		return
+	}
+
+	var blobUnseen bool
 	for i := range cmts {
 		if summary.HasIndex(uint64(i)) {
 			blobExistedInDBTotal.Inc()
+		} else {
+			blobUnseen = true
 		}
 	}
+	// If all blobs have been seen via gossip, we can exit the reconstruction
+	// routine early as there is nothing to fetch from the EL.
+	if !blobUnseen {
+		return
+	}
 
 	// Reconstruct blob sidecars from the EL
 	blobSidecars, err := s.cfg.executionReconstructor.ReconstructBlobSidecars(ctx, block, blockRoot, summary.HasIndex)

changelog/james-prysm_blockv2-cognit.md

@@ -0,0 +1,4 @@
+### Fixed
+
+- refactored publish block and block ssz functions to fix gocognit 
+- refactored publish blinded block and blinded block ssz to correctly deal with version headers and sent blocks

changelog/james-prysm_dynamic-max-blobs.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- fixed max and target blob per block from static to dynamic values

changelog/nisdas_exit_reconstruction_early.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Exit Blob Reconstruction early in the event we have already seen them.

changelog/radek_rename-slashing-files.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Rename files in `beacon-chain/operations/slashings`.

changelog/tt_blob_by_range_electra_test.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Add blobs by range electra test

config/params/config.go

@@ -387,7 +387,7 @@ func (b *BeaconChainConfig) MaximumGossipClockDisparityDuration() time.Duration
 // TargetBlobsPerBlock returns the target number of blobs per block for the given slot,
 // accounting for changes introduced by the Electra fork.
 func (b *BeaconChainConfig) TargetBlobsPerBlock(slot primitives.Slot) int {
-	if primitives.Epoch(slot.DivSlot(32)) >= b.ElectraForkEpoch {
+	if primitives.Epoch(slot.DivSlot(b.SlotsPerEpoch)) >= b.ElectraForkEpoch {
 		return b.DeprecatedTargetBlobsPerBlockElectra
 	}
 	return b.DeprecatedMaxBlobsPerBlock / 2
@@ -396,7 +396,7 @@ func (b *BeaconChainConfig) TargetBlobsPerBlock(slot primitives.Slot) int {
 // MaxBlobsPerBlock returns the maximum number of blobs per block for the given slot,
 // adjusting for the Electra fork.
 func (b *BeaconChainConfig) MaxBlobsPerBlock(slot primitives.Slot) int {
-	if primitives.Epoch(slot.DivSlot(32)) >= b.ElectraForkEpoch {
+	if primitives.Epoch(slot.DivSlot(b.SlotsPerEpoch)) >= b.ElectraForkEpoch {
 		return b.DeprecatedMaxBlobsPerBlockElectra
 	}
 	return b.DeprecatedMaxBlobsPerBlock