chore(dot/core, dot/state, lib/grandpa): implement GrandpaState, use in DigestHandler and grandpa.Service

dot/core/digest.go

@@ -33,13 +33,11 @@ type DigestHandler struct {
 	cancel context.CancelFunc
 
 	// interfaces
-	blockState          BlockState
-	epochState          EpochState
-	grandpa             FinalityGadget
-	babe                BlockProducer
-	verifier            Verifier
-	isFinalityAuthority bool
-	isBlockProducer     bool
+	blockState   BlockState
+	epochState   EpochState
+	grandpaState GrandpaState
+	babe         BlockProducer
+	verifier     Verifier
 
 	// block notification channels
 	imported    chan *types.Block
@@ -52,7 +50,6 @@ type DigestHandler struct {
 	grandpaForcedChange    *grandpaChange
 	grandpaPause           *pause
 	grandpaResume          *resume
-	grandpaAuths           []*types.Authority // saved in case of pause
 }
 
 type grandpaChange struct {
@@ -69,7 +66,7 @@ type resume struct {
 }
 
 // NewDigestHandler returns a new DigestHandler
-func NewDigestHandler(blockState BlockState, epochState EpochState, babe BlockProducer, grandpa FinalityGadget, verifier Verifier) (*DigestHandler, error) {
+func NewDigestHandler(blockState BlockState, epochState EpochState, grandpaState GrandpaState, babe BlockProducer, verifier Verifier) (*DigestHandler, error) {
 	imported := make(chan *types.Block, 16)
 	finalised := make(chan *types.Header, 16)
 	iid, err := blockState.RegisterImportedChannel(imported)
@@ -82,32 +79,27 @@ func NewDigestHandler(blockState BlockState, epochState EpochState, babe BlockPr
 		return nil, err
 	}
 
-	isFinalityAuthority := grandpa != nil
-	isBlockProducer := babe != nil
-
 	ctx, cancel := context.WithCancel(context.Background())
 
 	return &DigestHandler{
-		ctx:                 ctx,
-		cancel:              cancel,
-		blockState:          blockState,
-		epochState:          epochState,
-		grandpa:             grandpa,
-		babe:                babe,
-		verifier:            verifier,
-		isFinalityAuthority: isFinalityAuthority,
-		isBlockProducer:     isBlockProducer,
-		imported:            imported,
-		importedID:          iid,
-		finalised:           finalised,
-		finalisedID:         fid,
+		ctx:          ctx,
+		cancel:       cancel,
+		blockState:   blockState,
+		epochState:   epochState,
+		grandpaState: grandpaState,
+		babe:         babe,
+		verifier:     verifier,
+		imported:     imported,
+		importedID:   iid,
+		finalised:    finalised,
+		finalisedID:  fid,
 	}, nil
 }
 
 // Start starts the DigestHandler
 func (h *DigestHandler) Start() {
 	go h.handleBlockImport(h.ctx)
-	go h.handleBlockFinalization(h.ctx)
+	go h.handleBlockFinalisation(h.ctx)
 }
 
 // Stop stops the DigestHandler
@@ -119,11 +111,6 @@ func (h *DigestHandler) Stop() {
 	close(h.finalised)
 }
 
-// SetFinalityGadget sets the digest handler's grandpa instance
-func (h *DigestHandler) SetFinalityGadget(grandpa FinalityGadget) {
-	h.grandpa = grandpa
-}
-
 // NextGrandpaAuthorityChange returns the block number of the next upcoming grandpa authorities change.
 // It returns 0 if no change is scheduled.
 func (h *DigestHandler) NextGrandpaAuthorityChange() uint64 {
@@ -155,11 +142,9 @@ func (h *DigestHandler) HandleConsensusDigest(d *types.ConsensusDigest, header *
 	if d.ConsensusEngineID == types.GrandpaEngineID {
 		switch t {
 		case types.GrandpaScheduledChangeType:
-			return h.handleScheduledChange(d)
+			return h.handleScheduledChange(d, header)
 		case types.GrandpaForcedChangeType:
-			return h.handleForcedChange(d)
-		case types.GrandpaOnDisabledType:
-			return h.handleGrandpaOnDisabled(d, header)
+			return h.handleForcedChange(d, header)
 		case types.GrandpaPauseType:
 			return h.handlePause(d)
 		case types.GrandpaResumeType:
@@ -193,163 +178,150 @@ func (h *DigestHandler) handleBlockImport(ctx context.Context) {
 				continue
 			}
 
-			if h.isFinalityAuthority {
-				h.handleGrandpaChangesOnImport(block.Header.Number)
+			err := h.handleGrandpaChangesOnImport(block.Header.Number)
+			if err != nil {
+				logger.Error("failed to handle grandpa changes on block import", "error", err)
 			}
 		case <-ctx.Done():
 			return
 		}
 	}
 }
 
-func (h *DigestHandler) handleBlockFinalization(ctx context.Context) {
+func (h *DigestHandler) handleBlockFinalisation(ctx context.Context) {
 	for {
 		select {
 		case header := <-h.finalised:
 			if header == nil {
 				continue
 			}
 
-			if h.isFinalityAuthority {
-				h.handleGrandpaChangesOnFinalization(header.Number)
+			err := h.handleGrandpaChangesOnFinalization(header.Number)
+			if err != nil {
+				logger.Error("failed to handle grandpa changes on block finalisation", "error", err)
 			}
-
-			// TODO: check if there's a NextEpochData or NextConfigData digest, if there is,
-			// make sure it matches what's in the EpochState for the upcoming epoch
 		case <-ctx.Done():
 			return
 		}
 	}
 }
 
-func (h *DigestHandler) handleGrandpaChangesOnImport(num *big.Int) {
+func (h *DigestHandler) handleGrandpaChangesOnImport(num *big.Int) error {
 	resume := h.grandpaResume
 	if resume != nil && num.Cmp(resume.atBlock) == 0 {
-		h.grandpa.UpdateAuthorities(h.grandpaAuths)
 		h.grandpaResume = nil
 	}
 
 	fc := h.grandpaForcedChange
 	if fc != nil && num.Cmp(fc.atBlock) == 0 {
-		h.grandpa.UpdateAuthorities(fc.auths)
+		err := h.grandpaState.IncrementSetID()
+		if err != nil {
+			return err
+		}
+
 		h.grandpaForcedChange = nil
 	}
+
+	return nil
 }
 
-func (h *DigestHandler) handleGrandpaChangesOnFinalization(num *big.Int) {
+func (h *DigestHandler) handleGrandpaChangesOnFinalization(num *big.Int) error {
 	pause := h.grandpaPause
 	if pause != nil && num.Cmp(pause.atBlock) == 0 {
-		// save authority data for Resume
-		h.grandpaAuths = h.grandpa.Authorities()
-		h.grandpa.UpdateAuthorities([]*types.Authority{})
 		h.grandpaPause = nil
 	}
 
 	sc := h.grandpaScheduledChange
 	if sc != nil && num.Cmp(sc.atBlock) == 0 {
-		h.grandpa.UpdateAuthorities(sc.auths)
+		err := h.grandpaState.IncrementSetID()
+		if err != nil {
+			return err
+		}
+
 		h.grandpaScheduledChange = nil
 	}
 
 	// if blocks get finalised before forced change takes place, disregard it
 	h.grandpaForcedChange = nil
+	return nil
 }
 
-func (h *DigestHandler) handleScheduledChange(d *types.ConsensusDigest) error {
+func (h *DigestHandler) handleScheduledChange(d *types.ConsensusDigest, header *types.Header) error {
 	curr, err := h.blockState.BestBlockHeader()
 	if err != nil {
 		return err
 	}
 
-	if d.ConsensusEngineID == types.GrandpaEngineID {
-		if h.grandpaScheduledChange != nil {
-			return nil
-		}
+	if d.ConsensusEngineID != types.GrandpaEngineID {
+		return nil
+	}
 
-		sc := &types.GrandpaScheduledChange{}
-		dec, err := scale.Decode(d.Data[1:], sc)
-		if err != nil {
-			return err
-		}
-		sc = dec.(*types.GrandpaScheduledChange)
+	if h.grandpaScheduledChange != nil {
+		return nil
+	}
 
-		logger.Debug("handling GrandpaScheduledChange", "data", sc)
+	sc := &types.GrandpaScheduledChange{}
+	dec, err := scale.Decode(d.Data[1:], sc)
+	if err != nil {
+		return err
+	}
+	sc = dec.(*types.GrandpaScheduledChange)
 
-		if h.grandpa == nil {
-			// this should never happen
-			return nil
-		}
+	logger.Debug("handling GrandpaScheduledChange", "data", sc)
 
-		c, err := newGrandpaChange(sc.Auths, sc.Delay, curr.Number)
-		if err != nil {
-			return err
-		}
-
-		h.grandpaScheduledChange = c
+	c, err := newGrandpaChange(sc.Auths, sc.Delay, curr.Number)
+	if err != nil {
+		return err
 	}
 
-	return nil
-}
+	h.grandpaScheduledChange = c
 
-func (h *DigestHandler) handleForcedChange(d *types.ConsensusDigest) error {
-	curr, err := h.blockState.BestBlockHeader()
+	auths, err := types.GrandpaAuthoritiesRawToAuthorities(sc.Auths)
 	if err != nil {
 		return err
 	}
 
-	if d.ConsensusEngineID == types.GrandpaEngineID {
-		if h.grandpaForcedChange != nil {
-			return errors.New("already have forced change scheduled")
-		}
-
-		fc := &types.GrandpaForcedChange{}
-		dec, err := scale.Decode(d.Data[1:], fc)
-		if err != nil {
-			return err
-		}
-		fc = dec.(*types.GrandpaForcedChange)
+	return h.grandpaState.SetNextChange(types.NewGrandpaVotersFromAuthorities(auths), big.NewInt(0).Add(header.Number, big.NewInt(int64(sc.Delay))))
+}
 
-		c, err := newGrandpaChange(fc.Auths, fc.Delay, curr.Number)
-		if err != nil {
-			return err
-		}
+func (h *DigestHandler) handleForcedChange(d *types.ConsensusDigest, header *types.Header) error {
+	if d.ConsensusEngineID != types.GrandpaEngineID {
+		return nil
+	}
 
-		h.grandpaForcedChange = c
+	if header == nil {
+		return errors.New("header is nil")
 	}
 
-	return nil
-}
+	if h.grandpaForcedChange != nil {
+		return errors.New("already have forced change scheduled")
+	}
 
-func (h *DigestHandler) handleGrandpaOnDisabled(d *types.ConsensusDigest, _ *types.Header) error {
-	od := &types.GrandpaOnDisabled{}
-	dec, err := scale.Decode(d.Data[1:], od)
+	fc := &types.GrandpaForcedChange{}
+	dec, err := scale.Decode(d.Data[1:], fc)
 	if err != nil {
 		return err
 	}
-	od = dec.(*types.GrandpaOnDisabled)
+	fc = dec.(*types.GrandpaForcedChange)
 
-	logger.Debug("handling GrandpaOnDisabled", "data", od)
+	logger.Debug("handling GrandpaForcedChange", "data", fc)
 
-	if h.grandpa == nil {
-		// this should never happen
-		return nil
+	c, err := newGrandpaChange(fc.Auths, fc.Delay, header.Number)
+	if err != nil {
+		return err
 	}
 
-	curr := h.grandpa.Authorities()
-	next := []*types.Authority{}
+	h.grandpaForcedChange = c
 
-	for _, auth := range curr {
-		if auth.Weight != od.ID {
-			next = append(next, auth)
-		}
+	auths, err := types.GrandpaAuthoritiesRawToAuthorities(fc.Auths)
+	if err != nil {
+		return err
 	}
 
-	// TODO: this needs to be updated not to remove the authority from the list,
-	// but to flag them as disabled. thus, if we are disabled, we should stop voting.
-	// if we receive vote or finalisation messages, we should ignore anything signed by the
-	// disabled authority
-	h.grandpa.UpdateAuthorities(next)
-	return nil
+	return h.grandpaState.SetNextChange(
+		types.NewGrandpaVotersFromAuthorities(auths),
+		big.NewInt(0).Add(header.Number, big.NewInt(int64(fc.Delay))),
+	)
 }
 
 func (h *DigestHandler) handlePause(d *types.ConsensusDigest) error {
@@ -371,7 +343,7 @@ func (h *DigestHandler) handlePause(d *types.ConsensusDigest) error {
 		atBlock: big.NewInt(-1).Add(curr.Number, delay),
 	}
 
-	return nil
+	return h.grandpaState.SetNextPause(h.grandpaPause.atBlock)
 }
 
 func (h *DigestHandler) handleResume(d *types.ConsensusDigest) error {
@@ -393,7 +365,7 @@ func (h *DigestHandler) handleResume(d *types.ConsensusDigest) error {
 		atBlock: big.NewInt(-1).Add(curr.Number, delay),
 	}
 
-	return nil
+	return h.grandpaState.SetNextResume(h.grandpaResume.atBlock)
 }
 
 func newGrandpaChange(raw []*types.GrandpaAuthoritiesRaw, delay uint32, currBlock *big.Int) (*grandpaChange, error) {