Review feedback

alpe · alpe · commit 20bb79d3d42b · 2026-03-13T08:58:11.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Persist cache snapshot only once at shutdown to avoid Badger vlog increase. [#3153](https://github.com/evstack/ev-node/pull/3153)
 
+### Changes
+
+- Subscribe to forced inclusion namespace events [#3146](https://github.com/evstack/ev-node/pull/3146)
+
 ## v1.0.0-rc.5
 
 ### Added
diff --git a/apps/evm/cmd/run.go b/apps/evm/cmd/run.go
@@ -23,7 +23,6 @@ import (
 	"github.com/evstack/ev-node/pkg/config"
 	blobrpc "github.com/evstack/ev-node/pkg/da/jsonrpc"
 	da "github.com/evstack/ev-node/pkg/da/types"
-	"github.com/evstack/ev-node/pkg/genesis"
 	genesispkg "github.com/evstack/ev-node/pkg/genesis"
 	"github.com/evstack/ev-node/pkg/p2p/key"
 	"github.com/evstack/ev-node/pkg/sequencers/based"
@@ -84,7 +83,7 @@ var RunCmd = &cobra.Command{
 		}
 
 		// Create sequencer based on configuration
-		sequencer, err := createSequencer(logger, datastore, nodeConfig, genesis, daClient, executor)
+		sequencer, err := createSequencer(cmd.Context(), logger, datastore, nodeConfig, genesis, daClient, executor)
 		if err != nil {
 			return err
 		}
@@ -145,10 +144,11 @@ func init() {
 // If BasedSequencer is enabled, it creates a based sequencer that fetches transactions from DA.
 // Otherwise, it creates a single (traditional) sequencer.
 func createSequencer(
+	ctx context.Context,
 	logger zerolog.Logger,
 	datastore datastore.Batching,
 	nodeConfig config.Config,
-	genesis genesis.Genesis,
+	genesis genesispkg.Genesis,
 	daClient block.FullDAClient,
 	executor execution.Executor,
 ) (coresequencer.Sequencer, error) {
@@ -158,7 +158,7 @@ func createSequencer(
 			return nil, fmt.Errorf("based sequencer mode requires aggregator mode to be enabled")
 		}
 
-		basedSeq, err := based.NewBasedSequencer(daClient, nodeConfig, datastore, genesis, logger, executor)
+		basedSeq, err := based.NewBasedSequencer(ctx, daClient, nodeConfig, datastore, genesis, logger, executor)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create based sequencer: %w", err)
 		}
diff --git a/apps/grpc/cmd/run.go b/apps/grpc/cmd/run.go
@@ -121,7 +121,7 @@ func createSequencer(
 			return nil, fmt.Errorf("based sequencer mode requires aggregator mode to be enabled")
 		}
 
-		basedSeq, err := based.NewBasedSequencer(daClient, nodeConfig, datastore, genesis, logger, executor)
+		basedSeq, err := based.NewBasedSequencer(ctx, daClient, nodeConfig, datastore, genesis, logger, executor)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create based sequencer: %w", err)
 		}
diff --git a/apps/testapp/cmd/run.go b/apps/testapp/cmd/run.go
@@ -124,7 +124,7 @@ func createSequencer(
 			return nil, fmt.Errorf("based sequencer mode requires aggregator mode to be enabled")
 		}
 
-		basedSeq, err := based.NewBasedSequencer(daClient, nodeConfig, datastore, genesis, logger, executor)
+		basedSeq, err := based.NewBasedSequencer(ctx, daClient, nodeConfig, datastore, genesis, logger, executor)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create based sequencer: %w", err)
 		}
diff --git a/block/internal/da/async_block_retriever.go b/block/internal/da/async_block_retriever.go
@@ -174,6 +174,9 @@ func (f *asyncBlockRetriever) GetCachedBlock(ctx context.Context, daHeight uint6
 // HandleEvent caches blobs from the subscription inline, even empty ones,
 // to record that the DA height was seen and has 0 blobs.
 func (f *asyncBlockRetriever) HandleEvent(ctx context.Context, ev datypes.SubscriptionEvent, isInline bool) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
 	f.cacheBlock(ctx, ev.Height, ev.Timestamp, ev.Blobs)
 	if isInline {
 		return errors.New("async block retriever relies on catchup state machine")
@@ -184,6 +187,10 @@ func (f *asyncBlockRetriever) HandleEvent(ctx context.Context, ev datypes.Subscr
 // HandleCatchup fetches a single height via Retrieve and caches it.
 // Also applies the prefetch window for speculative forward fetching.
 func (f *asyncBlockRetriever) HandleCatchup(ctx context.Context, daHeight uint64) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+
 	if _, err := f.cache.Get(ctx, newBlockDataKey(daHeight)); err != nil {
 		if err := f.fetchAndCacheBlock(ctx, daHeight); err != nil {
 			return err
@@ -208,8 +215,10 @@ func (f *asyncBlockRetriever) HandleCatchup(ctx context.Context, daHeight uint64
 
 // fetchAndCacheBlock fetches a block via Retrieve and caches it.
 func (f *asyncBlockRetriever) fetchAndCacheBlock(ctx context.Context, height uint64) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
 	f.logger.Debug().Uint64("height", height).Msg("prefetching block")
-
 	result := f.client.Retrieve(ctx, height, f.namespace)
 
 	switch result.Code {
diff --git a/block/internal/da/forced_inclusion_retriever.go b/block/internal/da/forced_inclusion_retriever.go
@@ -42,7 +42,6 @@ type ForcedInclusionEvent struct {
 // NewForcedInclusionRetriever creates a new forced inclusion retriever.
 // It internally creates and manages an AsyncBlockRetriever for background prefetching.
 func NewForcedInclusionRetriever(
-	ctx context.Context,
 	client Client,
 	logger zerolog.Logger,
 	daBlockTime time.Duration,
diff --git a/block/internal/da/forced_inclusion_retriever_test.go b/block/internal/da/forced_inclusion_retriever_test.go
@@ -24,7 +24,7 @@ func TestNewForcedInclusionRetriever(t *testing.T) {
 		DAEpochForcedInclusion: 10,
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	assert.Assert(t, retriever != nil)
 	retriever.Stop()
 }
@@ -39,7 +39,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_NoNamespace(t *testi
 		DAEpochForcedInclusion: 10,
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -60,7 +60,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_NotAtEpochStart(t *t
 		DAEpochForcedInclusion: 10,
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -95,7 +95,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_EpochStartSuccess(t
 		DAEpochForcedInclusion: 1, // Single height epoch
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -126,7 +126,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_EpochStartNotAvailab
 		DAEpochForcedInclusion: 10,
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -151,7 +151,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_NoBlobsAtHeight(t *t
 		DAEpochForcedInclusion: 1, // Single height epoch
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -191,7 +191,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_MultiHeightEpoch(t *
 		DAEpochForcedInclusion: 3, // Epoch: 100-102
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -226,7 +226,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_ErrorHandling(t *tes
 		DAEpochForcedInclusion: 1, // Single height epoch
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -253,7 +253,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_EmptyBlobsSkipped(t
 		DAEpochForcedInclusion: 1, // Single height epoch
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
@@ -299,7 +299,7 @@ func TestForcedInclusionRetriever_RetrieveForcedIncludedTxs_OrderPreserved(t *te
 		DAEpochForcedInclusion: 3, // Epoch: 100-102
 	}
 
-	retriever := NewForcedInclusionRetriever(context.Background(), client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	retriever := NewForcedInclusionRetriever(client, zerolog.Nop(), 100*time.Millisecond, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	defer retriever.Stop()
 	ctx := context.Background()
 
diff --git a/block/internal/da/subscriber.go b/block/internal/da/subscriber.go
@@ -24,7 +24,6 @@ type SubscriberHandler interface {
 
 	// HandleCatchup is called for each height during sequential catchup.
 	// The subscriber advances localDAHeight only after this returns (true, nil).
-	// Returning (false, nil) rolls back localDAHeight without triggering a backoff.
 	// Returning an error rolls back localDAHeight and triggers a backoff retry.
 	HandleCatchup(ctx context.Context, height uint64) error
 }
@@ -93,7 +92,9 @@ func NewSubscriber(cfg SubscriberConfig) *Subscriber {
 	}
 	s.localDAHeight.Store(cfg.StartHeight)
 	s.highestSeenDAHeight.Store(cfg.StartHeight)
-	s.catchupSignal <- struct{}{}
+	if cfg.StartHeight != 0 {
+		s.catchupSignal <- struct{}{}
+	}
 
 	if len(s.namespaces) == 0 {
 		s.logger.Warn().Msg("no namespaces configured, subscriber will stay idle")
@@ -138,10 +139,6 @@ func (s *Subscriber) HasReachedHead() bool {
 	return s.headReached.Load()
 }
 
-// ---------------------------------------------------------------------------
-// Follow loop
-// ---------------------------------------------------------------------------
-
 // signalCatchup sends a non-blocking signal to wake catchupLoop.
 func (s *Subscriber) signalCatchup() {
 	select {
diff --git a/block/internal/syncing/da_follower.go b/block/internal/syncing/da_follower.go
@@ -89,10 +89,6 @@ func (f *daFollower) HasReachedHead() bool {
 	return f.subscriber.HasReachedHead()
 }
 
-// ---------------------------------------------------------------------------
-// SubscriberHandler implementation
-// ---------------------------------------------------------------------------
-
 // HandleEvent processes a subscription event. When the follower is
 // caught up (ev.Height == localDAHeight) and blobs are available, it processes
 // them inline — avoiding a DA re-fetch round trip. Otherwise, it just lets
@@ -178,10 +174,6 @@ func (f *daFollower) fetchAndPipeHeight(ctx context.Context, daHeight uint64) er
 	return nil
 }
 
-// ---------------------------------------------------------------------------
-// Priority queue (absorbed from DARetriever — refactoring #2)
-// ---------------------------------------------------------------------------
-
 // QueuePriorityHeight queues a DA height for priority retrieval.
 func (f *daFollower) QueuePriorityHeight(daHeight uint64) {
 	f.priorityMu.Lock()
diff --git a/block/internal/syncing/da_retriever.go b/block/internal/syncing/da_retriever.go
@@ -292,27 +292,22 @@ func (r *daRetriever) tryDecodeHeader(bz []byte, daHeight uint64) *types.SignedH
 		r.logger.Warn().Msg("strict mode: rejecting block that is not a fully valid envelope")
 		return nil
 	}
-	// Mode Switch Logic
-	if isValidEnvelope && !r.strictMode {
-		r.logger.Info().Uint64("height", header.Height()).Msg("valid DA envelope detected, switching to STRICT MODE")
-		r.strictMode = true
-	}
-
-	// Legacy blob support implies: strictMode == false AND (!isValidEnvelope).
-	// We fall through here.
 
-	// Basic validation
 	if err := header.Header.ValidateBasic(); err != nil {
 		r.logger.Debug().Err(err).Msg("invalid header structure")
 		return nil
 	}
 
-	// Check proposer
 	if err := r.assertExpectedProposer(header.ProposerAddress); err != nil {
 		r.logger.Debug().Err(err).Msg("unexpected proposer")
 		return nil
 	}
 
+	if isValidEnvelope && !r.strictMode {
+		r.logger.Info().Uint64("height", header.Height()).Msg("valid DA envelope detected, switching to STRICT MODE")
+		r.strictMode = true
+	}
+
 	// Optimistically mark as DA included
 	// This has to be done for all fetched DA headers prior to validation because P2P does not confirm
 	// da inclusion. This is not an issue, as an invalid header will be rejected. There cannot be hash collisions.
diff --git a/block/internal/syncing/syncer.go b/block/internal/syncing/syncer.go
@@ -181,7 +181,7 @@ func (s *Syncer) Start(ctx context.Context) (err error) {
 		s.daRetriever = WithTracingDARetriever(s.daRetriever)
 	}
 
-	s.fiRetriever = da.NewForcedInclusionRetriever(ctx, s.daClient, s.logger, s.config.DA.BlockTime.Duration, s.config.Instrumentation.IsTracingEnabled(), s.genesis.DAStartHeight, s.genesis.DAEpochForcedInclusion)
+	s.fiRetriever = da.NewForcedInclusionRetriever(s.daClient, s.logger, s.config.DA.BlockTime.Duration, s.config.Instrumentation.IsTracingEnabled(), s.genesis.DAStartHeight, s.genesis.DAEpochForcedInclusion)
 	s.fiRetriever.Start(ctx)
 	s.p2pHandler = NewP2PHandler(s.headerStore, s.dataStore, s.cache, s.genesis, s.logger)
 
diff --git a/block/internal/syncing/syncer_forced_inclusion_test.go b/block/internal/syncing/syncer_forced_inclusion_test.go
@@ -78,7 +78,7 @@ func newForcedInclusionSyncer(t *testing.T, daStart, epochSize uint64) (*Syncer,
 	client.On("Subscribe", mock.Anything, mock.Anything, mock.Anything).Return((<-chan datypes.SubscriptionEvent)(subCh), nil).Maybe()
 
 	daRetriever := NewDARetriever(client, cm, gen, zerolog.Nop())
-	fiRetriever := da.NewForcedInclusionRetriever(t.Context(), client, zerolog.Nop(), cfg.DA.BlockTime.Duration, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	fiRetriever := da.NewForcedInclusionRetriever(client, zerolog.Nop(), cfg.DA.BlockTime.Duration, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	t.Cleanup(fiRetriever.Stop)
 
 	s := NewSyncer(
@@ -150,7 +150,7 @@ func TestVerifyForcedInclusionTxs_NamespaceNotConfigured(t *testing.T) {
 	subCh := make(chan datypes.SubscriptionEvent)
 	client.On("Subscribe", mock.Anything, mock.Anything, mock.Anything).Return((<-chan datypes.SubscriptionEvent)(subCh), nil).Maybe()
 
-	fiRetriever := da.NewForcedInclusionRetriever(t.Context(), client, zerolog.Nop(), cfg.DA.BlockTime.Duration, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
+	fiRetriever := da.NewForcedInclusionRetriever(client, zerolog.Nop(), cfg.DA.BlockTime.Duration, false, gen.DAStartHeight, gen.DAEpochForcedInclusion)
 	t.Cleanup(fiRetriever.Stop)
 
 	s := NewSyncer(
diff --git a/block/public.go b/block/public.go
@@ -85,13 +85,19 @@ type ForcedInclusionRetriever interface {
 // It internally creates and manages an AsyncBlockRetriever for background prefetching.
 // Tracing is automatically enabled when configured.
 func NewForcedInclusionRetriever(
-	ctx context.Context,
 	client DAClient,
 	cfg config.Config,
 	logger zerolog.Logger,
 	daStartHeight, daEpochSize uint64,
 ) ForcedInclusionRetriever {
-	return da.NewForcedInclusionRetriever(ctx, client, logger, cfg.DA.BlockTime.Duration, cfg.Instrumentation.IsTracingEnabled(), daStartHeight, daEpochSize)
+	return da.NewForcedInclusionRetriever(
+		client,
+		logger,
+		cfg.DA.BlockTime.Duration,
+		cfg.Instrumentation.IsTracingEnabled(),
+		daStartHeight,
+		daEpochSize,
+	)
 }
 
 // Expose Raft types for consensus integration
diff --git a/pkg/sequencers/based/sequencer.go b/pkg/sequencers/based/sequencer.go
@@ -44,6 +44,7 @@ type BasedSequencer struct {
 
 // NewBasedSequencer creates a new based sequencer instance
 func NewBasedSequencer(
+	ctx context.Context,
 	daClient block.FullDAClient,
 	cfg config.Config,
 	db ds.Batching,
@@ -59,7 +60,7 @@ func NewBasedSequencer(
 	}
 
 	// Read state from the store to allow nodes to restart as based sequencers on a chain that had ran previously with a different sequencer type, and to initialize the timestamp floor for monotonicity guarantees after restart.
-	initCtx, initCancel := context.WithTimeout(context.Background(), 10*time.Second)
+	initCtx, initCancel := context.WithTimeout(ctx, 10*time.Second)
 	defer initCancel()
 	s := store.New(store.NewEvNodeKVStore(db))
 	daStartHeight := genesis.DAStartHeight
@@ -71,7 +72,7 @@ func NewBasedSequencer(
 	bs.SetDAHeight(daStartHeight)
 
 	// Load checkpoint from DB, or initialize if none exists
-	loadCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	loadCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
 
 	checkpoint, err := bs.checkpointStore.Load(loadCtx)
@@ -97,7 +98,8 @@ func NewBasedSequencer(
 		}
 	}
 
-	bs.fiRetriever = block.NewForcedInclusionRetriever(context.Background(), daClient, cfg, logger, genesis.DAStartHeight, genesis.DAEpochForcedInclusion)
+	bs.fiRetriever = block.NewForcedInclusionRetriever(daClient, cfg, logger, genesis.DAStartHeight, genesis.DAEpochForcedInclusion)
+	bs.fiRetriever.Start(ctx)
 
 	return bs, nil
 }
@@ -112,6 +114,9 @@ func (s *BasedSequencer) SubmitBatchTxs(ctx context.Context, req coresequencer.S
 // GetNextBatch retrieves the next batch of transactions from the DA layer using the checkpoint
 // It treats DA as a queue and only persists where it is in processing
 func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextBatchRequest) (*coresequencer.GetNextBatchResponse, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
 	daHeight := s.GetDAHeight()
 
 	// If we have no cached transactions or we've consumed all from the current DA epoch,
diff --git a/pkg/sequencers/based/sequencer_test.go b/pkg/sequencers/based/sequencer_test.go
diff --git a/pkg/sequencers/single/sequencer.go b/pkg/sequencers/single/sequencer.go
diff --git a/pkg/sequencers/single/sequencer_test.go b/pkg/sequencers/single/sequencer_test.go

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ func createSequencer(`
`121`	`121`	`return nil, fmt.Errorf("based sequencer mode requires aggregator mode to be enabled")`
`122`	`122`	`}`
`123`	`123`
`124`		`- basedSeq, err := based.NewBasedSequencer(daClient, nodeConfig, datastore, genesis, logger, executor)`
	`124`	`+ basedSeq, err := based.NewBasedSequencer(ctx, daClient, nodeConfig, datastore, genesis, logger, executor)`
`125`	`125`	`if err != nil {`
`126`	`126`	`return nil, fmt.Errorf("failed to create based sequencer: %w", err)`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ func createSequencer(`
`124`	`124`	`return nil, fmt.Errorf("based sequencer mode requires aggregator mode to be enabled")`
`125`	`125`	`}`
`126`	`126`
`127`		`- basedSeq, err := based.NewBasedSequencer(daClient, nodeConfig, datastore, genesis, logger, executor)`
	`127`	`+ basedSeq, err := based.NewBasedSequencer(ctx, daClient, nodeConfig, datastore, genesis, logger, executor)`
`128`	`128`	`if err != nil {`
`129`	`129`	`return nil, fmt.Errorf("failed to create based sequencer: %w", err)`
`130`	`130`	`}`