extract epoch calculation

Author: julienrbrt

block/internal/syncing/da_retriever.go

@@ -114,7 +114,7 @@ func (r *daRetriever) RetrieveForcedIncludedTxsFromDA(ctx context.Context, daHei
 	}
 
 	// Calculate deterministic epoch boundaries
-	epochStart, epochEnd := r.calculateEpochBoundaries(daHeight)
+	epochStart, epochEnd := types.CalculateEpochBoundaries(daHeight, r.genesis.DAStartHeight, r.daEpochSize)
 
 	// Only fetch at epoch start to prevent double fetching as DA height progresses
 	if daHeight != epochStart {
@@ -137,7 +137,7 @@ func (r *daRetriever) RetrieveForcedIncludedTxsFromDA(ctx context.Context, daHei
 		Uint64("da_height", daHeight).
 		Uint64("epoch_start", epochStart).
 		Uint64("epoch_end", epochEnd).
-		Uint64("epoch_num", r.calculateEpochNumber(daHeight)).
+		Uint64("epoch_num", types.CalculateEpochNumber(daHeight, r.genesis.DAStartHeight, r.daEpochSize)).
 		Msg("retrieving forced included transactions from DA")
 
 	// Check if both epoch start and end are available before fetching
@@ -247,38 +247,6 @@ func (r *daRetriever) processForcedInclusionBlobs(
 	return nil
 }
 
-// calculateEpochNumber returns the deterministic epoch number for a given DA height.
-// Epoch 1 starts at DAStartHeight.
-func (r *daRetriever) calculateEpochNumber(daHeight uint64) uint64 {
-	if daHeight < r.genesis.DAStartHeight {
-		return 0
-	}
-
-	if r.daEpochSize == 0 {
-		return 1
-	}
-
-	return ((daHeight - r.genesis.DAStartHeight) / r.daEpochSize) + 1
-}
-
-// calculateEpochBoundaries returns the start and end DA heights for the epoch
-// containing the given DA height. The boundaries are inclusive.
-func (r *daRetriever) calculateEpochBoundaries(daHeight uint64) (start, end uint64) {
-	if daHeight < r.genesis.DAStartHeight {
-		return r.genesis.DAStartHeight, r.genesis.DAStartHeight + r.daEpochSize - 1
-	}
-
-	if r.daEpochSize == 0 {
-		return r.genesis.DAStartHeight, r.genesis.DAStartHeight
-	}
-
-	epochNum := r.calculateEpochNumber(daHeight)
-	start = r.genesis.DAStartHeight + (epochNum-1)*r.daEpochSize
-	end = r.genesis.DAStartHeight + epochNum*r.daEpochSize - 1
-
-	return start, end
-}
-
 // fetchBlobs retrieves blobs from the DA layer
 func (r *daRetriever) fetchBlobs(ctx context.Context, daHeight uint64) (coreda.ResultRetrieve, error) {
 	// Retrieve from both namespaces

block/internal/syncing/da_retriever_test.go

@@ -624,203 +624,6 @@ func TestDARetriever_RetrieveForcedIncludedTxsFromDA_ExceedsMaxBlobSize(t *testi
 	assert.Greater(t, totalSizeWithThird, int(common.DefaultMaxBlobSize))
 }
 
-func TestDARetriever_CalculateEpochNumber(t *testing.T) {
-	tests := []struct {
-		name          string
-		daStartHeight uint64
-		daEpochSize   uint64
-		daHeight      uint64
-		expectedEpoch uint64
-	}{
-		{
-			name:          "first epoch - start height",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      100,
-			expectedEpoch: 1,
-		},
-		{
-			name:          "first epoch - middle",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      105,
-			expectedEpoch: 1,
-		},
-		{
-			name:          "first epoch - last height",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      109,
-			expectedEpoch: 1,
-		},
-		{
-			name:          "second epoch - start",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      110,
-			expectedEpoch: 2,
-		},
-		{
-			name:          "second epoch - middle",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      115,
-			expectedEpoch: 2,
-		},
-		{
-			name:          "tenth epoch",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      195,
-			expectedEpoch: 10,
-		},
-		{
-			name:          "before start height",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      50,
-			expectedEpoch: 0,
-		},
-		{
-			name:          "zero epoch size",
-			daStartHeight: 100,
-			daEpochSize:   0,
-			daHeight:      200,
-			expectedEpoch: 1,
-		},
-		{
-			name:          "large epoch size",
-			daStartHeight: 1000,
-			daEpochSize:   1000,
-			daHeight:      2500,
-			expectedEpoch: 2,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ds := dssync.MutexWrap(datastore.NewMapDatastore())
-			st := store.New(ds)
-			cm, err := cache.NewManager(config.DefaultConfig(), st, zerolog.Nop())
-			require.NoError(t, err)
-
-			mockDA := testmocks.NewMockDA(t)
-			gen := genesis.Genesis{DAStartHeight: tt.daStartHeight}
-			cfg := config.DefaultConfig()
-			cfg.DA.ForcedInclusionDAEpoch = tt.daEpochSize
-
-			r := NewDARetriever(mockDA, cm, cfg, gen, zerolog.Nop())
-			epoch := r.calculateEpochNumber(tt.daHeight)
-
-			assert.Equal(t, tt.expectedEpoch, epoch)
-		})
-	}
-}
-
-func TestDARetriever_CalculateEpochBoundaries(t *testing.T) {
-	tests := []struct {
-		name          string
-		daStartHeight uint64
-		daEpochSize   uint64
-		daHeight      uint64
-		expectedStart uint64
-		expectedEnd   uint64
-	}{
-		{
-			name:          "first epoch",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      105,
-			expectedStart: 100,
-			expectedEnd:   109,
-		},
-		{
-			name:          "second epoch",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      110,
-			expectedStart: 110,
-			expectedEnd:   119,
-		},
-		{
-			name:          "third epoch - last height",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      129,
-			expectedStart: 120,
-			expectedEnd:   129,
-		},
-		{
-			name:          "before start height returns first epoch",
-			daStartHeight: 100,
-			daEpochSize:   10,
-			daHeight:      50,
-			expectedStart: 100,
-			expectedEnd:   109,
-		},
-		{
-			name:          "zero epoch size",
-			daStartHeight: 100,
-			daEpochSize:   0,
-			daHeight:      200,
-			expectedStart: 100,
-			expectedEnd:   100,
-		},
-		{
-			name:          "large epoch",
-			daStartHeight: 1000,
-			daEpochSize:   1000,
-			daHeight:      1500,
-			expectedStart: 1000,
-			expectedEnd:   1999,
-		},
-		{
-			name:          "epoch boundary exact start",
-			daStartHeight: 100,
-			daEpochSize:   50,
-			daHeight:      100,
-			expectedStart: 100,
-			expectedEnd:   149,
-		},
-		{
-			name:          "epoch boundary exact end of first epoch",
-			daStartHeight: 100,
-			daEpochSize:   50,
-			daHeight:      149,
-			expectedStart: 100,
-			expectedEnd:   149,
-		},
-		{
-			name:          "epoch boundary exact start of second epoch",
-			daStartHeight: 100,
-			daEpochSize:   50,
-			daHeight:      150,
-			expectedStart: 150,
-			expectedEnd:   199,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ds := dssync.MutexWrap(datastore.NewMapDatastore())
-			st := store.New(ds)
-			cm, err := cache.NewManager(config.DefaultConfig(), st, zerolog.Nop())
-			require.NoError(t, err)
-
-			mockDA := testmocks.NewMockDA(t)
-			gen := genesis.Genesis{DAStartHeight: tt.daStartHeight}
-			cfg := config.DefaultConfig()
-			cfg.DA.ForcedInclusionDAEpoch = tt.daEpochSize
-
-			r := NewDARetriever(mockDA, cm, cfg, gen, zerolog.Nop())
-			start, end := r.calculateEpochBoundaries(tt.daHeight)
-
-			assert.Equal(t, tt.expectedStart, start, "start height mismatch")
-			assert.Equal(t, tt.expectedEnd, end, "end height mismatch")
-		})
-	}
-}
-
 func TestDARetriever_RetrieveForcedIncludedTxsFromDA_NotAtEpochStart(t *testing.T) {
 	ds := dssync.MutexWrap(datastore.NewMapDatastore())
 	st := store.New(ds)

types/epoch.go

@@ -0,0 +1,50 @@
+package types
+
+// CalculateEpochNumber returns the deterministic epoch number for a given DA height.
+// Epoch 1 starts at daStartHeight.
+//
+// Parameters:
+//   - daHeight: The DA height to calculate the epoch for
+//   - daStartHeight: The genesis DA start height
+//   - daEpochSize: The number of DA blocks per epoch (0 means all blocks in epoch 1)
+//
+// Returns:
+//   - Epoch number (0 if before daStartHeight, 1+ otherwise)
+func CalculateEpochNumber(daHeight, daStartHeight, daEpochSize uint64) uint64 {
+	if daHeight < daStartHeight {
+		return 0
+	}
+
+	if daEpochSize == 0 {
+		return 1
+	}
+
+	return ((daHeight - daStartHeight) / daEpochSize) + 1
+}
+
+// CalculateEpochBoundaries returns the start and end DA heights for the epoch
+// containing the given DA height. The boundaries are inclusive.
+//
+// Parameters:
+//   - daHeight: The DA height to calculate boundaries for
+//   - daStartHeight: The genesis DA start height
+//   - daEpochSize: The number of DA blocks per epoch (0 means single epoch)
+//
+// Returns:
+//   - start: The first DA height in the epoch (inclusive)
+//   - end: The last DA height in the epoch (inclusive)
+func CalculateEpochBoundaries(daHeight, daStartHeight, daEpochSize uint64) (start, end uint64) {
+	if daHeight < daStartHeight {
+		return daStartHeight, daStartHeight + daEpochSize - 1
+	}
+
+	if daEpochSize == 0 {
+		return daStartHeight, daStartHeight
+	}
+
+	epochNum := CalculateEpochNumber(daHeight, daStartHeight, daEpochSize)
+	start = daStartHeight + (epochNum-1)*daEpochSize
+	end = daStartHeight + epochNum*daEpochSize - 1
+
+	return start, end
+}