don't throw ErrProducerEquivocated if authored blocks have different parents

dot/state/block.go

@@ -250,6 +250,37 @@ func (bs *BlockState) GetHashByNumber(num uint) (common.Hash, error) {
 	return common.NewHash(bh), nil
 }
 
+// GetBlockHashesBySlot gets all block hashes that were produced in the given slot.
+func (bs *BlockState) GetBlockHashesBySlot(slotNum uint64) ([]common.Hash, error) {
+	highestFinalisedHash, err := bs.GetHighestFinalisedHash()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get highest finalised hash: %w", err)
+	}
+
+	descendants, err := bs.bt.GetAllDescendants(highestFinalisedHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get descendants: %w", err)
+	}
+
+	blocksWithGivenSlot := []common.Hash{}
+
+	for _, desc := range descendants {
+		descSlot, err := bs.GetSlotForBlock(desc)
+		if errors.Is(err, types.ErrGenesisHeader) {
+			continue
+		}
+		if err != nil {
+			return nil, fmt.Errorf("could not get slot for block: %w", err)
+		}
+
+		if descSlot == slotNum {
+			blocksWithGivenSlot = append(blocksWithGivenSlot, desc)
+		}
+	}
+
+	return blocksWithGivenSlot, nil
+}
+
 // GetHeaderByNumber returns the block header on our best chain with the given number
 func (bs *BlockState) GetHeaderByNumber(num uint) (*types.Header, error) {
 	hash, err := bs.GetHashByNumber(num)
@@ -505,7 +536,7 @@ func (bs *BlockState) BestBlock() (*types.Block, error) {
 func (bs *BlockState) GetSlotForBlock(hash common.Hash) (uint64, error) {
 	header, err := bs.GetHeader(hash)
 	if err != nil {
-		return 0, err
+		return 0, fmt.Errorf("getting header for hash %s: %w", hash, err)
 	}
 
 	return types.GetSlotFromHeader(header)

dot/state/block_test.go

@@ -195,6 +195,62 @@ func TestGetSlotForBlock(t *testing.T) {
 	require.Equal(t, expectedSlot, res)
 }
 
+func TestGetBlockHashesBySlot(t *testing.T) {
+	t.Parallel()
+
+	// create two block in the same slot and test if GetBlockHashesBySlot gets us
+	// both the blocks
+	bs := newTestBlockState(t, newTriesEmpty())
+	slot := uint64(77)
+
+	babeHeader := types.NewBabeDigest()
+	err := babeHeader.Set(*types.NewBabePrimaryPreDigest(0, slot, [32]byte{}, [64]byte{}))
+	require.NoError(t, err)
+	data, err := scale.Marshal(babeHeader)
+	require.NoError(t, err)
+	preDigest := types.NewBABEPreRuntimeDigest(data)
+
+	digest := types.NewDigest()
+	err = digest.Add(*preDigest)
+	require.NoError(t, err)
+	block := &types.Block{
+		Header: types.Header{
+			ParentHash: testGenesisHeader.Hash(),
+			Number:     1,
+			Digest:     digest,
+		},
+		Body: types.Body{},
+	}
+
+	err = bs.AddBlock(block)
+	require.NoError(t, err)
+
+	babeHeader2 := types.NewBabeDigest()
+	err = babeHeader2.Set(*types.NewBabePrimaryPreDigest(1, slot, [32]byte{}, [64]byte{}))
+	require.NoError(t, err)
+	data2, err := scale.Marshal(babeHeader2)
+	require.NoError(t, err)
+	preDigest2 := types.NewBABEPreRuntimeDigest(data2)
+
+	digest2 := types.NewDigest()
+	err = digest2.Add(*preDigest2)
+	require.NoError(t, err)
+	block2 := &types.Block{
+		Header: types.Header{
+			ParentHash: testGenesisHeader.Hash(),
+			Number:     1,
+			Digest:     digest2,
+		},
+		Body: types.Body{},
+	}
+	err = bs.AddBlock(block2)
+	require.NoError(t, err)
+
+	blocks, err := bs.GetBlockHashesBySlot(slot)
+	require.NoError(t, err)
+	require.ElementsMatch(t, blocks, []common.Hash{block.Header.Hash(), block2.Header.Hash()})
+}
+
 func TestIsBlockOnCurrentChain(t *testing.T) {
 	bs := newTestBlockState(t, newTriesEmpty())
 	currChain, branchChains := AddBlocksToState(t, bs, 3, false)

dot/types/babe.go

@@ -28,6 +28,7 @@ const (
 
 var (
 	ErrChainHeadMissingDigest = errors.New("chain head missing digest")
+	ErrGenesisHeader          = errors.New("genesis header doesn't have a slot")
 )
 
 // BabeConfiguration contains the genesis data for BABE
@@ -108,6 +109,10 @@ type ConfigData struct {
 
 // GetSlotFromHeader returns the BABE slot from the given header
 func GetSlotFromHeader(header *Header) (uint64, error) {
+	if header.Number == 0 {
+		return 0, ErrGenesisHeader
+	}
+
 	if len(header.Digest.Types) == 0 {
 		return 0, ErrChainHeadMissingDigest
 	}

lib/babe/errors.go

@@ -72,6 +72,7 @@ var (
 	errNoBABEAuthorityKeyProvided = errors.New("cannot create BABE service as authority; no keypair provided")
 	errLastDigestItemNotSeal      = errors.New("last digest item is not seal")
 	errLaggingSlot                = errors.New("current slot is smaller than slot of best block")
+	errNoDigest                   = errors.New("no digest provided")
 
 	other         Other
 	invalidCustom InvalidCustom

lib/babe/state.go

@@ -28,6 +28,7 @@ type BlockState interface {
 	GetHeader(common.Hash) (*types.Header, error)
 	GetBlockByNumber(blockNumber uint) (*types.Block, error)
 	GetBlockByHash(common.Hash) (*types.Block, error)
+	GetBlockHashesBySlot(slot uint64) (blockHashes []common.Hash, err error)
 	GetArrivalTime(common.Hash) (time.Time, error)
 	GenesisHash() common.Hash
 	GetSlotForBlock(common.Hash) (uint64, error)

lib/babe/verify.go

@@ -138,7 +138,7 @@ func (v *VerificationManager) VerifyBlock(header *types.Header) error {
 		if !block1IsFinal {
 			firstSlot, err := types.GetSlotFromHeader(header)
 			if err != nil {
-				return fmt.Errorf("failed to get slot from block 1: %w", err)
+				return fmt.Errorf("failed to get slot from header of block 1: %w", err)
 			}
 
 			logger.Debugf("syncing block 1, setting first slot as %d", firstSlot)
@@ -327,62 +327,58 @@ func (b *verifier) verifyAuthorshipRight(header *types.Header) error {
 		return ErrBadSignature
 	}
 
-	// check if the producer has equivocated, ie. have they produced a conflicting block?
-	// hashes is hashes of all blocks with same block number as header.Number
-	hashes := b.blockState.GetAllBlocksAtDepth(header.ParentHash)
+	equivocated, err := b.verifyBlockEquivocation(header)
+	if err != nil {
+		return fmt.Errorf("could not verify block equivocation: %w", err)
+	}
+	if equivocated {
+		return fmt.Errorf("%w for block header %s", ErrProducerEquivocated, header.Hash())
+	}
 
-	for _, currentHash := range hashes {
-		currentHeader, err := b.blockState.GetHeader(currentHash)
-		if err != nil {
-			return fmt.Errorf("failed get header %s", err)
-		}
+	return nil
+}
 
-		currentBlockProducerIndex, err := getAuthorityIndex(currentHeader)
-		if err != nil {
-			return fmt.Errorf("failed to get authority index %s", err)
-		}
+// verifyBlockEquivocation checks if the given block's author has occupied the corresponding slot more than once.
+// It returns true if the block was equivocated.
+func (b *verifier) verifyBlockEquivocation(header *types.Header) (bool, error) {
+	author, err := getAuthorityIndex(header)
+	if err != nil {
+		return false, fmt.Errorf("failed to get authority index: %w", err)
+	}
 
-		if len(currentHeader.Digest.Types) == 0 {
-			return fmt.Errorf("current header missing digest")
+	currentHash := header.Hash()
+	slot, err := types.GetSlotFromHeader(header)
+	if err != nil {
+		return false, fmt.Errorf("failed to get slot from header of block %s: %w", currentHash, err)
+	}
+
+	blockHashesInSlot, err := b.blockState.GetBlockHashesBySlot(slot)
+	if err != nil {
+		return false, fmt.Errorf("failed to get blocks produced in slot: %w", err)
+	}
+
+	for _, blockHashInSlot := range blockHashesInSlot {
+		if blockHashInSlot.Equal(currentHash) {
+			continue
 		}
 
-		currentPreDigestItemValue, err := currentHeader.Digest.Types[0].Value()
+		existingHeader, err := b.blockState.GetHeader(blockHashInSlot)
 		if err != nil {
-			return fmt.Errorf("getting current header first digest type value: %w", err)
-		}
-		currentPreDigest, ok := currentPreDigestItemValue.(types.PreRuntimeDigest)
-		if !ok {
-			return fmt.Errorf("%w: got %T", types.ErrNoFirstPreDigest, currentPreDigestItemValue)
+			return false, fmt.Errorf("failed to get header for block: %w", err)
 		}
 
-		currentBabePreDigest, err := b.verifyPreRuntimeDigest(&currentPreDigest)
+		authorOfExistingHeader, err := getAuthorityIndex(existingHeader)
 		if err != nil {
-			return fmt.Errorf("failed to verify pre-runtime digest: %w", err)
+			return false, fmt.Errorf("failed to get authority index for block %s: %w", blockHashInSlot, err)
 		}
-
-		_, isCurrentBlockProducerPrimary := currentBabePreDigest.(types.BabePrimaryPreDigest)
-
-		var isExistingBlockProducerPrimary bool
-		var existingBlockProducerIndex uint32
-		switch d := babePreDigest.(type) {
-		case types.BabePrimaryPreDigest:
-			existingBlockProducerIndex = d.AuthorityIndex
-			isExistingBlockProducerPrimary = true
-		case types.BabeSecondaryVRFPreDigest:
-			existingBlockProducerIndex = d.AuthorityIndex
-		case types.BabeSecondaryPlainPreDigest:
-			existingBlockProducerIndex = d.AuthorityIndex
+		if authorOfExistingHeader != author {
+			continue
 		}
 
-		// same authority won't produce two different blocks at the same block number as primary block producer
-		if currentBlockProducerIndex == existingBlockProducerIndex &&
-			!currentHash.Equal(header.Hash()) &&
-			isCurrentBlockProducerPrimary == isExistingBlockProducerPrimary {
-			return ErrProducerEquivocated
-		}
+		return true, nil
 	}
 
-	return nil
+	return false, nil
 }
 
 func (b *verifier) verifyPreRuntimeDigest(digest *types.PreRuntimeDigest) (scale.VaryingDataTypeValue, error) {
@@ -493,7 +489,7 @@ func (b *verifier) verifyPrimarySlotWinner(authorityIndex uint32,
 
 func getAuthorityIndex(header *types.Header) (uint32, error) {
 	if len(header.Digest.Types) == 0 {
-		return 0, fmt.Errorf("no digest provided")
+		return 0, fmt.Errorf("for block hash %s: %w", header.Hash(), errNoDigest)
 	}
 
 	digestValue, err := header.Digest.Types[0].Value()

lib/babe/verify_integration_test.go

@@ -466,7 +466,8 @@ func TestVerifyAuthorshipRight_Equivocation(t *testing.T) {
 	require.NoError(t, err)
 
 	err = verifier.verifyAuthorshipRight(&block2.Header)
-	require.Equal(t, ErrProducerEquivocated, err)
+	require.ErrorIs(t, err, ErrProducerEquivocated)
+	require.EqualError(t, err, fmt.Sprintf("%s for block header %s", ErrProducerEquivocated, block2.Header.Hash()))
 }
 
 func TestVerifyForkBlocksWithRespectiveEpochData(t *testing.T) {