fix(evm): don't create single sequencer for non-aggregator nodes (#3389)

* fix(evm): don't create single sequencer for non-aggregator nodes

P2P-only followers (no DA address) crashed on startup with a nil
pointer dereference: the EVM app's createSequencer unconditionally
built a single sequencer, whose forced-inclusion retriever calls
GetForcedInclusionNamespace on the nil DA client.

Mirror the testapp guard from #3386 by skipping sequencer creation
for non-aggregators, and fail fast in single.NewSequencer when the
DA client is nil so future regressions surface as a clean error
instead of a SIGSEGV.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: keep sequencer for promotable followers and require DA for promotable mode

Promotable nodes start as followers but can be promoted to proposer at
runtime, which hands the sequencer to the aggregator components. The
non-aggregator guard (added to testapp in #3386 and mirrored here for
the EVM app) would leave promotable nodes with a nil sequencer and
break promotion. Create the sequencer for promotable nodes too, and
require a DA address for promotable mode at config validation, same as
aggregator mode.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: tac0turtle

apps/evm/cmd/run.go

@@ -160,6 +160,12 @@ func createSequencer(
 	daClient block.FullDAClient,
 	executor execution.Executor,
 ) (coresequencer.Sequencer, error) {
+	// Only aggregators and promotable nodes need a sequencer; promotable
+	// followers must have one ready before they are promoted to proposer.
+	if !nodeConfig.Node.Aggregator && !nodeConfig.Node.Promotable {
+		return nil, nil
+	}
+
 	if nodeConfig.Node.BasedSequencer {
 		// Based sequencer mode - fetch transactions only from DA
 		if !nodeConfig.Node.Aggregator {

apps/testapp/cmd/run.go

@@ -113,7 +113,9 @@ func createSequencer(
 	genesis genesis.Genesis,
 	executor execution.Executor,
 ) (coresequencer.Sequencer, error) {
-	if !nodeConfig.Node.Aggregator {
+	// Only aggregators and promotable nodes need a sequencer; promotable
+	// followers must have one ready before they are promoted to proposer.
+	if !nodeConfig.Node.Aggregator && !nodeConfig.Node.Promotable {
 		return nil, nil
 	}
 

pkg/cmd/run_node.go

@@ -48,8 +48,8 @@ func ParseStartConfig(cmd *cobra.Command) (rollconf.Config, error) {
 	if err != nil {
 		return rollconf.Config{}, err
 	}
-	if nodeConfig.Node.Aggregator && nodeConfig.GetDAAddress() == "" {
-		return rollconf.Config{}, fmt.Errorf("DA address is required when aggregator mode is enabled")
+	if (nodeConfig.Node.Aggregator || nodeConfig.Node.Promotable) && nodeConfig.GetDAAddress() == "" {
+		return rollconf.Config{}, fmt.Errorf("DA address is required when aggregator or promotable mode is enabled")
 	}
 
 	return nodeConfig, nil

pkg/cmd/run_node_test.go

@@ -175,20 +175,22 @@ func TestAggregatorFlagInvariants(t *testing.T) {
 }
 
 func TestParseStartConfig_AggregatorRequiresDAAddress(t *testing.T) {
-	executor, sequencer, keyProvider, nodeKey, ds, stopDAHeightTicker := createTestComponents(context.Background(), t)
-	defer stopDAHeightTicker()
+	for _, flag := range []string{"--rollkit.node.aggregator", "--rollkit.node.promotable"} {
+		executor, sequencer, keyProvider, nodeKey, ds, stopDAHeightTicker := createTestComponents(context.Background(), t)
+		defer stopDAHeightTicker()
 
-	nodeConfig := rollconf.DefaultConfig()
-	nodeConfig.RootDir = t.TempDir()
+		nodeConfig := rollconf.DefaultConfig()
+		nodeConfig.RootDir = t.TempDir()
 
-	cmd := newRunNodeCmd(t.Context(), executor, sequencer, keyProvider, nodeKey, ds, nodeConfig)
-	require.NoError(t, cmd.ParseFlags([]string{"start", "--rollkit.node.aggregator"}))
+		cmd := newRunNodeCmd(t.Context(), executor, sequencer, keyProvider, nodeKey, ds, nodeConfig)
+		require.NoError(t, cmd.ParseFlags([]string{"start", flag}))
 
-	_, err := ParseConfig(cmd)
-	require.NoError(t, err)
+		_, err := ParseConfig(cmd)
+		require.NoError(t, err)
 
-	_, err = ParseStartConfig(cmd)
-	require.EqualError(t, err, "DA address is required when aggregator mode is enabled")
+		_, err = ParseStartConfig(cmd)
+		require.EqualError(t, err, "DA address is required when aggregator or promotable mode is enabled")
+	}
 }
 
 func TestPromotableFlagInvariants(t *testing.T) {

pkg/sequencers/single/sequencer.go

@@ -78,6 +78,10 @@ func NewSequencer(
 	genesis genesis.Genesis,
 	executor execution.Executor,
 ) (*Sequencer, error) {
+	if daClient == nil {
+		return nil, errors.New("single sequencer requires a DA client")
+	}
+
 	s := &Sequencer{
 		db:               db,
 		logger:           logger,

pkg/sequencers/single/sequencer_test.go

@@ -114,6 +114,13 @@ func newTestSequencer(t *testing.T, db ds.Batching, daClient block.FullDAClient)
 	return seq
 }
 
+func TestNewSequencer_NilDAClient(t *testing.T) {
+	mockExec := createDefaultMockExecutor(t)
+	seq, err := NewSequencer(zerolog.Nop(), ds.NewMapDatastore(), nil, config.DefaultConfig(), []byte("test"), 1000, genesis.Genesis{}, mockExec)
+	require.Error(t, err)
+	require.Nil(t, seq)
+}
+
 func TestSequencer_SubmitBatchTxs(t *testing.T) {
 	dummyDA := newDummyDA(100_000_000)
 	db := ds.NewMapDatastore()