fix(pullsync): return empty offer at gap boundary to prevent interval over-advancement

When SubscribeBin returns a first chunk whose BinID is beyond the requested
start, the server has no chunks at [start, firstBinID-1]. Previously the
server included the chunk in the offer with Topmost=firstBinID, causing the
client to advance its interval across BinIDs it never received.

collectAddrs now detects this case: when the first chunk is within the
historical range (BinID <= historicalCursor) and its BinID is beyond the
requested start, the server returns an empty offer with Topmost=firstBinID-1.
The client advances its interval to the gap boundary only, then issues a new
Get from firstBinID and receives the chunk cleanly on the next round.

The check is skipped for start=0 (the BinID namespace starts at 1; the
puller always uses start>=1 in practice, but test helpers may pass 0).

A new test, TestSync_HistoricalGapReturnsEmptyOfferAtBoundary, covers the
gap-boundary case directly.

Author: misaakidis

pkg/pullsync/pullsync.go

@@ -484,6 +484,17 @@ func (s *Syncer) collectAddrs(ctx context.Context, bin uint8, start uint64) ([]*
 					break LOOP // The stream has been closed.
 				}
 
+				// If the first chunk the server offers has a BinID beyond start
+				// and within the historical range, the server has no chunks at
+				// [start, c.BinID-1]. Return an empty offer with Topmost set to
+				// the gap boundary so the client advances its interval past only
+				// the BinIDs that genuinely do not exist on this server, then
+				// retries from c.BinID on the next round.
+				if len(chs) == 0 && start > 0 && c.BinID > start && c.BinID <= historicalCursor {
+					topmost = c.BinID - 1
+					break LOOP
+				}
+
 				chs = append(chs, &storer.BinC{Address: c.Address, BatchID: c.BatchID, StampHash: c.StampHash})
 				if c.BinID > topmost {
 					topmost = c.BinID

pkg/pullsync/pullsync_test.go

@@ -397,6 +397,49 @@ func TestSync_LiveChunkTopCappedAtCursor(t *testing.T) {
 	})
 }
 
+// TestSync_HistoricalGapReturnsEmptyOfferAtBoundary verifies that when the
+// server's first available chunk has a BinID beyond the requested start, the
+// server returns an empty offer with Topmost set to firstBinID-1. This lets
+// the client advance its interval to the gap boundary without silently marking
+// BinIDs that may exist on other peers as synced.
+func TestSync_HistoricalGapReturnsEmptyOfferAtBoundary(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		chunk := testingc.GenerateTestRandomChunk()
+		stampHash, err := chunk.Stamp().Hash()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// Server holds one chunk at BinID 5; start=2 creates a gap at [2,4].
+		const firstBinID = uint64(5)
+		const cursor = uint64(5)
+		result := []*storer.BinC{{
+			Address:   chunk.Address(),
+			BatchID:   chunk.Stamp().BatchID(),
+			BinID:     firstBinID,
+			StampHash: stampHash,
+		}}
+
+		var (
+			ps, _       = newPullSync(t, nil, 10, mock.WithSubscribeResp(result, nil), mock.WithChunks(chunk), mock.WithCursors([]uint64{cursor}, 0))
+			recorder    = streamtest.New(streamtest.WithProtocols(ps.Protocol()))
+			psClient, _ = newPullSync(t, recorder, 0)
+		)
+
+		topmost, count, err := psClient.Sync(context.Background(), swarm.ZeroAddress, 0, 2)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Empty offer: gap boundary is firstBinID-1.
+		if topmost != firstBinID-1 {
+			t.Fatalf("topmost: got %d, want %d (gap boundary)", topmost, firstBinID-1)
+		}
+		if count != 0 {
+			t.Fatalf("count: got %d, want 0 (no chunks in gap)", count)
+		}
+	})
+}
+
 // TestSync_OverwriteNewerChunkDoesNotBlockInterval verifies that
 // ErrOverwriteNewerChunk does not prevent interval advancement.
 // The chunk is already present in the reserve with a newer stamp, so it is