Broadcast Proposer Slashing on equivocation

beacon-chain/sync/BUILD.bazel

@@ -211,6 +211,7 @@ go_test(
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
+        "//beacon-chain/operations/slashings/mock:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",

beacon-chain/sync/validate_beacon_blocks.go

@@ -23,6 +23,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -99,6 +100,10 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 
 	// Verify the block is the first block received for the proposer for the slot.
 	if s.hasSeenBlockIndexSlot(blk.Block().Slot(), blk.Block().ProposerIndex()) {
+		// Attempt to detect and broadcast equivocation before ignoring
+		if err := s.detectAndBroadcastEquivocation(ctx, blk); err != nil {
+			log.WithError(err).Debug("Could not detect/broadcast equivocation")
+		}
 		return pubsub.ValidationIgnore, nil
 	}
 
@@ -456,3 +461,75 @@ func getBlockFields(b interfaces.ReadOnlySignedBeaconBlock) logrus.Fields {
 		"version":       b.Block().Version(),
 	}
 }
+
+// detectAndBroadcastEquivocation checks if the given block is an equivocating block (i.e. a different block
+// with the same slot and proposer index but different signature than one we've already seen). If an equivocation
+// is detected, it creates a proposer slashing object and broadcasts it to the network before adding it to the
+// slashing pool.
+func (s *Service) detectAndBroadcastEquivocation(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) error {
+	// If we've seen this proposer/slot combo before, it means this is an equivocating block
+	slot := blk.Block().Slot()
+	proposerIndex := blk.Block().ProposerIndex()
+
+	// Get the head state for block verification
+	headState, err := s.cfg.chain.HeadStateReadOnly(ctx)
+	if err != nil {
+		return err
+	}
+
+	sig1 := blk.Signature()
+	s.seenBlockLock.RLock()
+	// Create a unique cache key by combining slot and proposer index
+	// Convert slot and proposer index to 32 bytes and combine them into a single byte slice
+	b := append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(proposerIndex))...)
+	existingBlock, isSeen := s.seenBlockCache.Get(string(b))
+	s.seenBlockLock.RUnlock()
+
+	if !isSeen {
+		return nil
+	}
+
+	// Type assert to get the existing block
+	existingSignedBlock, ok := existingBlock.(interfaces.ReadOnlySignedBeaconBlock)
+	if !ok {
+		return errors.New("invalid type assertion for existing block")
+	}
+
+	sig2 := existingSignedBlock.Signature()
+
+	// Different signatures indicate equivocation
+	if sig1 != sig2 {
+		header1, err := blk.Header()
+		if err != nil {
+			return err
+		}
+		header2, err := existingSignedBlock.Header()
+		if err != nil {
+			return err
+		}
+
+		slashing := &ethpb.ProposerSlashing{
+			Header_1: header1,
+			Header_2: header2,
+		}
+
+		// Verify the proposer slashing is valid
+		if err := blocks.VerifyProposerSlashing(headState, slashing); err != nil {
+			return err
+		}
+
+		// Broadcast if verification passes
+		if !features.Get().DisableBroadcastSlashings {
+			if err := s.cfg.p2p.Broadcast(ctx, slashing); err != nil {
+				return errors.Wrap(err, "could not broadcast slashing object")
+			}
+		}
+
+		// Also insert into slashing pool
+		if err := s.cfg.slashingPool.InsertProposerSlashing(ctx, headState, slashing); err != nil {
+			return errors.Wrap(err, "could not insert proposer slashing into pool")
+		}
+	}
+
+	return nil
+}

beacon-chain/sync/validate_beacon_blocks_test.go

