connection with interface library

state/model/reorg_state.go

@@ -15,6 +15,8 @@ type ReorgRequest struct {
 	ReasonError              error
 }
 
+type PreExecuteReorgFunc = func(ctx context.Context, reorgRequest *ReorgRequest, dbTx storageTxType) error
+
 func (r *ReorgRequest) String() string {
 	return fmt.Sprintf("FirstL1BlockNumberToKeep: %d, ReasonError: %s", r.FirstL1BlockNumberToKeep, r.ReasonError)
 }
@@ -49,6 +51,7 @@ type ReorgState struct {
 	storage          StorageReorgInterface
 	onReorgCallbacks []ReorgCallbackType
 	lastReorgResult  *ReorgExecutionResult
+	preExecuteReorg  []PreExecuteReorgFunc
 }
 
 func NewReorgState(storage StorageReorgInterface) *ReorgState {
@@ -57,15 +60,35 @@ func NewReorgState(storage StorageReorgInterface) *ReorgState {
 	}
 }
 
+func (s *ReorgState) AddPreExecuteReorg(f PreExecuteReorgFunc) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.preExecuteReorg = append(s.preExecuteReorg, f)
+}
+
 func (s *ReorgState) AddOnReorgCallback(f ReorgCallbackType) {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 	s.onReorgCallbacks = append(s.onReorgCallbacks, f)
 }
 
+func (s *ReorgState) executePreExecuteReorg(ctx context.Context, reorgRequest *ReorgRequest, dbTx storageTxType) error {
+	for _, f := range s.preExecuteReorg {
+		err := f(ctx, reorgRequest, dbTx)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (s *ReorgState) ExecuteReorg(ctx context.Context, reorgRequest ReorgRequest, dbTx storageTxType) ReorgExecutionResult {
 	startTime := time.Now()
-	err := s.storage.ResetToL1BlockNumber(ctx, reorgRequest.FirstL1BlockNumberToKeep, dbTx)
+	err := s.executePreExecuteReorg(ctx, &reorgRequest, dbTx)
+	if err != nil {
+		return s.createNewResult(reorgRequest, err, startTime)
+	}
+	err = s.storage.ResetToL1BlockNumber(ctx, reorgRequest.FirstL1BlockNumberToKeep, dbTx)
 	res := s.createNewResult(reorgRequest, err, startTime)
 	dbTx.AddCommitCallback(s.onTxCommit)
 	dbTx.AddCommitCallback(s.onTxRollback)

state/model/rollback_batches_state.go

@@ -22,6 +22,7 @@ type StorageRollbackBatchesInterface interface {
 	GetSequencesGreatestOrEqualBatchNumber(ctx context.Context, batchNumber uint64, dbTx storageTxType) (*SequencesBatchesSlice, error)
 	DeleteSequencesGreatestOrEqualBatchNumber(ctx context.Context, batchNumber uint64, dbTx storageTxType) error
 	AddRollbackBatchesLogEntry(ctx context.Context, entry *RollbackBatchesLogEntry, dbTx dbTxType) error
+	GetRollbackBatchesLogEntryGreaterOrEqualL1BlockNumber(ctx context.Context, l1BlockNumber uint64, dbTx dbTxType) ([]RollbackBatchesLogEntry, error)
 }
 
 type RollbackBatchesExecutionResult struct {
@@ -106,3 +107,23 @@ func (s *RollbackBatchesState) ExecuteRollbackBatches(ctx context.Context, rollb
 	dbTx.AddCommitCallback(func(dbTx storageTxType, err error) { s.onTxCommit(response, dbTx, err) })
 	return response, nil
 }
+
+// PreExecuteReorg check that is possible to execute the reorg
+// or add more info to the reorg request
+func (s *RollbackBatchesState) PreExecuteReorg(ctx context.Context, reorgRequest *ReorgRequest, dbTx storageTxType) error {
+	entries, err := s.storage.GetRollbackBatchesLogEntryGreaterOrEqualL1BlockNumber(ctx, reorgRequest.FirstL1BlockNumberToKeep+1, dbTx)
+	if err != nil {
+		err = fmt.Errorf("pre_execute_reorg: error getting rollback batches log entries (L1BlockNumber>=%d): %w", reorgRequest.FirstL1BlockNumberToKeep+1, err)
+		log.Error(err.Error())
+		return err
+	}
+	if len(entries) == 0 {
+		log.Infof("pre_execute_reorg: no rollback batches log entries affected for reorg (L1BlockNumber>=%d)", reorgRequest.FirstL1BlockNumberToKeep+1)
+		return nil
+	}
+	// Todo a real reorg you must get the lowest UndoFirstBlockNumber and execute the reorg from this point
+	err = fmt.Errorf("pre_execute_reorg: reorg not possible (L1BlockNumber>=%d), affect to rollback batches! (%v)", reorgRequest.FirstL1BlockNumberToKeep+1, entries)
+	log.Error(err.Error())
+	return err
+
+}

state/state.go

@@ -30,5 +30,7 @@ func NewState(storageImpl storage.Storer) *State {
 	}
 	// Connect cache invalidation on Reorg
 	res.ReorgState.AddOnReorgCallback(res.L1InfoTreeState.OnReorg)
+	// Before doing a reorg rollbackBatches must validate it
+	res.ReorgState.AddPreExecuteReorg(res.RollbackBatchesState.PreExecuteReorg)
 	return res
 }

synchronizer/synchronizer_adapter.go

@@ -27,6 +27,13 @@ func (s *SynchronizerAdapter) SetCallbackOnReorgDone(callback func(reorgData Reo
 }
 
 func (s *SynchronizerAdapter) SetCallbackOnRollbackBatches(callback func(data RollbackBatchesData)) {
+	s.internalSyncrhonizer.SetCallbackOnRollbackBatches(
+		func(data internal.RollbackBatchesData) {
+			callback(RollbackBatchesData{
+				LastBatchNumber:       data.LastBatchNumber,
+				LastBatchAccInputHash: data.LastBatchAccInputHash,
+			})
+		})
 }
 
 func (s *SynchronizerAdapter) Sync(returnOnSync bool) error {