fix head

Author: Wondertan

sync/sync_head.go

@@ -61,6 +61,13 @@ func (s *Syncer[H]) Tail(ctx context.Context) (H, error) {
 	tail, err := s.store.Tail(ctx)
 	switch {
 	case errors.Is(err, header.ErrEmptyStore):
+		// TODO(@Wondertan): This is a temporary solution requesting the head directly from the network instead of
+		//  calling general Head path. This is needed to ensure Tail is written to the store first.
+		head, err := s.head.Head(ctx)
+		if err != nil {
+			return head, err
+		}
+
 		switch {
 		case s.Params.SyncFromHash != nil:
 			tail, err = s.getter.Get(ctx, s.Params.SyncFromHash)
@@ -73,23 +80,23 @@ func (s *Syncer[H]) Tail(ctx context.Context) (H, error) {
 				return tail, fmt.Errorf("getting tail header(%d): %w", s.Params.SyncFromHeight, err)
 			}
 		default:
-			head, err := s.Head(ctx)
-			if err != nil {
-				return head, err
-			}
-
 			tailHeight := estimateTail(head, s.Params.blockTime, s.Params.TrustingPeriod)
 			tail, err = s.getter.GetByHeight(ctx, tailHeight)
 			if err != nil {
 				return tail, fmt.Errorf("getting estimated tail header(%d): %w", tailHeight, err)
 			}
 		}
 
-		err = s.store.Store.Append(ctx, tail)
+		err = s.store.Append(ctx, tail)
 		if err != nil {
 			return tail, fmt.Errorf("appending tail header: %w", err)
 		}
 
+		err = s.incomingNetworkHead(ctx, head)
+		if err != nil {
+			return tail, fmt.Errorf("applying head from trusted peers: %w", err)
+		}
+
 	case !s.isTailActual(tail):
 		if s.Params.SyncFromHash != nil {
 			tail, err = s.getter.Get(ctx, s.Params.SyncFromHash)

sync/sync_head_test.go

@@ -23,7 +23,7 @@ func TestSyncer_Tail(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	t.Cleanup(cancel)
 
-	remoteStore := headertest.NewDummyStore(t)
+	remoteStore := headertest.NewStore[*headertest.DummyHeader](t, headertest.NewTestSuite(t), 100)
 
 	ds := dssync.MutexWrap(datastore.NewMapDatastore())
 	localStore, err := store.NewStore[*headertest.DummyHeader](ds)
@@ -44,9 +44,17 @@ func TestSyncer_Tail(t *testing.T) {
 	require.NoError(t, err)
 	assert.NotNil(t, tail)
 
+	err = syncer.Start(ctx)
+	require.NoError(t, err)
+
+	time.Sleep(time.Millisecond * 100)
 	storeTail, err := localStore.Tail(ctx)
 	require.NoError(t, err)
 	assert.EqualValues(t, tail.Height(), storeTail.Height())
+
+	storeHead, err := localStore.Head(ctx)
+	require.NoError(t, err)
+	assert.EqualValues(t, remoteStore.Height(), storeHead.Height())
 }
 
 func TestSyncer_HeadConcurrencyError(t *testing.T) {
@@ -435,7 +443,7 @@ type errorGetter struct{}
 
 func (e errorGetter) Head(
 	context.Context,
-	...header.HeadOption[*headertest.DummyHeader],
+...header.HeadOption[*headertest.DummyHeader],
 ) (*headertest.DummyHeader, error) {
 	time.Sleep(time.Millisecond * 1)
 	return nil, fmt.Errorf("error")

sync/sync_store.go

@@ -48,18 +48,20 @@ func (s *syncStore[H]) Append(ctx context.Context, headers ...H) error {
 	}
 
 	head, err := s.Head(ctx)
-	if err != nil && !errors.Is(err, context.Canceled) {
-		panic(err)
+	if err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, header.ErrEmptyStore) {
+		return err
 	}
 
-	for _, h := range headers {
-		if h.Height() != head.Height()+1 {
-			return &errNonAdjacent{
-				Head:      head.Height(),
-				Attempted: h.Height(),
+	if !errors.Is(err, header.ErrEmptyStore) {
+		for _, h := range headers {
+			if h.Height() != head.Height()+1 {
+				return &errNonAdjacent{
+					Head:      head.Height(),
+					Attempted: h.Height(),
+				}
 			}
+			head = h
 		}
-		head = h
 	}
 
 	if err := s.Store.Append(ctx, headers...); err != nil {