fix(eth): log live sync status every cycle

The sync status logger only fired while the downloader was inside a bulk
historical sync. Once the node is caught up, new blocks are followed
through the block fetcher / BFT announcements, so Synchronising() stays
false and the warn log appeared only once or never over hours of normal
operation instead of every 10 minutes.

The logger now emits a status line on every 10-minute cycle with a
neutral message (current / highest / behind / peers). While the downloader
is actively synchronising it reports the downloader's discovered target
and the fast-sync snap block; otherwise it uses the local head merged
with a per-peer live high-water mark fed by block announcements
(NewBlockMsg / NewBlockHashesMsg). The announced numbers are only trusted
after passing the fetcher's plausibility window, exposed as
IsPlausibleAnnouncement, so a peer cannot inflate the reported gap.

Author: gzliudan

eth/fetcher/block_fetcher.go

@@ -45,6 +45,21 @@ const (
 	blockLimit   = 64  // Maximum number of unique blocks a peer may have delivered
 )
 
+// IsPlausibleAnnouncement reports whether a block announcement at the given
+// number is within the fetcher's plausibility window of the current chain
+// height. Untrusted announced numbers must be gated on this check before being
+// recorded (e.g. as a peer's live tip), so a peer cannot inflate the recorded
+// number beyond the window.
+func IsPlausibleAnnouncement(number, height uint64) bool {
+	if number == 0 {
+		return true
+	}
+	if number < height {
+		return height <= maxUncleDist+number
+	}
+	return number <= maxQueueDist+height
+}
+
 var (
 	blockAnnounceInMeter   = metrics.NewRegisteredMeter("eth/fetcher/block/announces/in", nil)
 	blockAnnounceOutTimer  = metrics.NewRegisteredTimer("eth/fetcher/block/announces/out", nil)
@@ -365,12 +380,11 @@ func (f *BlockFetcher) loop() {
 				break
 			}
 			// If we have a valid block number, check that it's potentially useful
-			if notification.number > 0 {
-				if dist := int64(notification.number) - int64(f.chainHeight()); dist < -maxUncleDist || dist > maxQueueDist {
-					log.Debug("Peer discarded announcement", "peer", notification.origin, "number", notification.number, "hash", notification.hash, "distance", dist)
-					blockAnnounceDropMeter.Mark(1)
-					break
-				}
+			height := f.chainHeight()
+			if !IsPlausibleAnnouncement(notification.number, height) {
+				log.Debug("Peer discarded announcement", "peer", notification.origin, "number", notification.number, "hash", notification.hash, "height", height)
+				blockAnnounceDropMeter.Mark(1)
+				break
 			}
 			// All is well, schedule the announce if block's not yet downloading
 			if _, ok := f.fetching[notification.hash]; ok {

eth/fetcher/block_fetcher_test.go

@@ -629,6 +629,28 @@ func TestDistantPropagationDiscarding(t *testing.T) {
 	}
 }
 
+// Tests that IsPlausibleAnnouncement accepts announcements within the fetcher's
+// plausibility window and rejects those too far from the local chain head.
+func TestIsPlausibleAnnouncement(t *testing.T) {
+	height := uint64(1000)
+	tests := []struct {
+		number uint64
+		want   bool
+	}{
+		{number: 0, want: true},                          // Unknown height, always plausible
+		{number: height - maxUncleDist, want: true},      // Backward window edge
+		{number: height - maxUncleDist - 1, want: false}, // Too far behind
+		{number: height + maxQueueDist, want: true},      // Forward window edge
+		{number: height + maxQueueDist + 1, want: false}, // Too far ahead
+		{number: ^uint64(0), want: false},                // Far future
+	}
+	for i, tt := range tests {
+		if got := IsPlausibleAnnouncement(tt.number, height); got != tt.want {
+			t.Fatalf("case %d: number=%d got %v, want %v", i, tt.number, got, tt.want)
+		}
+	}
+}
+
 // Tests that announcements with numbers much lower or higher than out current
 // head get discarded to prevent wasting resources on useless blocks from faulty
 // peers.

eth/handler.go

@@ -733,9 +733,14 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
 		if err := msg.Decode(&announces); err != nil {
 			return errResp(ErrDecode, "%v: %v", msg, err)
 		}
-		// Mark the hashes as present at the remote node
+		// Mark the hashes as present at the remote node and track the highest
+		// plausible announced block as the peer's live tip.
+		height := pm.blockchain.CurrentBlock().Number.Uint64()
 		for _, block := range announces {
 			p.MarkBlock(block.Hash)
+			if fetcher.IsPlausibleAnnouncement(block.Number, height) {
+				p.SetTipNumber(block.Number)
+			}
 		}
 		// Schedule all the unknown hashes for retrieval
 		unknown := make(newBlockHashesData, 0, len(announces))
@@ -768,8 +773,13 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
 		request.Block.ReceivedAt = msg.ReceivedAt
 		request.Block.ReceivedFrom = p
 
-		// Mark the peer as owning the block and schedule it for import
+		// Mark the peer as owning the block, track its tip (only when the block
+		// number is within the fetcher's plausibility window), and schedule it
+		// for import
 		p.MarkBlock(request.Block.Hash())
+		if fetcher.IsPlausibleAnnouncement(request.Block.NumberU64(), pm.blockchain.CurrentBlock().Number.Uint64()) {
+			p.SetTipNumber(request.Block.NumberU64())
+		}
 		pm.blockFetcher.Enqueue(p.id, request.Block)
 
 		// Assuming the block is importable by the peer, but possibly not yet done so,

eth/peer.go

@@ -95,6 +95,8 @@ type peer struct {
 	td   *big.Int
 	lock sync.RWMutex
 
+	tipNumber uint64 // Highest block number announced by the peer (live network high-water mark)
+
 	knownBlocks     mapset.Set[common.Hash] // Set of block hashes known to be known by this peer
 	queuedBlocks    chan *propEvent         // Queue of blocks to broadcast to the peer
 	queuedBlockAnns chan *types.Block       // Queue of blocks to announce to the peer
@@ -343,6 +345,25 @@ func (p *peer) SetHead(hash common.Hash, td *big.Int) {
 	p.td.Set(td)
 }
 
+// TipNumber retrieves the highest block number announced by the peer.
+func (p *peer) TipNumber() uint64 {
+	p.lock.RLock()
+	defer p.lock.RUnlock()
+	return p.tipNumber
+}
+
+// SetTipNumber records the highest block number announced by the peer. The tip
+// only ever moves forward; unlike SetHead (which conservatively tracks the
+// parent of an announced block), this reflects the actual tip the peer has
+// advertised, so it can serve as a live network high-water mark.
+func (p *peer) SetTipNumber(number uint64) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	if number > p.tipNumber {
+		p.tipNumber = number
+	}
+}
+
 // MarkBlock marks a block as known for the peer, ensuring that the block will
 // never be propagated to this particular peer.
 func (p *peer) MarkBlock(hash common.Hash) {
@@ -1041,6 +1062,22 @@ func (ps *peerSet) BestPeer() *peer {
 	return bestPeer
 }
 
+// HighestTipNumber returns the highest block number announced by any known
+// peer, providing a live network high-water mark that stays current even when
+// the downloader is idle.
+func (ps *peerSet) HighestTipNumber() uint64 {
+	ps.lock.RLock()
+	defer ps.lock.RUnlock()
+
+	var highest uint64
+	for _, p := range ps.peers {
+		if tip := p.TipNumber(); tip > highest {
+			highest = tip
+		}
+	}
+	return highest
+}
+
 // Close disconnects all peers.
 // No new peers can be registered after Close has returned.
 func (ps *peerSet) Close() {

eth/sync.go

@@ -205,24 +205,65 @@ func (pm *ProtocolManager) syncStatusLogger() {
 	for {
 		select {
 		case <-ticker.C:
-			if pm.downloader.Synchronising() {
-				progress := pm.downloader.Progress()
-				log.Warn("Block synchronisation in progress",
-					"starting", progress.StartingBlock,
-					"current", progress.CurrentBlock,
-					"highest", progress.HighestBlock,
-					"pulledStates", progress.PulledStates,
-					"knownStates", progress.KnownStates,
-					"peers", pm.peers.Len(),
-				)
-			}
+			pm.reportSyncStatus()
 
 		case <-pm.quitSync:
 			return
 		}
 	}
 }
 
+// reportSyncStatus emits a warn-level periodic sync status line, so that the
+// current sync state is always visible in the logs every cycle regardless of
+// whether the node is catching up or already in sync.
+func (pm *ProtocolManager) reportSyncStatus() {
+	var (
+		current uint64
+		highest uint64
+	)
+	// While the downloader is actively synchronising, prefer its progress: it
+	// knows the discovered sync target (peers may not send block announcements
+	// during a bulk sync) and, in fast sync, reports the snap block as the
+	// current height.
+	if pm.downloader.Synchronising() {
+		progress := pm.downloader.Progress()
+		current, highest = progress.CurrentBlock, progress.HighestBlock
+	} else {
+		current = pm.blockchain.CurrentBlock().Number.Uint64()
+	}
+	status := computeSyncStatus(current, highest, pm.peers.HighestTipNumber())
+	log.Warn("Block synchronisation status",
+		"current", status.current,
+		"highest", status.highest,
+		"behind", status.behind,
+		"peers", pm.peers.Len(),
+	)
+}
+
+// syncStatus holds the values reported by the periodic sync status heartbeat.
+type syncStatus struct {
+	current uint64 // Local head, or the fast-sync snap block while bulk syncing
+	highest uint64 // Highest known network block (downloader target + announced tips)
+	behind  uint64 // Number of blocks behind the highest known network block
+}
+
+// computeSyncStatus derives the heartbeat values, merging the downloader's
+// discovered target with the live network high-water mark from announced tips
+// so the reported highest stays current even outside downloader bulk syncs.
+func computeSyncStatus(current, highest, announcedTip uint64) syncStatus {
+	if announcedTip > highest {
+		highest = announcedTip
+	}
+	if current > highest {
+		highest = current
+	}
+	behind := uint64(0)
+	if highest > current {
+		behind = highest - current
+	}
+	return syncStatus{current: current, highest: highest, behind: behind}
+}
+
 // synchronise tries to sync up our local block chain with a remote peer.
 func (pm *ProtocolManager) synchronise(peer *peer) {
 	// Short circuit if no peers are available