@@ -21,6 +21,7 @@ import (
 	dbtest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
+	slashingsmock "github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/slashings/mock"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	p2ptest "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
@@ -1495,3 +1496,136 @@ func Test_validateDenebBeaconBlock(t *testing.T) {
 	require.NoError(t, err)
 	require.ErrorIs(t, validateDenebBeaconBlock(bdb.Block()), errRejectCommitmentLen)
 }
+
+func TestDetectAndBroadcastEquivocation_NoEquivocation(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+	beaconState, privKeys := util.DeterministicGenesisState(t, 100)
+
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 1
+	block.Block.ProposerIndex = 0
+
+	sig, err := signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+	require.NoError(t, err)
+	block.Signature = sig
+
+	chainService := &mock.ChainService{
+		State:   beaconState,
+		Genesis: time.Now(),
+	}
+
+	slashingPool := &slashingsmock.PoolMock{}
+	r := &Service{
+		cfg: &config{
+			p2p:          p,
+			chain:        chainService,
+			slashingPool: slashingPool,
+		},
+		seenBlockCache: lruwrpr.New(10),
+	}
+
+	b, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(t, err)
+
+	err = r.detectAndBroadcastEquivocation(ctx, b)
+	assert.NoError(t, err)
+	assert.Equal(t, 0, len(slashingPool.PendingPropSlashings), "Expected no slashings to be inserted")
+}
+
+func TestDetectAndBroadcastEquivocation_EquivocationDetected(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+	beaconState, privKeys := util.DeterministicGenesisState(t, 100)
+
+	// Create first block
+	block1 := util.NewBeaconBlock()
+	block1.Block.Slot = 1
+	block1.Block.ProposerIndex = 0
+	block1.Block.ParentRoot = bytesutil.PadTo([]byte("parent1"), 32)
+	sig1, err := signing.ComputeDomainAndSign(beaconState, 0, block1.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+	require.NoError(t, err)
+	block1.Signature = sig1
+
+	// Create second block with same slot/proposer but different contents
+	block2 := util.NewBeaconBlock()
+	block2.Block.Slot = 1
+	block2.Block.ProposerIndex = 0
+	block2.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32)
+	sig2, err := signing.ComputeDomainAndSign(beaconState, 0, block2.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+	require.NoError(t, err)
+	block2.Signature = sig2
+
+	slashingPool := &slashingsmock.PoolMock{}
+	chainService := &mock.ChainService{
+		State:   beaconState,
+		Genesis: time.Now(),
+	}
+	r := &Service{
+		cfg: &config{
+			p2p:          p,
+			chain:        chainService,
+			slashingPool: slashingPool,
+		},
+		seenBlockCache: lruwrpr.New(10),
+	}
+
+	// Cache first block
+	r.setSeenBlockIndexSlot(block1.Block.Slot, block1.Block.ProposerIndex)
+	b := append(bytesutil.Bytes32(uint64(block1.Block.Slot)), bytesutil.Bytes32(uint64(block1.Block.ProposerIndex))...)
+	signedBlock1, err := blocks.NewSignedBeaconBlock(block1)
+	require.NoError(t, err)
+	r.seenBlockCache.Add(string(b), signedBlock1)
+
+	// Process second block which should trigger equivocation
+	signedBlock2, err := blocks.NewSignedBeaconBlock(block2)
+	require.NoError(t, err)
+	err = r.detectAndBroadcastEquivocation(ctx, signedBlock2)
+	require.NoError(t, err)
+
+	// Verify slashing was inserted
+	require.Equal(t, 1, len(slashingPool.PendingPropSlashings), "Expected a slashing to be inserted")
+	slashing := slashingPool.PendingPropSlashings[0]
+	assert.Equal(t, primitives.ValidatorIndex(0), slashing.Header_1.Header.ProposerIndex, "Wrong proposer index")
+	assert.Equal(t, primitives.Slot(1), slashing.Header_1.Header.Slot, "Wrong slot")
+}
+
+func TestDetectAndBroadcastEquivocation_SameSignature(t *testing.T) {
+	p := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+	beaconState, privKeys := util.DeterministicGenesisState(t, 100)
+
+	// Create a block
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 1
+	block.Block.ProposerIndex = 0
+	sig, err := signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+	require.NoError(t, err)
+	block.Signature = sig
+
+	slashingPool := &slashingsmock.PoolMock{}
+	chainService := &mock.ChainService{
+		State:   beaconState,
+		Genesis: time.Now(),
+	}
+	r := &Service{
+		cfg: &config{
+			p2p:          p,
+			chain:        chainService,
+			slashingPool: slashingPool,
+		},
+		seenBlockCache: lruwrpr.New(10),
+	}
+
+	// Cache the block
+	r.setSeenBlockIndexSlot(block.Block.Slot, block.Block.ProposerIndex)
+	b := append(bytesutil.Bytes32(uint64(block.Block.Slot)), bytesutil.Bytes32(uint64(block.Block.ProposerIndex))...)
+	signedBlock, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(t, err)
+	r.seenBlockCache.Add(string(b), signedBlock)
+
+	// Try to process the same block again
+	err = r.detectAndBroadcastEquivocation(ctx, signedBlock)
+	require.NoError(t, err)
+	assert.Equal(t, 0, len(slashingPool.PendingPropSlashings), "Expected no slashings for same signature")
+}

changelog/kira_broadcast_slashings.md

@@ -0,0 +1,5 @@
+### Added
+- Added broadcast of slashing events (proposer and attester slashings) upon detection of equivocation.
+
+### Updated
+- Updated attestation pool logic to prioritize slashings over regular attestations during block production.