simplify

Author: julienrbrt

block/internal/submitting/batching_strategy.go

@@ -14,6 +14,22 @@ type BatchingStrategy interface {
 	ShouldSubmit(pendingCount uint64, totalSize int, maxBlobSize int, timeSinceLastSubmit time.Duration) bool
 }
 
+// NewBatchingStrategy creates a batching strategy based on configuration
+func NewBatchingStrategy(cfg config.DAConfig) (BatchingStrategy, error) {
+	switch cfg.BatchingStrategy {
+	case "immediate":
+		return &ImmediateStrategy{}, nil
+	case "size":
+		return NewSizeBasedStrategy(cfg.BatchSizeThreshold, cfg.BatchMinItems), nil
+	case "time":
+		return NewTimeBasedStrategy(cfg.BlockTime.Duration, cfg.BatchMaxDelay.Duration, cfg.BatchMinItems), nil
+	case "adaptive":
+		return NewAdaptiveStrategy(cfg.BlockTime.Duration, cfg.BatchSizeThreshold, cfg.BatchMaxDelay.Duration, cfg.BatchMinItems), nil
+	default:
+		return nil, fmt.Errorf("unknown batching strategy: %s", cfg.BatchingStrategy)
+	}
+}
+
 // ImmediateStrategy submits as soon as any items are available
 type ImmediateStrategy struct{}
 
@@ -122,22 +138,6 @@ func (s *AdaptiveStrategy) ShouldSubmit(pendingCount uint64, totalSize int, maxB
 	return false
 }
 
-// NewBatchingStrategy creates a batching strategy based on configuration
-func NewBatchingStrategy(cfg config.DAConfig) (BatchingStrategy, error) {
-	switch cfg.BatchingStrategy {
-	case "immediate":
-		return &ImmediateStrategy{}, nil
-	case "size":
-		return NewSizeBasedStrategy(cfg.BatchSizeThreshold, cfg.BatchMinItems), nil
-	case "time":
-		return NewTimeBasedStrategy(cfg.BlockTime.Duration, cfg.BatchMaxDelay.Duration, cfg.BatchMinItems), nil
-	case "adaptive":
-		return NewAdaptiveStrategy(cfg.BlockTime.Duration, cfg.BatchSizeThreshold, cfg.BatchMaxDelay.Duration, cfg.BatchMinItems), nil
-	default:
-		return nil, fmt.Errorf("unknown batching strategy: %s", cfg.BatchingStrategy)
-	}
-}
-
 // estimateBatchSize estimates the total size of pending items
 // This is a helper function that can be used by the submitter
 func estimateBatchSize(marshaled [][]byte) int {
@@ -180,39 +180,6 @@ func optimizeBatchSize(marshaled [][]byte, maxBlobSize int, targetUtilization fl
 	return count
 }
 
-// BatchMetrics provides information about batch efficiency
-type BatchMetrics struct {
-	ItemCount     int
-	TotalBytes    int
-	MaxBlobBytes  int
-	Utilization   float64 // percentage of max blob size used
-	EstimatedCost float64 // estimated cost relative to single full blob
-}
-
-// calculateBatchMetrics computes metrics for a batch
-func calculateBatchMetrics(itemCount int, totalBytes int, maxBlobBytes int) BatchMetrics {
-	utilization := 0.0
-	if maxBlobBytes > 0 {
-		utilization = float64(totalBytes) / float64(maxBlobBytes)
-	}
-
-	// Rough cost estimate: each blob submission has a fixed cost
-	// Higher utilization = better cost efficiency
-	estimatedCost := 1.0
-	if utilization > 0 {
-		// If we're only using 50% of the blob, we're paying 2x per byte effectively
-		estimatedCost = 1.0 / utilization
-	}
-
-	return BatchMetrics{
-		ItemCount:     itemCount,
-		TotalBytes:    totalBytes,
-		MaxBlobBytes:  maxBlobBytes,
-		Utilization:   utilization,
-		EstimatedCost: estimatedCost,
-	}
-}
-
 // ShouldWaitForMoreItems determines if we should wait for more items
 // to improve batch efficiency
 func ShouldWaitForMoreItems(
@@ -239,10 +206,3 @@ func ShouldWaitForMoreItems(
 
 	return currentUtilization < minUtilization-epsilon
 }
-
-// BatchingConfig holds configuration for batch optimization
-type BatchingConfig struct {
-	MaxBlobSize       int
-	Strategy          BatchingStrategy
-	TargetUtilization float64
-}

block/internal/submitting/batching_strategy_test.go

@@ -406,63 +406,6 @@ func TestOptimizeBatchSize(t *testing.T) {
 	}
 }
 
-func TestCalculateBatchMetrics(t *testing.T) {
-	maxBlobSize := 8 * 1024 * 1024
-
-	tests := []struct {
-		name              string
-		itemCount         int
-		totalBytes        int
-		expectedUtil      float64
-		expectedCostRange [2]float64 // min, max
-	}{
-		{
-			name:              "empty batch",
-			itemCount:         0,
-			totalBytes:        0,
-			expectedUtil:      0.0,
-			expectedCostRange: [2]float64{0, 999999}, // cost is undefined for empty
-		},
-		{
-			name:              "half full",
-			itemCount:         10,
-			totalBytes:        4 * 1024 * 1024,
-			expectedUtil:      0.5,
-			expectedCostRange: [2]float64{2.0, 2.0}, // 1/0.5 = 2.0x cost
-		},
-		{
-			name:              "80% full",
-			itemCount:         20,
-			totalBytes:        int(float64(maxBlobSize) * 0.8),
-			expectedUtil:      0.8,
-			expectedCostRange: [2]float64{1.25, 1.25}, // 1/0.8 = 1.25x cost
-		},
-		{
-			name:              "nearly full",
-			itemCount:         50,
-			totalBytes:        int(float64(maxBlobSize) * 0.95),
-			expectedUtil:      0.95,
-			expectedCostRange: [2]float64{1.05, 1.06}, // ~1.05x cost
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			metrics := calculateBatchMetrics(tt.itemCount, tt.totalBytes, maxBlobSize)
-
-			assert.Equal(t, tt.itemCount, metrics.ItemCount)
-			assert.Equal(t, tt.totalBytes, metrics.TotalBytes)
-			assert.Equal(t, maxBlobSize, metrics.MaxBlobBytes)
-			assert.InDelta(t, tt.expectedUtil, metrics.Utilization, 0.01)
-
-			if tt.totalBytes > 0 {
-				assert.InEpsilon(t, (tt.expectedCostRange[0]+tt.expectedCostRange[1])/2,
-					metrics.EstimatedCost, 0.01, "cost should be within range")
-			}
-		})
-	}
-}
-
 func TestShouldWaitForMoreItems(t *testing.T) {
 	maxBlobSize := 8 * 1024 * 1024
 

block/internal/submitting/submitter.go

@@ -88,7 +88,6 @@ func NewSubmitter(
 ) *Submitter {
 	submitterLogger := logger.With().Str("component", "submitter").Logger()
 
-	// Initialize batching strategy
 	strategy, err := NewBatchingStrategy(config.DA)
 	if err != nil {
 		submitterLogger.Warn().Err(err).Msg("failed to create batching strategy, using time-based default")