fix(manager): re-use submitted DA batches on SL failure (#708)

block/manager.go

@@ -60,11 +60,17 @@ type Manager struct {
  // Block production
  shouldProduceBlocksCh chan bool
  produceEmptyBlockCh chan bool
- lastSubmissionTime atomic.Int64
- batchInProcess sync.Mutex
  produceBlockMutex sync.Mutex
  applyCachedBlockMutex sync.Mutex
 
+ // batch submission
+ batchInProcess sync.Mutex
+ lastSubmissionTime atomic.Int64
+ // pendingBatch is the result of the last DA submission
+ // that is pending settlement layer submission.
+ // It is used to avoid double submission of the same batch.
+ pendingBatch *PendingBatch
+
  // Logging
  logger types.Logger
 

block/submit.go

@@ -49,37 +49,62 @@ func (m *Manager) handleSubmissionTrigger(ctx context.Context) {
  m.logger.Error("produce empty block", "error", err)
  }
 
- syncHeight, err := m.submitNextBatch()
+ if m.pendingBatch != nil {
+ m.logger.Info("pending batch exists", "startHeight", m.pendingBatch.batch.StartHeight, "endHeight", m.pendingBatch.batch.EndHeight)
+ } else {
+ nextBatch, err := m.createNextBatch()
+ if err != nil {
+ m.logger.Error("get next batch", "error", err)
+ return
+ }
+
+ resultSubmitToDA, err := m.submitNextBatchToDA(nextBatch)
+ if err != nil {
+ m.logger.Error("submit next batch", "error", err)
+ return
+ }
+
+ m.pendingBatch = &PendingBatch{
+ daResult: resultSubmitToDA,
+ batch: nextBatch,
+ }
+ }
+
+ syncHeight, err := m.submitPendingBatchToSL()
  if err != nil {
- m.logger.Error("submit next batch", "error", err)
+ m.logger.Error("submit next batch to SL", "error", err)
  return
  }
 
  // Update the syncTarget to the height of the last block in the last batch as seen by this node.
  m.updateSyncParams(syncHeight)
 }
 
-func (m *Manager) submitNextBatch() (uint64, error) {
- // Get the batch start and end height
+func (m *Manager) createNextBatch() (*types.Batch, error) {
+ // Create the batch
  startHeight := m.syncTarget.Load() + 1
  endHeight := m.store.Height()
-
- // Create the batch
  nextBatch, err := m.createNextDABatch(startHeight, endHeight)
  if err != nil {
  m.logger.Error("create next batch", "startHeight", startHeight, "endHeight", endHeight, "error", err)
- return 0, err
+ return nil, err
  }
 
  if err := m.validateBatch(nextBatch); err != nil {
- return 0, err
+ return nil, err
  }
+
+ return nextBatch, nil
+}
+
+func (m *Manager) submitNextBatchToDA(nextBatch *types.Batch) (*da.ResultSubmitBatch, error) {
+ startHeight := nextBatch.StartHeight
  actualEndHeight := nextBatch.EndHeight
 
  isLastBlockEmpty, err := m.isBlockEmpty(actualEndHeight)
  if err != nil {
  m.logger.Error("validate last block in batch is empty", "startHeight", startHeight, "endHeight", actualEndHeight, "error", err)
- return 0, err
+ return nil, err
  }
  // Verify the last block in the batch is an empty block and that no ibc messages has accidentially passed through.
  // This block may not be empty if another block has passed it in line. If that's the case our empty block request will
@@ -94,16 +119,28 @@ func (m *Manager) submitNextBatch() (uint64, error) {
  resultSubmitToDA := m.dalc.SubmitBatch(nextBatch)
  if resultSubmitToDA.Code != da.StatusSuccess {
  err = fmt.Errorf("submit next batch to DA Layer: %s", resultSubmitToDA.Message)
- return 0, err
+ return nil, err
+ }
+ return &resultSubmitToDA, nil
+}
+
+func (m *Manager) submitPendingBatchToSL() (uint64, error) {
+ if m.pendingBatch == nil {
+ return 0, fmt.Errorf("no pending batch to submit")
  }
 
  // Submit batch to SL
- err = m.settlementClient.SubmitBatch(nextBatch, m.dalc.GetClientType(), &resultSubmitToDA)
+ startHeight := m.pendingBatch.batch.StartHeight
+ actualEndHeight := m.pendingBatch.batch.EndHeight
+ err := m.settlementClient.SubmitBatch(m.pendingBatch.batch, m.dalc.GetClientType(), m.pendingBatch.daResult)
  if err != nil {
  m.logger.Error("submit batch to SL", "startHeight", startHeight, "endHeight", actualEndHeight, "error", err)
  return 0, err
  }
 
+ // Clear pending batch
+ m.pendingBatch = nil
+
  return actualEndHeight, nil
 }
 

block/types.go

@@ -1,5 +1,10 @@
 package block
 
+import (
+ "github.com/dymensionxyz/dymint/da"
+ "github.com/dymensionxyz/dymint/types"
+)
+
 // TODO: move to types package
 type blockSource string
 
@@ -13,3 +18,8 @@ type blockMetaData struct {
  source blockSource
  daHeight uint64
 }
+
+type PendingBatch struct {
+ daResult *da.ResultSubmitBatch
+ batch *types.Batch
+}