feat(lib/babe): implement secondary slot block production

dot/sync/chain_processor.go

@@ -103,15 +103,24 @@ func (s *chainProcessor) processReadyBlocks() {
 }
 
 // processBlockData processes the BlockData from a BlockResponse and
-// eturns the index of the last BlockData it handled on success,
+// returns the index of the last BlockData it handled on success,
 // or the index of the block data that errored on failure.
 func (s *chainProcessor) processBlockData(bd *types.BlockData) error {
 	if bd == nil {
 		return ErrNilBlockData
 	}
 
-	hasHeader, _ := s.blockState.HasHeader(bd.Hash)
-	hasBody, _ := s.blockState.HasBlockBody(bd.Hash)
+	hasHeader, err := s.blockState.HasHeader(bd.Hash)
+	if err != nil {
+		logger.Debugf("failed to check if block state has header for hash %s: %s", bd.Hash, err)
+		return err
+	}
+	hasBody, err := s.blockState.HasBlockBody(bd.Hash)
+	if err != nil {
+		logger.Debugf("failed to check block state has body for hash %s: %s", bd.Hash, err)
+		return err
+	}
+
 	if hasHeader && hasBody {
 		// TODO: fix this; sometimes when the node shuts down the "best block" isn't stored properly,
 		// so when the node restarts it has blocks higher than what it thinks is the best, causing it not to sync

lib/babe/babe.go

@@ -400,7 +400,7 @@ func (b *Service) handleEpoch(epoch uint64) (next uint64, err error) {
 	return next, nil
 }
 
-func (b *Service) handleSlot(epoch, slotNum uint64, authorityIndex uint32, proof *VrfOutputAndProof) error {
+func (b *Service) handleSlot(epoch, slotNum uint64, authorityIndex uint32, proof *VrfOutputAndProof, ifPrimary bool) error {
 	parentHeader, err := b.blockState.BestBlockHeader()
 	if err != nil {
 		return err
@@ -442,7 +442,7 @@ func (b *Service) handleSlot(epoch, slotNum uint64, authorityIndex uint32, proof
 
 	rt.SetContextStorage(ts)
 
-	block, err := b.buildBlock(parent, currentSlot, rt, authorityIndex, proof)
+	block, err := b.buildBlock(parent, currentSlot, rt, authorityIndex, proof, ifPrimary)
 	if err != nil {
 		return err
 	}

lib/babe/build.go

@@ -26,7 +26,7 @@ const (
 
 // construct a block for this slot with the given parent
 func (b *Service) buildBlock(parent *types.Header, slot Slot, rt runtime.Instance,
-	authorityIndex uint32, proof *VrfOutputAndProof) (*types.Block, error) {
+	authorityIndex uint32, proof *VrfOutputAndProof, ifPrimary bool) (*types.Block, error) {
 	builder, err := NewBlockBuilder(
 		b.keypair,
 		b.transactionState,
@@ -42,7 +42,7 @@ func (b *Service) buildBlock(parent *types.Header, slot Slot, rt runtime.Instanc
 	ethmetrics.Enabled = true
 
 	start := time.Now()
-	block, err := builder.buildBlock(parent, slot, rt)
+	block, err := builder.buildBlock(parent, slot, rt, ifPrimary)
 	if err != nil {
 		builderErrors := ethmetrics.GetOrRegisterCounter(buildBlockErrors, nil)
 		builderErrors.Inc(1)
@@ -88,11 +88,11 @@ func NewBlockBuilder(kp *sr25519.Keypair, ts TransactionState,
 	return bb, nil
 }
 
-func (b *BlockBuilder) buildBlock(parent *types.Header, slot Slot, rt runtime.Instance) (*types.Block, error) {
+func (b *BlockBuilder) buildBlock(parent *types.Header, slot Slot, rt runtime.Instance, ifPrimary bool) (*types.Block, error) {
 	logger.Tracef("build block with parent %s and slot: %s", parent, slot)
 
 	// create pre-digest
-	preDigest, err := b.buildBlockPreDigest(slot)
+	preDigest, err := b.buildBlockPreDigest(slot, ifPrimary)
 	if err != nil {
 		return nil, err
 	}
@@ -193,21 +193,35 @@ func (b *BlockBuilder) buildBlockSeal(header *types.Header) (*types.SealDigest,
 
 // buildBlockPreDigest creates the pre-digest for the slot.
 // the pre-digest consists of the ConsensusEngineID and the encoded BABE header for the slot.
-func (b *BlockBuilder) buildBlockPreDigest(slot Slot) (*types.PreRuntimeDigest, error) {
+func (b *BlockBuilder) buildBlockPreDigest(slot Slot, ifPrimary bool) (*types.PreRuntimeDigest, error) {
+
+	// check if secondary slot
+
+	// TODO: if author_secondary_vrf enabled, use SecondaryVRF
+	// otherwise BlockBabeSecondaryPlainPreDigest
 	babeHeader := types.NewBabeDigest()
-	data := b.buildBlockBABEPrimaryPreDigest(slot)
-	if err := babeHeader.Set(*data); err != nil {
-		return nil, fmt.Errorf("cannot set babe header: %w", err)
+	if ifPrimary {
+		data := b.buildBlockBABEPrimaryPreDigest(slot)
+		err := babeHeader.Set(*data)
+		if err != nil {
+			return nil, fmt.Errorf("cannot set babe header: %w", err)
+		}
+	} else {
+		data := b.buildBlockBabeSecondaryPlainPreDigest(slot)
+		err := babeHeader.Set(*data)
+		if err != nil {
+			return nil, fmt.Errorf("cannot set babe header: %w", err)
+		}
 	}
 
-	encBABEPrimaryPreDigest, err := scale.Marshal(babeHeader)
+	encBABEPreDigest, err := scale.Marshal(babeHeader)
 	if err != nil {
 		return nil, err
 	}
 
 	return &types.PreRuntimeDigest{
 		ConsensusEngineID: types.BabeEngineID,
-		Data:              encBABEPrimaryPreDigest,
+		Data:              encBABEPreDigest,
 	}, nil
 }
 
@@ -222,6 +236,13 @@ func (b *BlockBuilder) buildBlockBABEPrimaryPreDigest(slot Slot) *types.BabePrim
 	)
 }
 
+func (b *BlockBuilder) buildBlockBabeSecondaryPlainPreDigest(slot Slot) *types.BabeSecondaryPlainPreDigest {
+	return &types.BabeSecondaryPlainPreDigest{
+		AuthorityIndex: b.currentAuthorityIndex,
+		SlotNumber:     slot.number,
+	}
+}
+
 // buildBlockExtrinsics applies extrinsics to the block. it returns an array of included extrinsics.
 // for each extrinsic in queue, add it to the block, until the slot ends or the block is full.
 // if any extrinsic fails, it returns an empty array and an error.

lib/babe/crypto.go

@@ -9,6 +9,7 @@ import (
 	"math"
 	"math/big"
 
+	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/crypto"
 	"github.com/ChainSafe/gossamer/lib/crypto/sr25519"
 	"github.com/ChainSafe/gossamer/pkg/scale"
@@ -83,6 +84,39 @@ func checkPrimaryThreshold(randomness Randomness,
 	return inoutUint.Compare(threshold) < 0, nil
 }
 
+func claimSecondarySlot(randomness Randomness,
+	slot, epoch uint64,
+	authorities []types.Authority,
+	threshold *scale.Uint128,
+	keypair *sr25519.Keypair,
+	authorityIndex uint32,
+) (*VrfOutputAndProof, error) {
+
+	secondarySlotAuthor, err := getSecondarySlotAuthor(slot, len(authorities), randomness)
+	if err != nil {
+		return nil, err
+	}
+
+	if int(authorityIndex) == int(secondarySlotAuthor) {
+		transcript := makeTranscript(randomness, slot, epoch)
+
+		out, proof, err := keypair.VrfSign(transcript)
+		if err != nil {
+			return nil, err
+		}
+
+		logger.Debugf("claimed secondary slot, for slot number: %d", slot)
+
+		return &VrfOutputAndProof{
+			output: out,
+			proof:  proof,
+		}, nil
+	}
+
+	// It is not our turn to propose
+	return nil, nil
+}
+
 // CalculateThreshold calculates the slot lottery threshold
 // equation: threshold = 2^128 * (1 - (1-c)^(1/len(authorities))
 // see https://github.com/paritytech/substrate/blob/master/client/consensus/babe/src/authorship.rs#L44

lib/babe/epoch.go

@@ -138,6 +138,7 @@ func (b *Service) getEpochDataAndStartSlot(epoch uint64) (*epochData, uint64, er
 		authorities:    data.Authorities,
 		authorityIndex: idx,
 		threshold:      threshold,
+		secondary:      cfgData.SecondarySlots,
 	}
 
 	startSlot, err := b.epochState.GetStartSlotForEpoch(epoch)
@@ -222,11 +223,25 @@ func (b *Service) incrementEpoch() (uint64, error) {
 // if it is not authorised.
 // output = return[0:32]; proof = return[32:96]
 func (b *Service) runLottery(slot, epoch uint64, epochData *epochData) (*VrfOutputAndProof, error) {
-	return claimPrimarySlot(
+	// TODO: Check if whether to store if a primary slot was claimed? How?
+	proof, err := claimPrimarySlot(
 		epochData.randomness,
 		slot,
 		epoch,
 		epochData.threshold,
 		b.keypair,
 	)
+	if err == nil {
+		return proof, nil
+	}
+
+	if epochData.secondary == 0 {
+		return nil, err
+	}
+
+	if errors.Is(err, errOverPrimarySlotThreshold) {
+		return claimSecondarySlot(epochData.randomness, slot, epoch, epochData.authorities, epochData.threshold, b.keypair, epochData.authorityIndex)
+	}
+
+	return nil, err
 }

lib/babe/epoch_handler.go

@@ -13,7 +13,7 @@ import (
 	"github.com/ChainSafe/gossamer/lib/crypto/sr25519"
 )
 
-type handleSlotFunc = func(epoch, slotNum uint64, authorityIndex uint32, proof *VrfOutputAndProof) error
+type handleSlotFunc = func(epoch, slotNum uint64, authorityIndex uint32, proof *VrfOutputAndProof, ifPrimary bool) error
 
 var (
 	errEpochPast = errors.New("cannot run epoch that has already passed")
@@ -27,7 +27,8 @@ type epochHandler struct {
 	epochData *epochData
 
 	// for slots where we are a producer, store the vrf output (bytes 0-32) + proof (bytes 32-96)
-	slotToProof map[uint64]*VrfOutputAndProof
+	slotToProof     map[uint64]*VrfOutputAndProof
+	slotToIfPrimary map[uint64]bool
 
 	handleSlot handleSlotFunc
 }
@@ -36,6 +37,7 @@ func newEpochHandler(epochNumber, firstSlot uint64, epochData *epochData, consta
 	handleSlot handleSlotFunc, keypair *sr25519.Keypair) (*epochHandler, error) {
 	// determine which slots we'll be authoring in by pre-calculating VRF output
 	slotToProof := make(map[uint64]*VrfOutputAndProof, constants.epochLength)
+	slotToIfPrimary := make(map[uint64]bool)
 	for i := firstSlot; i < firstSlot+constants.epochLength; i++ {
 		proof, err := claimPrimarySlot(
 			epochData.randomness,
@@ -44,23 +46,34 @@ func newEpochHandler(epochNumber, firstSlot uint64, epochData *epochData, consta
 			epochData.threshold,
 			keypair,
 		)
-		if errors.Is(err, errOverPrimarySlotThreshold) {
+		if err == nil {
+			slotToProof[i] = proof
+			slotToIfPrimary[i] = true
+			logger.Debugf("epoch %d: claimed slot %d", epochNumber, i)
 			continue
-		} else if err != nil {
+		}
+		if !errors.Is(err, errOverPrimarySlotThreshold) {
+			return nil, fmt.Errorf("error running slot lottery at slot %d: %w", i, err)
+		}
+
+		proof, err = claimSecondarySlot(epochData.randomness, i, epochNumber, epochData.authorities, epochData.threshold, keypair, epochData.authorityIndex)
+		if err != nil {
 			return nil, fmt.Errorf("error running slot lottery at slot %d: %w", i, err)
 		}
 
 		slotToProof[i] = proof
+		slotToIfPrimary[i] = false
 		logger.Debugf("epoch %d: claimed slot %d", epochNumber, i)
 	}
 
 	return &epochHandler{
-		epochNumber: epochNumber,
-		firstSlot:   firstSlot,
-		constants:   constants,
-		epochData:   epochData,
-		slotToProof: slotToProof,
-		handleSlot:  handleSlot,
+		epochNumber:     epochNumber,
+		firstSlot:       firstSlot,
+		constants:       constants,
+		epochData:       epochData,
+		slotToProof:     slotToProof,
+		handleSlot:      handleSlot,
+		slotToIfPrimary: slotToIfPrimary,
 	}, nil
 }
 
@@ -124,7 +137,7 @@ func (h *epochHandler) run(ctx context.Context, errCh chan<- error) {
 				panic(fmt.Sprintf("no VRF proof for authoring slot! slot=%d", swt.slotNum))
 			}
 
-			err := h.handleSlot(h.epochNumber, swt.slotNum, h.epochData.authorityIndex, h.slotToProof[swt.slotNum])
+			err := h.handleSlot(h.epochNumber, swt.slotNum, h.epochData.authorityIndex, h.slotToProof[swt.slotNum], h.slotToIfPrimary[swt.slotNum])
 			if err != nil {
 				logger.Warnf("failed to handle slot %d: %s", swt.slotNum, err)
 				continue

lib/babe/secondary.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ChainSafe/gossamer/lib/crypto/sr25519"
 )
 
+// https://github.com/paritytech/substrate/blob/b07765f9ecc4c508fb4d0fba930b476c8509f5c2/client/consensus/babe/src/authorship.rs#L98
 func getSecondarySlotAuthor(slot uint64, numAuths int, randomness Randomness) (uint32, error) {
 	s := make([]byte, 8)
 	binary.LittleEndian.PutUint64(s, slot)

lib/babe/types.go

@@ -60,6 +60,7 @@ type epochData struct {
 	authorityIndex uint32
 	authorities    []types.Authority
 	threshold      *scale.Uint128
+	secondary      byte
 }
 
 func (ed *epochData) String() string {