fix: bug block not been processed yet

.github/workflows/test-e2e-multi_pp.yml

@@ -38,7 +38,7 @@ jobs:
       with:
         repository: 0xPolygon/kurtosis-cdk
         path: kurtosis-cdk
-        ref: v0.2.26
+        ref: v0.2.31
 
     - name: Install Kurtosis CDK tools
       uses: ./kurtosis-cdk/.github/actions/setup-kurtosis-cdk

.github/workflows/test-e2e.yml

@@ -52,7 +52,7 @@ jobs:
       with:
         repository: 0xPolygon/kurtosis-cdk
         path: kurtosis-cdk
-        ref: v0.2.25
+        ref: v0.2.31
 
     - name: Install Kurtosis CDK tools
       uses: ./kurtosis-cdk/.github/actions/setup-kurtosis-cdk
@@ -88,6 +88,7 @@ jobs:
         KURTOSIS_FOLDER: ${{ github.workspace }}/kurtosis-cdk
         BATS_LIB_PATH: /usr/lib/
         agglayer_prover_sp1_key: ${{ secrets.SP1_PRIVATE_KEY }}
+
 
     - name: Dump enclave logs
       if: failure()

.golangci.yml

@@ -3,10 +3,6 @@
 run:
   timeout: 3m
   tests: true
-  skip-dirs-use-default: true
-
-service:
-  golangci-lint-version: 1.61.0
 
 linters:
   disable-all: true

sync/evmdownloader.go

