fix(sync): tip sync can follow chain and finalize blocks (#3765)

dot/state/block.go

@@ -58,6 +58,8 @@ type BlockState struct {
 	lock              sync.RWMutex
 	genesisHash       common.Hash
 	lastFinalised     common.Hash
+	lastRound         uint64
+	lastSetID         uint64
 	unfinalisedBlocks *hashToBlockMap
 	tries             *Tries
 

dot/state/block_finalisation.go

@@ -54,6 +54,14 @@ func (bs *BlockState) GetFinalisedHeader(round, setID uint64) (*types.Header, er
 	return header, nil
 }
 
+// GetRoundAndSetID returns the finalised round and setID
+func (bs *BlockState) GetRoundAndSetID() (uint64, uint64) {
+	bs.lock.Lock()
+	defer bs.lock.Unlock()
+
+	return bs.lastRound, bs.lastSetID
+}
+
 // GetFinalisedHash gets the finalised block header by round and setID
 func (bs *BlockState) GetFinalisedHash(round, setID uint64) (common.Hash, error) {
 	h, err := bs.db.Get(finalisedHashKey(round, setID))
@@ -182,6 +190,8 @@ func (bs *BlockState) SetFinalisedHash(hash common.Hash, round, setID uint64) er
 	}
 
 	bs.lastFinalised = hash
+	bs.lastRound = round
+	bs.lastSetID = setID
 
 	logger.Infof(
 		"🔨 finalised block #%d (%s), round %d, set id %d", header.Number, hash, round, setID)

dot/sync/chain_sync.go

@@ -402,11 +402,11 @@ func (cs *chainSync) requestChainBlocks(announcedHeader, bestBlockHeader *types.
 		startAtBlock = announcedHeader.Number - uint(*request.Max) + 1
 		totalBlocks = *request.Max
 
-		logger.Infof("requesting %d blocks, descending request from #%d (%s)",
-			peerWhoAnnounced, gapLength, announcedHeader.Number, announcedHeader.Hash().Short())
+		logger.Infof("requesting %d blocks from peer: %v, descending request from #%d (%s)",
+			gapLength, peerWhoAnnounced, announcedHeader.Number, announcedHeader.Hash().Short())
 	} else {
 		request = network.NewBlockRequest(startingBlock, 1, network.BootstrapRequestData, network.Descending)
-		logger.Infof("requesting a single block #%d (%s)",
+		logger.Infof("requesting a single block from peer: %v with Number: #%d and Hash: (%s)",
 			peerWhoAnnounced, announcedHeader.Number, announcedHeader.Hash().Short())
 	}
 
@@ -445,8 +445,8 @@ func (cs *chainSync) requestForkBlocks(bestBlockHeader, highestFinalizedHeader,
 		request = network.NewBlockRequest(startingBlock, gapLength, network.BootstrapRequestData, network.Descending)
 	}
 
-	logger.Infof("requesting %d fork blocks, starting at #%d (%s)",
-		peerWhoAnnounced, gapLength, announcedHeader.Number, announcedHash.Short())
+	logger.Infof("requesting %d fork blocks from peer: %v starting at #%d (%s)",
+		gapLength, peerWhoAnnounced, announcedHeader.Number, announcedHash.Short())
 
 	resultsQueue := make(chan *syncTaskResult)
 	cs.workerPool.submitRequest(request, &peerWhoAnnounced, resultsQueue)

dot/sync/worker_pool.go

@@ -4,9 +4,8 @@
 package sync
 
 import (
-	"fmt"
-
 	"crypto/rand"
+	"fmt"
 	"math/big"
 	"sync"
 	"time"
@@ -161,9 +160,14 @@ func (s *syncWorkerPool) submitRequest(request *network.BlockRequestMessage,
 	defer s.mtx.RUnlock()
 
 	if who != nil {
-		syncWorker := s.workers[*who]
-		syncWorker.queue <- task
-		return
+		syncWorker, inMap := s.workers[*who]
+		if inMap {
+			if syncWorker == nil {
+				panic("sync worker should not be nil")
+			}
+			syncWorker.queue <- task
+			return
+		}
 	}
 
 	// if the exact peer is not specified then

lib/grandpa/message_handler.go

@@ -80,28 +80,25 @@ func (h *MessageHandler) handleMessage(from peer.ID, m GrandpaMessage) (network.
 }
 
 func (h *MessageHandler) handleNeighbourMessage(msg *NeighbourPacketV1) error {
-	if h.grandpa.authority {
-		// TODO(#2931): this is a simple hack to ensure that the neighbour messages
-		// sent by gossamer are being received by substrate nodes
-		// not intended to be production code
-		h.grandpa.roundLock.Lock()
-		neighbourMessage := &NeighbourPacketV1{
-			Round:  h.grandpa.state.round,
-			SetID:  h.grandpa.state.setID,
-			Number: uint32(h.grandpa.head.Number),
-		}
-		h.grandpa.roundLock.Unlock()
-
-		cm, err := neighbourMessage.ToConsensusMessage()
-		if err != nil {
-			return fmt.Errorf("converting neighbour message to network message: %w", err)
-		}
+	// TODO(#2931): this is a simple hack to ensure that the neighbour messages
+	// sent by gossamer are being received by substrate nodes
+	// not intended to be production code
+	round, setID := h.blockState.GetRoundAndSetID()
+	neighbourMessage := &NeighbourPacketV1{
+		Round:  round,
+		SetID:  setID,
+		Number: uint32(h.grandpa.head.Number),
+	}
 
-		logger.Debugf("sending neighbour message: %v", neighbourMessage)
-		h.grandpa.network.GossipMessage(cm)
+	cm, err := neighbourMessage.ToConsensusMessage()
+	if err != nil {
+		return fmt.Errorf("converting neighbour message to network message: %w", err)
 	}
 
-	currFinalized, err := h.blockState.GetFinalisedHeader(0, 0)
+	logger.Debugf("sending neighbour message: %v", neighbourMessage)
+	h.grandpa.network.GossipMessage(cm)
+
+	currFinalized, err := h.blockState.GetFinalisedHeader(round, setID)
 	if err != nil {
 		return err
 	}

lib/grandpa/state.go

@@ -23,6 +23,7 @@ type BlockState interface {
 	LowestCommonAncestor(a, b common.Hash) (common.Hash, error)
 	HasFinalisedBlock(round, setID uint64) (bool, error)
 	GetFinalisedHeader(round, setID uint64) (*types.Header, error)
+	GetRoundAndSetID() (uint64, uint64)
 	GetFinalisedHash(round, setID uint64) (common.Hash, error)
 	SetFinalisedHash(common.Hash, uint64, uint64) error
 	BestBlockHeader() (*types.Header, error)