fix(manager): removes outdated syncTarget field

block/block.go

@@ -93,7 +93,9 @@ func (m *Manager) applyBlock(block *types.Block, commit *types.Commit, blockMeta
 	}
 
 	// Prune old heights, if requested by ABCI app.
-	if retainHeight > 0 {
+	wantToPrune := 0 < retainHeight
+	canPrune := !m.IsSequencer() || (uint64(retainHeight) <= m.NextHeightToSubmit()) // do not delete anything that we might submit in future
+	if wantToPrune && canPrune {
 		_, err := m.pruneBlocks(uint64(retainHeight))
 		if err != nil {
 			m.logger.Error("prune blocks", "retain_height", retainHeight, "err", err)

block/manager.go

@@ -60,7 +60,9 @@
 	AccumulatedBatchSize atomic.Uint64
 	// The last height which was submitted to both sublayers, that we know of. When we produce new batches, we will
 	// start at this height + 1. Note: only accessed by one thread at a time so doesn't need synchro.
-	LastSubmittedHeight uint64
+	// It is ALSO used by the producer, because the producer needs to check if it can prune blocks and it wont'
+	// prune anything that might be submitted in the future. Therefore, it must be atomic.
+	LastSubmittedHeight atomic.Uint64
 
 	/*
 		Retrieval
@@ -130,13 +132,11 @@
 func (m *Manager) Start(ctx context.Context) error {
 	m.logger.Info("Starting the block manager")
 
-	slProposerKey := m.SLClient.GetProposer().PublicKey.Bytes()
-	localProposerKey, err := m.ProposerKey.GetPublic().Raw()
+	isSequencer, err := m.IsSequencerVerify()
 	if err != nil {
-		return fmt.Errorf("get local node public key: %w", err)
+		return err
 	}
 
-	isSequencer := bytes.Equal(slProposerKey, localProposerKey)
 	m.logger.Info("Starting block manager", "isSequencer", isSequencer)
 
 	// Check if InitChain flow is needed
@@ -164,14 +164,28 @@
 		go m.SubmitLoop(ctx)
 	} else {
 		go m.RetrieveLoop(ctx)
 		go m.SyncToTargetHeightLoop(ctx)
 	}
 
 	return nil
 }
 
+func (m *Manager) IsSequencerVerify() (bool, error) {
+	slProposerKey := m.SLClient.GetProposer().PublicKey.Bytes()
+	localProposerKey, err := m.ProposerKey.GetPublic().Raw()
+	if err != nil {
+		return false, fmt.Errorf("get local node public key: %w", err)
+	}
+	return bytes.Equal(slProposerKey, localProposerKey), nil
+}
+
+func (m *Manager) IsSequencer() bool {
+	ret, _ := m.IsSequencerVerify()
+	return ret
+}
+
 func (m *Manager) NextHeightToSubmit() uint64 {
-	return m.LastSubmittedHeight + 1
+	return m.LastSubmittedHeight.Load() + 1
 }
 
 // syncBlockManager enforces the node to be synced on initial run.
@@ -180,19 +194,19 @@
 	if errors.Is(err, gerr.ErrNotFound) {
 		// The SL hasn't got any batches for this chain yet.
 		m.logger.Info("No batches for chain found in SL.")
-		m.LastSubmittedHeight = uint64(m.Genesis.InitialHeight - 1)
+		m.LastSubmittedHeight.Store(uint64(m.Genesis.InitialHeight - 1))
 		return nil
 	}
 	if err != nil {
 		// TODO: separate between fresh rollapp and non-registered rollapp
 		return err
 	}
-	m.LastSubmittedHeight = res.EndHeight
+	m.LastSubmittedHeight.Store(res.EndHeight)
 	err = m.syncToTargetHeight(res.EndHeight)
 	if err != nil {
 		return err
 	}
 
-	m.logger.Info("Synced.", "current height", m.State.Height(), "last submitted height", m.LastSubmittedHeight)
+	m.logger.Info("Synced.", "current height", m.State.Height(), "last submitted height", m.LastSubmittedHeight.Load())
 	return nil
 }

block/manager_test.go

@@ -134,7 +134,7 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 	}
 
 	// Initially sync target is 0
-	assert.Zero(t, manager.LastSubmittedHeight)
+	assert.Zero(t, manager.LastSubmittedHeight.Load())
 	assert.True(t, manager.State.Height() == 0)
 
 	// enough time to sync and produce blocks
@@ -148,7 +148,7 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 		assert.NoError(t, err)
 	}()
 	<-ctx.Done()
-	assert.Equal(t, batch.EndHeight, manager.LastSubmittedHeight)
+	assert.Equal(t, batch.EndHeight, manager.LastSubmittedHeight.Load())
 	// validate that we produced blocks
 	assert.Greater(t, manager.State.Height(), batch.EndHeight)
 }

block/submit.go

@@ -137,7 +137,7 @@ func (m *Manager) HandleSubmissionTrigger() error {
 	}
 
 	types.RollappHubHeightGauge.Set(float64(actualEndHeight))
-	m.LastSubmittedHeight = actualEndHeight
+	m.LastSubmittedHeight.Store(actualEndHeight)
 	return nil
 }
 

block/submit_test.go

@@ -39,17 +39,17 @@ func TestBatchSubmissionHappyFlow(t *testing.T) {
 	// Check initial assertions
 	initialHeight := uint64(0)
 	require.Zero(manager.State.Height())
-	require.Zero(manager.LastSubmittedHeight)
+	require.Zero(manager.LastSubmittedHeight.Load())
 
 	// Produce block and validate that we produced blocks
 	_, _, err = manager.ProduceAndGossipBlock(ctx, true)
 	require.NoError(err)
 	assert.Greater(t, manager.State.Height(), initialHeight)
-	assert.Zero(t, manager.LastSubmittedHeight)
+	assert.Zero(t, manager.LastSubmittedHeight.Load())
 
 	// submit and validate sync target
 	manager.HandleSubmissionTrigger()
-	assert.EqualValues(t, manager.State.Height(), manager.LastSubmittedHeight)
+	assert.EqualValues(t, manager.State.Height(), manager.LastSubmittedHeight.Load())
 }
 
 func TestBatchSubmissionFailedSubmission(t *testing.T) {
@@ -86,13 +86,13 @@ func TestBatchSubmissionFailedSubmission(t *testing.T) {
 	// Check initial assertions
 	initialHeight := uint64(0)
 	require.Zero(manager.State.Height())
-	require.Zero(manager.LastSubmittedHeight)
+	require.Zero(manager.LastSubmittedHeight.Load())
 
 	// Produce block and validate that we produced blocks
 	_, _, err = manager.ProduceAndGossipBlock(ctx, true)
 	require.NoError(err)
 	assert.Greater(t, manager.State.Height(), initialHeight)
-	assert.Zero(t, manager.LastSubmittedHeight)
+	assert.Zero(t, manager.LastSubmittedHeight.Load())
 
 	// try to submit, we expect failure
 	mockLayerI.On("SubmitBatch", mock.Anything, mock.Anything, mock.Anything).Return(fmt.Errorf("submit batch")).Once()
@@ -101,7 +101,7 @@ func TestBatchSubmissionFailedSubmission(t *testing.T) {
 	// try to submit again, we expect success
 	mockLayerI.On("SubmitBatch", mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 	manager.HandleSubmissionTrigger()
-	assert.EqualValues(t, manager.State.Height(), manager.LastSubmittedHeight)
+	assert.EqualValues(t, manager.State.Height(), manager.LastSubmittedHeight.Load())
 }
 
 // TestSubmissionByTime tests the submission trigger by time
@@ -135,7 +135,7 @@ func TestSubmissionByTime(t *testing.T) {
 	// Check initial height
 	initialHeight := uint64(0)
 	require.Equal(initialHeight, manager.State.Height())
-	require.Zero(manager.LastSubmittedHeight)
+	require.Zero(manager.LastSubmittedHeight.Load())
 
 	var wg sync.WaitGroup
 	mCtx, cancel := context.WithTimeout(context.Background(), 2*submitTimeout)
@@ -154,7 +154,7 @@ func TestSubmissionByTime(t *testing.T) {
 	}()
 
 	wg.Wait() // Wait for all goroutines to finish
-	require.True(0 < manager.LastSubmittedHeight)
+	require.True(0 < manager.LastSubmittedHeight.Load())
 }
 
 // TestSubmissionByBatchSize tests the submission trigger by batch size
@@ -201,7 +201,7 @@ func TestSubmissionByBatchSize(t *testing.T) {
 		}()
 
 		go func() {
-			assert.Zero(manager.LastSubmittedHeight)
+			assert.Zero(manager.LastSubmittedHeight.Load())
 			manager.SubmitLoop(ctx)
 			wg.Done() // Decrease counter when this goroutine finishes
 		}()
@@ -215,9 +215,9 @@ func TestSubmissionByBatchSize(t *testing.T) {
 		wg.Wait() // Wait for all goroutines to finish
 
 		if c.expectedSubmission {
-			assert.Positive(manager.LastSubmittedHeight)
+			assert.Positive(manager.LastSubmittedHeight.Load())
 		} else {
-			assert.Zero(manager.LastSubmittedHeight)
+			assert.Zero(manager.LastSubmittedHeight.Load())
 		}
 	}
 }