bugfix(libs/header): store incoming head in syncer (#1724)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.
-->

## Overview
Closes #1728
<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 
-->

## Checklist

<!-- 
Please complete the checklist to ensure that the PR is ready to be
reviewed.

IMPORTANT:
PRs should be left in Draft until the below checklist is completed.
-->

- [x] New and updated code has appropriate documentation
- [x] New and updated code has new and/or updated testing
- [x] Required CI checks are passing
- [x] Visual proof for any user facing features like CLI or
documentation updates
- [x] Linked issues closed with keywords

---------

Co-authored-by: rene <[email protected]>

Author: vgonkivs

Diff for: libs/header/sync/sync.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	logging "github.com/ipfs/go-log/v2"
@@ -42,7 +43,7 @@ type Syncer[H header.Header] struct {
 	// signals to start syncing
 	triggerSync chan struct{}
 	// syncedHead is the latest synced header.
-	syncedHead H
+	syncedHead atomic.Pointer[H]
 	// pending keeps ranges of valid new network headers awaiting to be appended to store
 	pending ranges[H]
 	// netReqLk ensures only one network head is requested at any moment
@@ -177,42 +178,48 @@ func (s *Syncer[H]) sync(ctx context.Context) {
 		return
 	}
 
-	if s.syncedHead.IsZero() {
+	headPtr := s.syncedHead.Load()
+
+	var header H
+	if headPtr == nil {
 		head, err := s.store.Head(ctx)
 		if err != nil {
 			log.Errorw("getting head during sync", "err", err)
 			return
 		}
-		s.syncedHead = head
+		header = head
+	} else {
+		header = *headPtr
 	}
-	if s.syncedHead.Height() >= newHead.Height() {
+
+	if header.Height() >= newHead.Height() {
 		log.Warnw("sync attempt to an already synced header",
-			"synced_height", s.syncedHead.Height(),
+			"synced_height", header.Height(),
 			"attempted_height", newHead.Height(),
 		)
 		log.Warn("PLEASE REPORT THIS AS A BUG")
 		return // should never happen, but just in case
 	}
 
 	log.Infow("syncing headers",
-		"from", s.syncedHead.Height(),
+		"from", header.Height(),
 		"to", newHead.Height())
-	err := s.doSync(ctx, s.syncedHead, newHead)
+	err := s.doSync(ctx, header, newHead)
 	if err != nil {
 		if errors.Is(err, context.Canceled) {
 			// don't log this error as it is normal case of Syncer being stopped
 			return
 		}
 
 		log.Errorw("syncing headers",
-			"from", s.syncedHead.Height(),
+			"from", header.Height(),
 			"to", newHead.Height(),
 			"err", err)
 		return
 	}
 
 	log.Infow("finished syncing",
-		"from", s.syncedHead.Height(),
+		"from", header.Height(),
 		"to", newHead.Height(),
 		"elapsed time", s.state.End.Sub(s.state.Start))
 }
@@ -257,7 +264,7 @@ func (s *Syncer[H]) processHeaders(ctx context.Context, from, to uint64) (int, e
 
 	amount, err := s.store.Append(ctx, headers...)
 	if err == nil && amount > 0 {
-		s.syncedHead = headers[amount-1]
+		s.syncedHead.Store(&headers[amount-1])
 	}
 	return amount, err
 }

Diff for: libs/header/sync/sync_head.go

@@ -112,6 +112,7 @@ func (s *Syncer[H]) incomingNetHead(ctx context.Context, netHead H) pubsub.Valid
 	_, err := s.store.Append(ctx, netHead)
 	if err == nil {
 		// a happy case where we appended maybe head directly, so accept
+		s.syncedHead.Store(&netHead)
 		return pubsub.ValidationAccept
 	}
 	var nonAdj *header.ErrNonAdjacent

Diff for: libs/header/sync/sync_test.go

@@ -99,7 +99,10 @@ func TestSyncCatchUp(t *testing.T) {
 	// 4. assert syncer caught-up
 	have, err := localStore.Head(ctx)
 	require.NoError(t, err)
-	assert.Equal(t, syncer.syncedHead.Height(), incomingHead.Height())
+	headerPtr := syncer.syncedHead.Load()
+	require.NotNil(t, headerPtr)
+	head = *headerPtr
+	assert.Equal(t, head.Height(), incomingHead.Height())
 	assert.Equal(t, exp.Height()+1, have.Height()) // plus one as we didn't add last header to remoteStore
 	assert.Empty(t, syncer.pending.Head())
 
@@ -157,7 +160,11 @@ func TestSyncPendingRangesWithMisses(t *testing.T) {
 	require.NoError(t, err)
 	_, err = localStore.GetByHeight(ctx, 43)
 	require.NoError(t, err)
-	require.Equal(t, syncer.syncedHead.Height(), int64(43))
+
+	headerPtr := syncer.syncedHead.Load()
+	require.NotNil(t, headerPtr)
+	lastHead := *headerPtr
+	require.Equal(t, lastHead.Height(), int64(43))
 	exp, err := remoteStore.Head(ctx)
 	require.NoError(t, err)