fix: sync service for non zero height starts with empty store

README.md

@@ -8,7 +8,7 @@ Ev-node is the basis of the Evolve Stack. For more in-depth information about Ev
 [![GoDoc](https://godoc.org/github.com/evstack/ev-node?status.svg)](https://godoc.org/github.com/evstack/ev-node)
 <!-- markdownlint-enable MD013 -->
 
-> **⚠️ Version Notice**: Do not use tags or releases before v1.*. Pre-v1 releases are not stable and should be considered abandoned. 
+> **⚠️ Version Notice**: Do not use tags or releases before v1.*. Pre-v1 releases are not stable and should be considered abandoned.
 
 ## Using Evolve
 

RELEASE.md

@@ -303,7 +303,7 @@ go get github.com/evstack/ev-node/core@v0.3.0
 
 - Wait 5-30 minutes for propagation
 - Use `go list -m` to verify availability
-- Check https://proxy.golang.org/
+- Check <https://proxy.golang.org/>
 
 **Dependency version conflicts**
 

docs/guides/full-node.md

@@ -4,7 +4,7 @@
 
 This guide covers how to set up a full node to run alongside a sequencer node in a Evolve-based blockchain network. A full node maintains a complete copy of the blockchain and helps validate transactions, improving the network's decentralization and security.
 
-> ** Note: The guide on how to run an evolve EVM full node can be found [here](./evm/single#setting-up-a-full-node). **
+> **Note: The guide on how to run an evolve EVM full node can be found [here](./evm/single#setting-up-a-full-node).**
 
 ## Prerequisites
 

docs/learn/config.md

@@ -658,6 +658,7 @@ curl http://localhost:7331/health/live
 #### `/health/ready`
 
 Returns `200 OK` if the node can serve correct data. Checks:
+
 - P2P is listening (if enabled)
 - Has synced blocks
 - Not too far behind network
@@ -669,6 +670,7 @@ curl http://localhost:7331/health/ready
 ```
 
 Configure max blocks behind:
+
 ```yaml
 node:
   readiness_max_blocks_behind: 15

pkg/sync/sync_service.go

@@ -135,11 +135,9 @@ func (syncService *SyncService[H]) WriteToStoreAndBroadcast(ctx context.Context,
 		return fmt.Errorf("empty header/data cannot write to store or broadcast")
 	}
 
-	isGenesis := headerOrData.Height() == syncService.genesis.InitialHeight
-	if isGenesis { // when starting the syncer for the first time, we have no blocks, so initFromP2P didn't initialize the genesis block.
-		if err := syncService.initStore(ctx, headerOrData); err != nil {
-			return fmt.Errorf("failed to initialize the store: %w", err)
-		}
+	storeInitialized, err := syncService.initStore(ctx, headerOrData)
+	if err != nil {
+		return fmt.Errorf("failed to initialize the store: %w", err)
 	}
 
 	firstStart := false
@@ -156,10 +154,10 @@ func (syncService *SyncService[H]) WriteToStoreAndBroadcast(ctx context.Context,
 		// as we have already initialized the store for starting the syncer.
 		// Hence, we ignore the error. Exact reason: validation ignored
 		if (firstStart && errors.Is(err, pubsub.ValidationError{Reason: pubsub.RejectValidationIgnored})) ||
-			// for the genesis header, broadcast error is expected as we have already initialized the store
+			// for the genesis header (or any first header used to bootstrap the store), broadcast error is expected as we have already initialized the store
 			// for starting the syncer. Hence, we ignore the error.
 			// exact reason: validation failed, err header verification failed: known header: '1' <= current '1'
-			(isGenesis && errors.Is(err, pubsub.ValidationError{Reason: pubsub.RejectValidationFailed})) {
+			((storeInitialized) && errors.Is(err, pubsub.ValidationError{Reason: pubsub.RejectValidationFailed})) {
 
 			return nil
 		}
@@ -221,23 +219,27 @@ func (syncService *SyncService[H]) startSyncer(ctx context.Context) error {
 
 // initStore initializes the store with the given initial header.
 // it is a no-op if the store is already initialized.
-func (syncService *SyncService[H]) initStore(ctx context.Context, initial H) error {
+// Returns true when the store was initialized by this call.
+func (syncService *SyncService[H]) initStore(ctx context.Context, initial H) (bool, error) {
 	if initial.IsZero() {
-		return errors.New("failed to initialize the store")
+		return false, errors.New("failed to initialize the store")
 	}
 
 	if _, err := syncService.store.Head(ctx); errors.Is(err, header.ErrNotFound) || errors.Is(err, header.ErrEmptyStore) {
 		if err := syncService.store.Append(ctx, initial); err != nil {
-			return err
+			return false, err
 		}
 
 		if err := syncService.store.Sync(ctx); err != nil {
-			return err
+			return false, err
 		}
 
+		return true, nil
+	} else if err != nil {
+		return false, err
 	}
 
-	return nil
+	return false, nil
 }
 
 // setupP2PInfrastructure sets up the P2P infrastructure (Exchange, ExchangeServer, Store)
@@ -328,7 +330,7 @@ func (syncService *SyncService[H]) initFromP2PWithRetry(ctx context.Context, pee
 			}
 		}
 
-		if err := syncService.initStore(ctx, trusted); err != nil {
+		if _, err := syncService.initStore(ctx, trusted); err != nil {
 			return false, fmt.Errorf("failed to initialize the store: %w", err)
 		}
 		if err := syncService.startSyncer(ctx); err != nil {

pkg/sync/sync_service_test.go

@@ -114,6 +114,59 @@ func TestHeaderSyncServiceRestart(t *testing.T) {
 	cancel()
 }
 
+func TestHeaderSyncServiceInitFromHigherHeight(t *testing.T) {
+	mainKV := sync.MutexWrap(datastore.NewMapDatastore())
+	pk, _, err := crypto.GenerateEd25519Key(cryptoRand.Reader)
+	require.NoError(t, err)
+	noopSigner, err := noop.NewNoopSigner(pk)
+	require.NoError(t, err)
+	rnd := rand.New(rand.NewSource(1)) // nolint:gosec // test code only
+	mn := mocknet.New()
+
+	chainId := "test-chain-id"
+
+	proposerAddr := []byte("test")
+	genesisDoc := genesispkg.Genesis{
+		ChainID:         chainId,
+		StartTime:       time.Now(),
+		InitialHeight:   1,
+		ProposerAddress: proposerAddr,
+	}
+	conf := config.DefaultConfig()
+	conf.RootDir = t.TempDir()
+	nodeKey, err := key.LoadOrGenNodeKey(filepath.Dir(conf.ConfigPath()))
+	require.NoError(t, err)
+	logger := zerolog.Nop()
+	priv := nodeKey.PrivKey
+	h, err := mn.AddPeer(priv, nil)
+	require.NoError(t, err)
+
+	p2pClient, err := p2p.NewClientWithHost(conf.P2P, nodeKey.PrivKey, mainKV, chainId, logger, p2p.NopMetrics(), h)
+	require.NoError(t, err)
+
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+	require.NoError(t, p2pClient.Start(ctx))
+	t.Cleanup(func() { _ = p2pClient.Close() })
+
+	svc, err := NewHeaderSyncService(mainKV, conf, genesisDoc, p2pClient, logger)
+	require.NoError(t, err)
+	require.NoError(t, svc.Start(ctx))
+	t.Cleanup(func() { _ = svc.Stop(context.Background()) })
+
+	headerConfig := types.HeaderConfig{
+		Height:   genesisDoc.InitialHeight + 5,
+		DataHash: bytesN(rnd, 32),
+		AppHash:  bytesN(rnd, 32),
+		Signer:   noopSigner,
+	}
+	signedHeader, err := types.GetRandomSignedHeaderCustom(&headerConfig, genesisDoc.ChainID)
+	require.NoError(t, err)
+	require.NoError(t, signedHeader.Validate())
+
+	require.NoError(t, svc.WriteToStoreAndBroadcast(ctx, signedHeader))
+}
+
 func nextHeader(t *testing.T, previousHeader *types.SignedHeader, chainID string, noopSigner signer.Signer) *types.SignedHeader {
 	newSignedHeader := &types.SignedHeader{
 		Header: types.GetRandomNextHeader(previousHeader.Header, chainID),