feat: solo sequencer, testapp max blob size ldflags (#3235)

* feat: solo sequencer

* refactor: set max blob size as ldflag

* refactor: wire solo sequencer in testapp

* updates

* fix ldflag

* cleanup api

* better defaults

* cleanup readme

* fixes

* nit

* fix typo

Author: julienrbrt

CHANGELOG.md

@@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changes
 
+- Make it easier to override `DefaultMaxBlobSize` by ldflags [#3235](https://github.com/evstack/ev-node/pull/3235)
+- Add solo sequencer (simple in memory single sequencer without force inclusion) [#3235](https://github.com/evstack/ev-node/pull/3235)
 - Improve reaper to sustain txs burst better [#3236](https://github.com/evstack/ev-node/pull/3236)
 
 ## v1.1.0

apps/testapp/Dockerfile

@@ -27,7 +27,9 @@ RUN go mod download && (cd apps/testapp && go mod download)
 COPY . .
 
 WORKDIR /ev-node/apps/testapp
-RUN go build -o /go/bin/testapp .
+
+# 125829120 = 120 MB
+RUN go build -ldflags "-X github.com/evstack/ev-node/block/internal/common.defaultMaxBlobSizeStr=125829120" -o /go/bin/testapp .
 
 ## prep the final image.
 #

apps/testapp/cmd/init.go

@@ -35,7 +35,7 @@ func InitCmd() *cobra.Command {
 			// we use load in order to parse all the flags
 			cfg, _ := rollconf.Load(cmd)
 			cfg.Node.Aggregator = aggregator
-			cfg.Node.BlockTime = rollconf.DurationWrapper{Duration: 10 * time.Millisecond}
+			cfg.Node.BlockTime = rollconf.DurationWrapper{Duration: 100 * time.Millisecond}
 			if err := cfg.Validate(); err != nil {
 				return fmt.Errorf("error validating config: %w", err)
 			}

apps/testapp/cmd/root.go

@@ -12,13 +12,17 @@ const (
 
 	// flagKVEndpoint is the flag for the KV endpoint
 	flagKVEndpoint = "kv-endpoint"
+	// flagSoloSequencer is the flag to enable a solo sequencer
+	flagSoloSequencer = "solo-sequencer"
 )
 
 func init() {
 	config.AddGlobalFlags(RootCmd, AppName)
 	config.AddFlags(RunCmd)
-	// Add the KV endpoint flag specifically to the RunCmd
+
+	// add more flags to RunCmd
 	RunCmd.Flags().String(flagKVEndpoint, "", "Address and port for the KV executor HTTP server")
+	RunCmd.Flags().Bool(flagSoloSequencer, false, "Enable Solo sequencer (instead of based sequencer or single sequencer)")
 }
 
 // RootCmd is the root command for Evolve

apps/testapp/cmd/run.go

@@ -22,6 +22,7 @@ import (
 	"github.com/evstack/ev-node/pkg/p2p/key"
 	"github.com/evstack/ev-node/pkg/sequencers/based"
 	"github.com/evstack/ev-node/pkg/sequencers/single"
+	"github.com/evstack/ev-node/pkg/sequencers/solo"
 	"github.com/evstack/ev-node/pkg/store"
 )
 
@@ -91,7 +92,7 @@ var RunCmd = &cobra.Command{
 		}
 
 		// Create sequencer based on configuration
-		sequencer, err := createSequencer(ctx, logger, datastore, nodeConfig, genesis, executor)
+		sequencer, err := createSequencer(ctx, command, logger, datastore, nodeConfig, genesis, executor)
 		if err != nil {
 			return err
 		}
@@ -105,12 +106,21 @@ var RunCmd = &cobra.Command{
 // Otherwise, it creates a single (traditional) sequencer.
 func createSequencer(
 	ctx context.Context,
+	cmd *cobra.Command,
 	logger zerolog.Logger,
 	datastore datastore.Batching,
 	nodeConfig config.Config,
 	genesis genesis.Genesis,
 	executor execution.Executor,
 ) (coresequencer.Sequencer, error) {
+	if enabled, _ := cmd.Flags().GetBool(flagSoloSequencer); enabled {
+		if nodeConfig.Node.BasedSequencer {
+			return nil, fmt.Errorf("solo sequencer cannot be used with based")
+		}
+
+		return solo.NewSoloSequencer(logger, []byte(genesis.ChainID), executor), nil
+	}
+
 	blobClient, err := blobrpc.NewWSClient(ctx, logger, nodeConfig.DA.Address, nodeConfig.DA.AuthToken, "")
 	if err != nil {
 		return nil, fmt.Errorf("failed to create blob client: %w", err)

block/internal/common/consts.go

@@ -1,3 +1,21 @@
 package common
 
-const DefaultMaxBlobSize = 5 * 1024 * 1024 // 5MB fallback blob size limit
+import "strconv"
+
+// defaultMaxBlobSizeStr holds the string representation of the default blob
+// size limit. Override at link time via:
+//
+//	go build -ldflags "-X github.com/evstack/ev-node/block/internal/common.defaultMaxBlobSizeStr=125829120"
+var defaultMaxBlobSizeStr = "5242880" // 5 MB
+
+// DefaultMaxBlobSize is the max blob size limit used for blob submission.
+var DefaultMaxBlobSize uint64
+
+func init() {
+	v, err := strconv.ParseUint(defaultMaxBlobSizeStr, 10, 64)
+	if err != nil || v == 0 {
+		DefaultMaxBlobSize = 5 * 1024 * 1024 // 5 MB fallback
+		return
+	}
+	DefaultMaxBlobSize = v
+}

block/internal/da/client.go

@@ -559,7 +559,7 @@ func extractBlobData(resp *blobrpc.SubscriptionResponse) [][]byte {
 			continue
 		}
 		data := blob.Data()
-		if len(data) == 0 || len(data) > common.DefaultMaxBlobSize {
+		if len(data) == 0 || uint64(len(data)) > common.DefaultMaxBlobSize {
 			continue
 		}
 		blobs = append(blobs, data)

block/internal/submitting/batching_strategy.go

@@ -12,7 +12,7 @@ import (
 type BatchingStrategy interface {
 	// ShouldSubmit determines if a batch should be submitted based on the strategy
 	// Returns true if submission should happen now
-	ShouldSubmit(pendingCount uint64, totalSizeBeforeSig int, maxBlobSize int, timeSinceLastSubmit time.Duration) bool
+	ShouldSubmit(pendingCount uint64, totalSizeBeforeSig uint64, maxBlobSize uint64, timeSinceLastSubmit time.Duration) bool
 }
 
 // NewBatchingStrategy creates a batching strategy based on configuration
@@ -34,7 +34,7 @@ func NewBatchingStrategy(cfg config.DAConfig) (BatchingStrategy, error) {
 // ImmediateStrategy submits as soon as any items are available
 type ImmediateStrategy struct{}
 
-func (s *ImmediateStrategy) ShouldSubmit(pendingCount uint64, totalSize int, maxBlobSize int, timeSinceLastSubmit time.Duration) bool {
+func (s *ImmediateStrategy) ShouldSubmit(pendingCount uint64, totalSize uint64, maxBlobSize uint64, timeSinceLastSubmit time.Duration) bool {
 	return pendingCount > 0
 }
 
@@ -57,12 +57,12 @@ func NewSizeBasedStrategy(sizeThreshold float64, minItems uint64) *SizeBasedStra
 	}
 }
 
-func (s *SizeBasedStrategy) ShouldSubmit(pendingCount uint64, totalSize int, maxBlobSize int, timeSinceLastSubmit time.Duration) bool {
+func (s *SizeBasedStrategy) ShouldSubmit(pendingCount uint64, totalSize uint64, maxBlobSize uint64, timeSinceLastSubmit time.Duration) bool {
 	if pendingCount < s.minItems {
 		return false
 	}
 
-	threshold := int(float64(maxBlobSize) * s.sizeThreshold)
+	threshold := uint64(float64(maxBlobSize) * s.sizeThreshold)
 	return totalSize >= threshold
 }
 
@@ -85,7 +85,7 @@ func NewTimeBasedStrategy(daBlockTime time.Duration, maxDelay time.Duration, min
 	}
 }
 
-func (s *TimeBasedStrategy) ShouldSubmit(pendingCount uint64, totalSize int, maxBlobSize int, timeSinceLastSubmit time.Duration) bool {
+func (s *TimeBasedStrategy) ShouldSubmit(pendingCount uint64, totalSize uint64, maxBlobSize uint64, timeSinceLastSubmit time.Duration) bool {
 	if pendingCount < s.minItems {
 		return false
 	}
@@ -120,18 +120,16 @@ func NewAdaptiveStrategy(daBlockTime time.Duration, sizeThreshold float64, maxDe
 	}
 }
 
-func (s *AdaptiveStrategy) ShouldSubmit(pendingCount uint64, totalSize int, maxBlobSize int, timeSinceLastSubmit time.Duration) bool {
+func (s *AdaptiveStrategy) ShouldSubmit(pendingCount uint64, totalSize uint64, maxBlobSize uint64, timeSinceLastSubmit time.Duration) bool {
 	if pendingCount < s.minItems {
 		return false
 	}
 
-	// Submit if we've reached the size threshold
-	threshold := int(float64(maxBlobSize) * s.sizeThreshold)
+	threshold := uint64(float64(maxBlobSize) * s.sizeThreshold)
 	if totalSize >= threshold {
 		return true
 	}
 
-	// Submit if max delay has been reached
 	if timeSinceLastSubmit >= s.maxDelay {
 		return true
 	}

block/internal/submitting/batching_strategy_test.go

@@ -13,11 +13,12 @@ import (
 
 func TestImmediateStrategy(t *testing.T) {
 	strategy := &ImmediateStrategy{}
+	maxBlobSize := common.DefaultMaxBlobSize
 
 	tests := []struct {
 		name         string
 		pendingCount uint64
-		totalSize    int
+		totalSize    uint64
 		expected     bool
 	}{
 		{
@@ -42,7 +43,7 @@ func TestImmediateStrategy(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := strategy.ShouldSubmit(tt.pendingCount, tt.totalSize, common.DefaultMaxBlobSize, 0)
+			result := strategy.ShouldSubmit(tt.pendingCount, tt.totalSize, maxBlobSize, 0)
 			assert.Equal(t, tt.expected, result)
 		})
 	}
@@ -56,7 +57,7 @@ func TestSizeBasedStrategy(t *testing.T) {
 		sizeThreshold  float64
 		minItems       uint64
 		pendingCount   uint64
-		totalSize      int
+		totalSize      uint64
 		expectedSubmit bool
 	}{
 		{
@@ -80,15 +81,15 @@ func TestSizeBasedStrategy(t *testing.T) {
 			sizeThreshold:  0.8,
 			minItems:       1,
 			pendingCount:   10,
-			totalSize:      int(float64(maxBlobSize) * 0.8), // 80% of max
+			totalSize:      uint64(float64(maxBlobSize) * 0.8), // 80% of max
 			expectedSubmit: true,
 		},
 		{
 			name:           "above threshold",
 			sizeThreshold:  0.8,
 			minItems:       1,
 			pendingCount:   20,
-			totalSize:      int(float64(maxBlobSize) * 0.875), // 87.5%
+			totalSize:      uint64(float64(maxBlobSize) * 0.875), // 87.5%
 			expectedSubmit: true,
 		},
 		{
@@ -125,39 +126,39 @@ func TestTimeBasedStrategy(t *testing.T) {
 		name                string
 		minItems            uint64
 		pendingCount        uint64
-		totalSize           int
+		totalSize           uint64
 		timeSinceLastSubmit time.Duration
 		expectedSubmit      bool
 	}{
 		{
 			name:                "below min items",
 			minItems:            2,
 			pendingCount:        1,
-			totalSize:           int(float64(maxBlobSize) * 0.2),
+			totalSize:           uint64(float64(maxBlobSize) * 0.2),
 			timeSinceLastSubmit: 10 * time.Second,
 			expectedSubmit:      false,
 		},
 		{
 			name:                "before max delay",
 			minItems:            1,
 			pendingCount:        5,
-			totalSize:           int(float64(maxBlobSize) * 0.5),
+			totalSize:           uint64(float64(maxBlobSize) * 0.5),
 			timeSinceLastSubmit: 3 * time.Second,
 			expectedSubmit:      false,
 		},
 		{
 			name:                "at max delay",
 			minItems:            1,
 			pendingCount:        3,
-			totalSize:           int(float64(maxBlobSize) * 0.4),
+			totalSize:           uint64(float64(maxBlobSize) * 0.4),
 			timeSinceLastSubmit: 6 * time.Second,
 			expectedSubmit:      true,
 		},
 		{
 			name:                "after max delay",
 			minItems:            1,
 			pendingCount:        2,
-			totalSize:           int(float64(maxBlobSize) * 0.2),
+			totalSize:           uint64(float64(maxBlobSize) * 0.2),
 			timeSinceLastSubmit: 10 * time.Second,
 			expectedSubmit:      true,
 		},
@@ -181,7 +182,7 @@ func TestAdaptiveStrategy(t *testing.T) {
 		name                string
 		minItems            uint64
 		pendingCount        uint64
-		totalSize           int
+		totalSize           uint64
 		timeSinceLastSubmit time.Duration
 		expectedSubmit      bool
 		reason              string
@@ -190,7 +191,7 @@ func TestAdaptiveStrategy(t *testing.T) {
 			name:                "below min items",
 			minItems:            3,
 			pendingCount:        2,
-			totalSize:           int(float64(maxBlobSize) * 0.875),
+			totalSize:           uint64(float64(maxBlobSize) * 0.875),
 			timeSinceLastSubmit: 10 * time.Second,
 			expectedSubmit:      false,
 			reason:              "not enough items",
@@ -199,7 +200,7 @@ func TestAdaptiveStrategy(t *testing.T) {
 			name:                "size threshold reached",
 			minItems:            1,
 			pendingCount:        10,
-			totalSize:           int(float64(maxBlobSize) * 0.85), // 85%
+			totalSize:           uint64(float64(maxBlobSize) * 0.85), // 85%
 			timeSinceLastSubmit: 1 * time.Second,
 			expectedSubmit:      true,
 			reason:              "size threshold met",
@@ -208,7 +209,7 @@ func TestAdaptiveStrategy(t *testing.T) {
 			name:                "time threshold reached",
 			minItems:            1,
 			pendingCount:        2,
-			totalSize:           int(float64(maxBlobSize) * 0.2), // Only 20%
+			totalSize:           uint64(float64(maxBlobSize) * 0.2), // Only 20%
 			timeSinceLastSubmit: 7 * time.Second,
 			expectedSubmit:      true,
 			reason:              "time threshold met",
@@ -217,7 +218,7 @@ func TestAdaptiveStrategy(t *testing.T) {
 			name:                "neither threshold reached",
 			minItems:            1,
 			pendingCount:        5,
-			totalSize:           int(float64(maxBlobSize) * 0.5), // 50%
+			totalSize:           uint64(float64(maxBlobSize) * 0.5), // 50%
 			timeSinceLastSubmit: 3 * time.Second,
 			expectedSubmit:      false,
 			reason:              "waiting for threshold",
@@ -226,7 +227,7 @@ func TestAdaptiveStrategy(t *testing.T) {
 			name:                "both thresholds reached",
 			minItems:            1,
 			pendingCount:        20,
-			totalSize:           int(float64(maxBlobSize) * 0.875), // 87.5%
+			totalSize:           uint64(float64(maxBlobSize) * 0.875), // 87.5%
 			timeSinceLastSubmit: 10 * time.Second,
 			expectedSubmit:      true,
 			reason:              "both thresholds met",
@@ -305,10 +306,9 @@ func TestNewBatchingStrategy(t *testing.T) {
 }
 
 func TestBatchingStrategiesComparison(t *testing.T) {
-	// This test demonstrates how different strategies behave with the same input
 	maxBlobSize := common.DefaultMaxBlobSize
 	pendingCount := uint64(10)
-	totalSize := maxBlobSize / 2 // 50% full
+	totalSize := maxBlobSize / 2
 	timeSinceLastSubmit := 3 * time.Second
 
 	immediate := &ImmediateStrategy{}

block/internal/submitting/da_submitter.go

@@ -42,7 +42,7 @@ type retryPolicy struct {
 	MaxAttempts  int
 	MinBackoff   time.Duration
 	MaxBackoff   time.Duration
-	MaxBlobBytes int
+	MaxBlobBytes uint64
 }
 
 func defaultRetryPolicy(maxAttempts int, maxDuration time.Duration) retryPolicy {
@@ -581,7 +581,7 @@ func submitToDA[T any](
 		if err != nil {
 			s.logger.Error().
 				Str("itemType", itemType).
-				Int("maxBlobBytes", pol.MaxBlobBytes).
+				Uint64("maxBlobBytes", pol.MaxBlobBytes).
 				Err(err).
 				Msg("CRITICAL: Unrecoverable error - item exceeds maximum blob size")
 			return fmt.Errorf("unrecoverable error: no %s items fit within max blob size: %w", itemType, err)
@@ -644,7 +644,7 @@ func submitToDA[T any](
 			if len(items) == 1 {
 				s.logger.Error().
 					Str("itemType", itemType).
-					Int("maxBlobBytes", pol.MaxBlobBytes).
+					Uint64("maxBlobBytes", pol.MaxBlobBytes).
 					Msg("CRITICAL: Unrecoverable error - single item exceeds DA blob size limit")
 				return fmt.Errorf("unrecoverable error: %w: single %s item exceeds DA blob size limit", common.ErrOversizedItem, itemType)
 			}
@@ -690,11 +690,11 @@ func submitToDA[T any](
 
 // limitBatchBySize returns a prefix of items whose total marshaled size does not exceed maxBytes.
 // If the first item exceeds maxBytes, it returns ErrOversizedItem which is unrecoverable.
-func limitBatchBySize[T any](items []T, marshaled [][]byte, maxBytes int) ([]T, [][]byte, error) {
-	total := 0
+func limitBatchBySize[T any](items []T, marshaled [][]byte, maxBytes uint64) ([]T, [][]byte, error) {
+	total := uint64(0)
 	count := 0
 	for i := range items {
-		sz := len(marshaled[i])
+		sz := uint64(len(marshaled[i]))
 		if sz > maxBytes {
 			if i == 0 {
 				return nil, nil, fmt.Errorf("%w: item size %d exceeds max %d", common.ErrOversizedItem, sz, maxBytes)