fix(dot/sync): Gossip BlockAnnounceMessage only after successfully imported

dot/core/service.go

@@ -127,40 +127,68 @@ func (s *Service) StorageRoot() (common.Hash, error) {
 
 // HandleBlockImport handles a block that was imported via the network
 func (s *Service) HandleBlockImport(block *types.Block, state *rtstorage.TrieState) error {
-	return s.handleBlock(block, state)
+	err := s.handleBlock(block, state)
+	if err != nil {
+		return fmt.Errorf("handling block: %s", err)
+	}
+
+	isBestBlock := false
+	bestBlockHash := s.blockState.BestBlockHash()
+
+	if bestBlockHash.Equal(block.Header.Hash()) {
+		isBestBlock = true
+	}
+
+	blockAnnounce, err := createBlockAnnounce(block, isBestBlock)
+	if err != nil {
+		logger.Errorf("creating block announce: %s", err)
+	}
+
+	s.net.GossipMessage(blockAnnounce)
+	return nil
 }
 
 // HandleBlockProduced handles a block that was produced by us
 // It is handled the same as an imported block in terms of state updates; the only difference
 // is we send a BlockAnnounceMessage to our peers.
 func (s *Service) HandleBlockProduced(block *types.Block, state *rtstorage.TrieState) error {
-	if err := s.handleBlock(block, state); err != nil {
-		return err
+	err := s.handleBlock(block, state)
+	if err != nil {
+		return fmt.Errorf("handling block: %s", err)
 	}
 
+	const isBestBlock = true
+	blockAnnounce, err := createBlockAnnounce(block, isBestBlock)
+	if err != nil {
+		logger.Errorf("creating block announce: %s", err)
+	}
+
+	s.net.GossipMessage(blockAnnounce)
+	return nil
+}
+
+func createBlockAnnounce(block *types.Block, isBestBlock bool) (
+	blockAnnounce *network.BlockAnnounceMessage, err error) {
 	digest := types.NewDigest()
 	for i := range block.Header.Digest.Types {
 		digestValue, err := block.Header.Digest.Types[i].Value()
 		if err != nil {
-			return fmt.Errorf("getting value of digest type at index %d: %w", i, err)
+			return nil, fmt.Errorf("getting value of digest type at index %d: %w", i, err)
 		}
 		err = digest.Add(digestValue)
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
 
-	msg := &network.BlockAnnounceMessage{
+	return &network.BlockAnnounceMessage{
 		ParentHash:     block.Header.ParentHash,
 		Number:         block.Header.Number,
 		StateRoot:      block.Header.StateRoot,
 		ExtrinsicsRoot: block.Header.ExtrinsicsRoot,
 		Digest:         digest,
-		BestBlock:      true,
-	}
-
-	s.net.GossipMessage(msg)
-	return nil
+		BestBlock:      isBestBlock,
+	}, nil
 }
 
 func (s *Service) handleBlock(block *types.Block, state *rtstorage.TrieState) error {

dot/network/block_announce.go

@@ -203,14 +203,13 @@ func (s *Service) validateBlockAnnounceHandshake(from peer.ID, hs Handshake) err
 // if some more blocks are required to sync the announced block, the node will open a sync stream
 // with its peer and send a BlockRequest message
 func (s *Service) handleBlockAnnounceMessage(from peer.ID, msg NotificationsMessage) (propagate bool, err error) {
+	propagate = false
+
 	bam, ok := msg.(*BlockAnnounceMessage)
 	if !ok {
-		return false, errors.New("invalid message")
-	}
-
-	if err = s.syncer.HandleBlockAnnounce(from, bam); err != nil {
-		return false, err
+		return propagate, errors.New("invalid message")
 	}
 
-	return true, nil
+	err = s.syncer.HandleBlockAnnounce(from, bam)
+	return propagate, err
 }

dot/sync/chain_processor.go

@@ -238,6 +238,7 @@ func (s *chainProcessor) handleBlock(block *types.Block) error {
 	}
 
 	logger.Debugf("🔗 imported block number %d with hash %s", block.Header.Number, block.Header.Hash())
+	// should we announce the block here?
 
 	blockHash := block.Header.Hash()
 	s.telemetry.SendMessage(telemetry.NewBlockImport(

dot/sync/chain_sync.go

@@ -632,7 +632,7 @@ func (cs *chainSync) dispatchWorker(w *worker) {
 		"start hash %s, target hash %s, "+
 		"request data %d, direction %s",
 		w.id,
-		w.startNumber, w.targetNumber,
+		*w.startNumber, *w.targetNumber,
 		w.startHash, w.targetHash,
 		w.requestData, w.direction)