fix: 0 tx blocks after limbo (0xPolygonHermez#1708) (0xPolygonHermez#1711)

* fix: 0 tx blocks after limbo

* Add executor-enabled flag.

It disables using remote executor even when executor-urls option is filled in,
which is helpful when testing limbo mode, when txs are still sent to
the remote executor.

Author: IvanBelyakoff

cmd/utils/flags.go

@@ -596,6 +596,11 @@ var (
 		Usage: "A comma separated list of grpc addresses that host executors",
 		Value: "",
 	}
+	ExecutorEnabled = cli.BoolFlag{
+		Name:  "zkevm.executor-enabled",
+		Usage: "Enables the executor. Used for testing limbo, when executor-urls are set, but we don't want to use them, only in limbo to verify limbo transactions. For this case, set it to false. Defaulted to true",
+		Value: true,
+	}
 	ExecutorStrictMode = cli.BoolFlag{
 		Name:  "zkevm.executor-strict",
 		Usage: "Defaulted to true to ensure you must set some executor URLs, bypass this restriction by setting to false",

eth/ethconfig/config_zkevm.go

@@ -49,6 +49,7 @@ type Zk struct {
 	ExecutorUrls                           []string
 	ExecutorStrictMode                     bool
 	ExecutorRequestTimeout                 time.Duration
+	ExecutorEnabled                        bool
 	DatastreamNewBlockTimeout              time.Duration
 	WitnessMemdbSize                       datasize.ByteSize
 	WitnessUnwindLimit                     uint64
@@ -113,6 +114,10 @@ func (c *Zk) HasExecutors() bool {
 	return len(c.ExecutorUrls) > 0 && c.ExecutorUrls[0] != ""
 }
 
+func (c *Zk) UseExecutors() bool {
+	return c.HasExecutors() && c.ExecutorEnabled
+}
+
 // ShouldImportInitialBatch returns true in case initial batch config file name is non-empty string.
 func (c *Zk) ShouldImportInitialBatch() bool {
 	return c.InitialBatchCfgFile != ""

turbo/cli/default_flags.go

@@ -217,6 +217,7 @@ var DefaultFlags = []cli.Flag{
 	&utils.ExecutorUrls,
 	&utils.ExecutorStrictMode,
 	&utils.ExecutorRequestTimeout,
+	&utils.ExecutorEnabled,
 	&utils.DatastreamNewBlockTimeout,
 	&utils.WitnessMemdbSize,
 	&utils.WitnessUnwindLimit,

turbo/cli/flags_zkevm.go

@@ -192,6 +192,7 @@ func ApplyFlagsForZkConfig(ctx *cli.Context, cfg *ethconfig.Config) {
 		ExecutorUrls:                           strings.Split(strings.ReplaceAll(ctx.String(utils.ExecutorUrls.Name), " ", ""), ","),
 		ExecutorStrictMode:                     ctx.Bool(utils.ExecutorStrictMode.Name),
 		ExecutorRequestTimeout:                 ctx.Duration(utils.ExecutorRequestTimeout.Name),
+		ExecutorEnabled:                        ctx.Bool(utils.ExecutorEnabled.Name),
 		DatastreamNewBlockTimeout:              ctx.Duration(utils.DatastreamNewBlockTimeout.Name),
 		WitnessMemdbSize:                       *witnessMemSize,
 		WitnessUnwindLimit:                     witnessUnwindLimit,
@@ -244,6 +245,7 @@ func ApplyFlagsForZkConfig(ctx *cli.Context, cfg *ethconfig.Config) {
 	} else {
 		checkFlag(utils.ExecutorUrls.Name, cfg.ExecutorUrls)
 		checkFlag(utils.ExecutorStrictMode.Name, cfg.ExecutorStrictMode)
+		checkFlag(utils.ExecutorEnabled.Name, cfg.ExecutorEnabled)
 		checkFlag(utils.DataStreamHost.Name, cfg.DataStreamHost)
 		checkFlag(utils.DataStreamPort.Name, cfg.DataStreamPort)
 		checkFlag(utils.DataStreamWriteTimeout.Name, cfg.DataStreamWriteTimeout)
@@ -261,7 +263,7 @@ func ApplyFlagsForZkConfig(ctx *cli.Context, cfg *ethconfig.Config) {
 			panic("You cannot disable virtual counters when running in strict mode")
 		}
 
-		if len(cfg.ExecutorUrls) > 0 && cfg.ExecutorUrls[0] != "" && cfg.DisableVirtualCounters {
+		if cfg.UseExecutors() && cfg.DisableVirtualCounters {
 			panic("You cannot disable virtual counters when running with executors")
 		}
 	}

turbo/stages/zk_stages.go

@@ -54,7 +54,7 @@ func NewDefaultZkStages(ctx context.Context,
 		zkStages.StageL1SyncerCfg(db, l1Syncer, cfg.Zk),
 		zkStages.StageL1InfoTreeCfg(db, cfg.Zk, infoTreeUpdater),
 		zkStages.StageBatchesCfg(db, datastreamClient, cfg.Zk, controlServer.ChainConfig, &cfg.Miner),
-		zkStages.StageDataStreamCatchupCfg(dataStreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion, cfg.HasExecutors()),
+		zkStages.StageDataStreamCatchupCfg(dataStreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion),
 		stagedsync.StageBlockHashesCfg(db, dirs.Tmp, controlServer.ChainConfig, blockWriter),
 		stagedsync.StageSendersCfg(db, controlServer.ChainConfig, false, dirs.Tmp, cfg.Prune, blockReader, controlServer.Hd, nil),
 		stagedsync.StageExecuteBlocksCfg(
@@ -121,7 +121,7 @@ func NewSequencerZkStages(ctx context.Context,
 		zkStages.StageL1SequencerSyncCfg(db, cfg.Zk, sequencerStageSyncer),
 		zkStages.StageL1InfoTreeCfg(db, cfg.Zk, infoTreeUpdater),
 		zkStages.StageSequencerL1BlockSyncCfg(db, cfg.Zk, l1BlockSyncer),
-		zkStages.StageDataStreamCatchupCfg(dataStreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion, cfg.HasExecutors()),
+		zkStages.StageDataStreamCatchupCfg(dataStreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion),
 		zkStages.StageSequenceBlocksCfg(
 			db,
 			cfg.Prune,

zk/stages/stage_data_stream_catch_up.go

@@ -18,15 +18,13 @@ type DataStreamCatchupCfg struct {
 	db               kv.RwDB
 	dataStreamServer server.DataStreamServer
 	streamVersion    int
-	hasExecutors     bool
 }
 
-func StageDataStreamCatchupCfg(dataStreamServer server.DataStreamServer, db kv.RwDB, chainId uint64, streamVersion int, hasExecutors bool) DataStreamCatchupCfg {
+func StageDataStreamCatchupCfg(dataStreamServer server.DataStreamServer, db kv.RwDB, chainId uint64, streamVersion int) DataStreamCatchupCfg {
 	return DataStreamCatchupCfg{
 		dataStreamServer: dataStreamServer,
 		db:               db,
 		streamVersion:    streamVersion,
-		hasExecutors:     hasExecutors,
 	}
 }
 

zk/stages/stage_data_stream_catch_up_test.go

@@ -89,7 +89,7 @@ func TestSpawnStageDataStreamCatchup(t *testing.T) {
 
 	dataStreamServerMock.EXPECT().WriteBlocksToStreamConsecutively(ctx, s.LogPrefix(), tx1, hDBReaderMatcher, uint64(1), uint64(20)).Return(nil)
 
-	cfg := StageDataStreamCatchupCfg(dataStreamServerMock, db1, chainID, streamVersion, true)
+	cfg := StageDataStreamCatchupCfg(dataStreamServerMock, db1, chainID, streamVersion)
 
 	// Act
 	err = SpawnStageDataStreamCatchup(s, ctx, tx1, cfg)

zk/stages/stage_sequence_execute.go

@@ -117,7 +117,7 @@ func sequencingBatchStep(
 	var block *types.Block
 	runLoopBlocks := true
 	batchContext := newBatchContext(ctx, &cfg, &historyCfg, s, sdb)
-	batchState := newBatchState(forkId, batchNumberForStateInitialization, executionAt+1, cfg.zk.HasExecutors(), cfg.zk.L1SyncStartBlock > 0, cfg.txPool, resequenceBatchJob)
+	batchState := newBatchState(forkId, batchNumberForStateInitialization, executionAt+1, cfg.zk.UseExecutors(), cfg.zk.L1SyncStartBlock > 0, cfg.txPool, resequenceBatchJob)
 	blockDataSizeChecker := NewBlockDataChecker(cfg.zk.ShouldCountersBeUnlimited(batchState.isL1Recovery()))
 	streamWriter := newSequencerBatchStreamWriter(batchContext, batchState)
 

zk/txpool/pool.go

@@ -395,8 +395,6 @@ func New(newTxs chan types.Announcements, coreDB kv.RoDB, cfg txpoolcfg.Config,
 func (p *TxPool) OnNewBlock(ctx context.Context, stateChanges *remote.StateChangeBatch, unwindTxs, minedTxs types.TxSlots, tx kv.Tx) error {
 	defer newBlockTimer.UpdateDuration(time.Now())
 
-	isAfterLimbo := len(unwindTxs.Txs) > 0 && p.isDeniedYieldingTransactions()
-
 	cache := p.cache()
 	cache.OnNewBlock(stateChanges)
 	coreTx, err := p.coreDB().BeginRo(ctx)
@@ -524,7 +522,7 @@ func (p *TxPool) OnNewBlock(ctx context.Context, stateChanges *remote.StateChang
 		log.Info("[txpool] Discarding", "tx-hash", hexutils.BytesToHex(slot.IDHash[:]))
 	}
 	p.finalizeLimboOnNewBlock(limboTxs)
-	if isAfterLimbo {
+	if p.isDeniedYieldingTransactions() {
 		p.allowYieldingTransactions()
 	}