fix: fixing bootstrap method in sequencer

Signed-off-by: Nikolay Nedkov <nikolai_nedkov@yahoo.com>

sequencer/finalizer.go

@@ -93,12 +93,14 @@ func newFinalizer(cfg FinalizerCfg, worker workerInterface, dbManager dbManagerI
 }
 
 // Start starts the finalizer.
-func (f *finalizer) Start(ctx context.Context, batch WipBatch, OldStateRoot, OldAccInputHash common.Hash) {
+func (f *finalizer) Start(ctx context.Context, batch *WipBatch, OldStateRoot, OldAccInputHash common.Hash) {
 	var (
 		err error
 	)
 
-	f.batch = batch
+	if batch != nil {
+		f.batch = *batch
+	}
 	f.processRequest = state.ProcessSingleTxRequest{
 		BatchNumber:      f.batch.batchNumber,
 		StateRoot:        f.batch.stateRoot,

sequencer/sequencer.go

@@ -53,8 +53,8 @@ func (s *Sequencer) Start(ctx context.Context) {
 	dbManager := newDBManager(s.pool, s.state, worker)
 	go dbManager.Start()
 
-	currBatch, OldAccInputHash, OldStateRoot := s.bootstrap(ctx, dbManager)
 	finalizer := newFinalizer(s.cfg.Finalizer, worker, dbManager, s.state, s.address, s.isSynced, s.cfg.MaxTxsPerBatch)
+	currBatch, OldAccInputHash, OldStateRoot := s.bootstrap(ctx, dbManager, finalizer)
 	go finalizer.Start(ctx, currBatch, OldStateRoot, OldAccInputHash)
 
 	closingSignalsManager := newClosingSignalsManager(finalizer)
@@ -75,9 +75,9 @@ func (s *Sequencer) Start(ctx context.Context) {
 	<-ctx.Done()
 }
 
-func (s *Sequencer) bootstrap(ctx context.Context, dbManager *dbManager) (WipBatch, common.Hash, common.Hash) {
+func (s *Sequencer) bootstrap(ctx context.Context, dbManager *dbManager, finalizer *finalizer) (*WipBatch, common.Hash, common.Hash) {
 	var (
-		currBatch                     WipBatch
+		currBatch                     *WipBatch
 		oldAccInputHash, oldStateRoot common.Hash
 	)
 	batchNum, err := dbManager.GetLastBatchNumber(ctx)
@@ -95,55 +95,20 @@ func (s *Sequencer) bootstrap(ctx context.Context, dbManager *dbManager) (WipBat
 		// GENESIS Batch //
 		///////////////////
 		processingCtx := dbManager.CreateFirstBatch(ctx, s.address)
-		currBatch = WipBatch{
+		currBatch = &WipBatch{
 			globalExitRoot: processingCtx.GlobalExitRoot,
 			batchNumber:    processingCtx.BatchNumber,
 			coinbase:       processingCtx.Coinbase,
 			timestamp:      uint64(processingCtx.Timestamp.Unix()),
 			txs:            make([]TxTracker, 0, s.cfg.MaxTxsPerBatch),
 		}
 	} else {
-		// Check if synchronizer is up to date
+		// Check if synchronizer is up-to-date
 		for !s.isSynced(ctx) {
 			log.Info("wait for synchronizer to sync last batch")
 			time.Sleep(time.Second)
 		}
-		// Revert reorged txs to pending
-		if err = dbManager.MarkReorgedTxsAsPending(ctx); err != nil {
-			log.Fatal(fmt.Errorf("failed to mark reorged txs as pending, err: %w", err))
-		}
-		// Get current wip batch
-		currBatch, err = dbManager.GetWIPBatch(ctx)
-		if err != nil {
-			log.Fatal(fmt.Errorf("failed to load batch from the state, err: %w", err))
-		}
-		// Get data for prevBatch
-		lastBatch, err := dbManager.GetLastBatch(ctx)
-		if err != nil {
-			log.Fatal(fmt.Errorf("failed to get last batch. err: %w", err))
-		}
-		isClosed, err := dbManager.IsBatchClosed(ctx, lastBatch.BatchNumber)
-		if err != nil {
-			log.Fatal(fmt.Errorf("failed to check is batch closed or not, err: %w", err))
-		}
-		if isClosed {
-			//ger, _, err := s.getLatestGer(ctx, dbTx)
-			// TODO: Open New batch and create WipBatch (currBatch)
-		} else {
-			if lastBatch.BatchNumber == 1 {
-				oldAccInputHash = lastBatch.AccInputHash
-				oldStateRoot = lastBatch.StateRoot
-			} else {
-				n := uint(2)
-				batches, err := dbManager.GetLastNBatches(ctx, n)
-				if err != nil {
-					log.Fatal(fmt.Errorf("failed to get last %d batches, err: %w", n, err))
-				}
-				oldAccInputHash = batches[1].AccInputHash
-				oldStateRoot = batches[1].StateRoot
-			}
-
-		}
+		finalizer.reopenBatch(ctx)
 	}
 	return currBatch, oldAccInputHash, oldStateRoot
 }