@@ -153,14 +153,18 @@ func (d *EVMDownloader) Download(ctx context.Context, fromBlock uint64, download
 		blocks := d.GetEventsByBlockRange(ctx, fromBlock, requestToBlock)
 		d.log.Debugf("result events from blocks [%d to  %d] -> len(blocks)=%d",
 			fromBlock, requestToBlock, len(blocks))
-		if toBlock <= lastFinalizedBlockNumber {
+		if requestToBlock <= lastFinalizedBlockNumber {
+			d.log.Debugf("range in safe zone: requestToBlock:%d <= finalized: %d",
+				requestToBlock, lastFinalizedBlockNumber)
 			d.reportBlocks(downloadedCh, blocks, lastFinalizedBlockNumber)
-			if blocks.Len() == 0 || blocks[blocks.Len()-1].Num < toBlock {
-				d.reportEmptyBlock(ctx, downloadedCh, toBlock, lastFinalizedBlockNumber)
+			if blocks.Len() == 0 || blocks[blocks.Len()-1].Num < requestToBlock {
+				d.reportEmptyBlock(ctx, downloadedCh, requestToBlock, lastFinalizedBlockNumber)
 			}
-			fromBlock = toBlock + 1
+			fromBlock = requestToBlock + 1
 			toBlock = fromBlock + d.syncBlockChunkSize
 		} else {
+			d.log.Debugf("range in not in safe zone: requestToBlock:%d <= finalized: %d",
+				requestToBlock, lastFinalizedBlockNumber)
 			if blocks.Len() == 0 {
 				if lastFinalizedBlockNumber >= fromBlock {
 					emptyBlock := lastFinalizedBlockNumber

sync/evmdownloader_test.go

@@ -312,24 +312,7 @@ func TestGetLogs(t *testing.T) {
 }
 
 func TestDownloadBeforeFinalized(t *testing.T) {
-	mockEthDownloader := NewEVMDownloaderMock(t)
-
-	ctx := context.Background()
-	ctx1, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	downloader, _ := NewTestDownloader(t, time.Millisecond)
-	downloader.EVMDownloaderInterface = mockEthDownloader
-
-	steps := []struct {
-		finalizedBlock          uint64
-		fromBlock, toBlock      uint64
-		eventsReponse           EVMBlocks
-		waitForNewBlocks        bool
-		waitForNewBlocksRequest uint64
-		waitForNewBlockReply    uint64
-		getBlockHeader          *EVMBlockHeader
-	}{
+	steps := []evmTestStep{
 		{finalizedBlock: 33, fromBlock: 1, toBlock: 11, waitForNewBlocks: true, waitForNewBlocksRequest: 0, waitForNewBlockReply: 35, getBlockHeader: &EVMBlockHeader{Num: 11}},
 		{finalizedBlock: 33, fromBlock: 12, toBlock: 22, eventsReponse: EVMBlocks{createEVMBlock(t, 14, true)}, getBlockHeader: &EVMBlockHeader{Num: 22}},
 		// It returns the last block of range, so it don't need to create a empty one
@@ -349,41 +332,18 @@ func TestDownloadBeforeFinalized(t *testing.T) {
 		{finalizedBlock: 61, fromBlock: 61, toBlock: 61, waitForNewBlocks: true, waitForNewBlocksRequest: 60, waitForNewBlockReply: 61, getBlockHeader: &EVMBlockHeader{Num: 61}},
 		{finalizedBlock: 61, fromBlock: 62, toBlock: 62, waitForNewBlocks: true, waitForNewBlocksRequest: 61, waitForNewBlockReply: 62},
 	}
-	for i := 0; i < len(steps); i++ {
-		log.Info("iteration: ", i, "------------------------------------------------")
-		downloadCh := make(chan EVMBlock, 100)
-		downloader, _ := NewTestDownloader(t, time.Millisecond)
-		downloader.EVMDownloaderInterface = mockEthDownloader
-		downloader.setStopDownloaderOnIterationN(i + 1)
-		expectedBlocks := EVMBlocks{}
-		for _, step := range steps[:i+1] {
-			mockEthDownloader.On("GetLastFinalizedBlock", mock.Anything).Return(&types.Header{Number: big.NewInt(int64(step.finalizedBlock))}, nil).Once()
-			if step.waitForNewBlocks {
-				mockEthDownloader.On("WaitForNewBlocks", mock.Anything, step.waitForNewBlocksRequest).Return(step.waitForNewBlockReply).Once()
-			}
-			mockEthDownloader.On("GetEventsByBlockRange", mock.Anything, step.fromBlock, step.toBlock).
-				Return(step.eventsReponse, false).Once()
-			for _, eventBlock := range step.eventsReponse {
-				expectedBlocks = append(expectedBlocks, eventBlock)
-			}
-			if step.getBlockHeader != nil {
-				log.Infof("iteration:%d : GetBlockHeader(%d) ", i, step.getBlockHeader.Num)
-				mockEthDownloader.On("GetBlockHeader", mock.Anything, step.getBlockHeader.Num).Return(*step.getBlockHeader, false).Once()
-				expectedBlocks = append(expectedBlocks, &EVMBlock{
-					EVMBlockHeader:   *step.getBlockHeader,
-					IsFinalizedBlock: step.getBlockHeader.Num <= step.finalizedBlock,
-				})
-			}
-		}
-		downloader.Download(ctx1, 1, downloadCh)
-		mockEthDownloader.AssertExpectations(t)
-		for _, expectedBlock := range expectedBlocks {
-			log.Debugf("waiting block %d ", expectedBlock.Num)
-			actualBlock := <-downloadCh
-			log.Debugf("block %d received!", actualBlock.Num)
-			require.Equal(t, *expectedBlock, actualBlock)
-		}
+	runSteps(t, 1, steps)
+}
+
+func TestCaseAskLastBlockIfFinalitySameAsTargetBlock(t *testing.T) {
+	steps := []evmTestStep{
+		{finalizedBlock: 105, fromBlock: 99, toBlock: 105, waitForNewBlocks: true, waitForNewBlocksRequest: 0, waitForNewBlockReply: 105, getBlockHeader: &EVMBlockHeader{Num: 105}},
+		{finalizedBlock: 110, fromBlock: 106, toBlock: 110, waitForNewBlocks: true, waitForNewBlocksRequest: 105, waitForNewBlockReply: 110, getBlockHeader: &EVMBlockHeader{Num: 110}},
+		// Here is the bug:
+		// - the range 111-115 returns block: 106. So the code must emit the block 106 and also the block 115 as empty (last block)
+		{finalizedBlock: 115, fromBlock: 111, toBlock: 115, waitForNewBlocks: true, waitForNewBlocksRequest: 110, waitForNewBlockReply: 115, eventsReponse: EVMBlocks{createEVMBlock(t, 106, false)}, getBlockHeader: &EVMBlockHeader{Num: 115}},
 	}
+	runSteps(t, 99, steps)
 }
 
 func buildAppender() LogAppenderMap {
@@ -424,3 +384,59 @@ func createEVMBlock(t *testing.T, num uint64, isSafeBlock bool) *EVMBlock {
 		},
 	}
 }
+
+type evmTestStep struct {
+	finalizedBlock          uint64
+	fromBlock, toBlock      uint64
+	eventsReponse           EVMBlocks
+	waitForNewBlocks        bool
+	waitForNewBlocksRequest uint64
+	waitForNewBlockReply    uint64
+	getBlockHeader          *EVMBlockHeader
+}
+
+func runSteps(t *testing.T, fromBlock uint64, steps []evmTestStep) {
+	t.Helper()
+	mockEthDownloader := NewEVMDownloaderMock(t)
+
+	ctx := context.Background()
+	ctx1, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	downloader, _ := NewTestDownloader(t, time.Millisecond)
+	downloader.EVMDownloaderInterface = mockEthDownloader
+
+	for i := 0; i < len(steps); i++ {
+		log.Info("iteration: ", i, "------------------------------------------------")
+		downloadCh := make(chan EVMBlock, 100)
+		downloader, _ := NewTestDownloader(t, time.Millisecond)
+		downloader.EVMDownloaderInterface = mockEthDownloader
+		downloader.setStopDownloaderOnIterationN(i + 1)
+		expectedBlocks := EVMBlocks{}
+		for _, step := range steps[:i+1] {
+			mockEthDownloader.On("GetLastFinalizedBlock", mock.Anything).Return(&types.Header{Number: big.NewInt(int64(step.finalizedBlock))}, nil).Once()
+			if step.waitForNewBlocks {
+				mockEthDownloader.On("WaitForNewBlocks", mock.Anything, step.waitForNewBlocksRequest).Return(step.waitForNewBlockReply).Once()
+			}
+			mockEthDownloader.On("GetEventsByBlockRange", mock.Anything, step.fromBlock, step.toBlock).
+				Return(step.eventsReponse, false).Once()
+			expectedBlocks = append(expectedBlocks, step.eventsReponse...)
+			if step.getBlockHeader != nil {
+				log.Infof("iteration:%d : GetBlockHeader(%d) ", i, step.getBlockHeader.Num)
+				mockEthDownloader.On("GetBlockHeader", mock.Anything, step.getBlockHeader.Num).Return(*step.getBlockHeader, false).Once()
+				expectedBlocks = append(expectedBlocks, &EVMBlock{
+					EVMBlockHeader:   *step.getBlockHeader,
+					IsFinalizedBlock: step.getBlockHeader.Num <= step.finalizedBlock,
+				})
+			}
+		}
+		downloader.Download(ctx1, fromBlock, downloadCh)
+		mockEthDownloader.AssertExpectations(t)
+		for _, expectedBlock := range expectedBlocks {
+			log.Debugf("waiting block %d ", expectedBlock.Num)
+			actualBlock := <-downloadCh
+			log.Debugf("block %d received!", actualBlock.Num)
+			require.Equal(t, *expectedBlock, actualBlock)
+		}
+	}
+}

sync/evmdriver_test.go

@@ -25,7 +25,7 @@ func TestSync(t *testing.T) {
 	}
 	rdm := NewReorgDetectorMock(t)
 	pm := NewProcessorMock(t)
-	dm := NewEVMDownloaderMock(t)
+	dm := NewDownloaderMock(t)
 	firstReorgedBlock := make(chan uint64)
 	reorgProcessed := make(chan bool)
 	rdm.On("Subscribe", reorgDetectorID).Return(&reorgdetector.Subscription{
@@ -126,7 +126,7 @@ func TestHandleNewBlock(t *testing.T) {
 	}
 	rdm := NewReorgDetectorMock(t)
 	pm := NewProcessorMock(t)
-	dm := NewEVMDownloaderMock(t)
+	dm := NewDownloaderMock(t)
 	rdm.On("Subscribe", reorgDetectorID).Return(&reorgdetector.Subscription{}, nil)
 	driver, err := NewEVMDriver(rdm, pm, dm, reorgDetectorID, 10, rh)
 	require.NoError(t, err)
@@ -206,7 +206,7 @@ func TestHandleReorg(t *testing.T) {
 	}
 	rdm := NewReorgDetectorMock(t)
 	pm := NewProcessorMock(t)
-	dm := NewEVMDownloaderMock(t)
+	dm := NewDownloaderMock(t)
 	reorgProcessed := make(chan bool)
 	rdm.On("Subscribe", reorgDetectorID).Return(&reorgdetector.Subscription{
 		ReorgProcessed: reorgProcessed,