Fix bugs in block polling logic and serialization (#84)

### TL;DR

Improved error handling and logging in the poller and serializer components.

### What changed?

- Enhanced logging in the poller to include the number of blocks being polled.
- Added a check to skip polling when the start block is greater than the latest block.
- Fixed a miscalculation issue in block range calculation due to pointer references.
- Improved error handling in the serializer for nil block results.
- Modified the serializer to use a dynamic slice instead of a fixed-size array for results.

### How to test?

1. Run the poller with various block ranges, including edge cases where the start block is greater than the latest block.
2. Simulate scenarios where the RPC returns nil block results and verify proper error handling.
3. Test the serializer with a large number of blocks to ensure dynamic slice allocation works correctly.
4. Verify that the new log messages appear correctly in the debug output.

### Why make this change?

These changes improve the robustness and reliability of the polling and serialization processes. By adding more detailed logging and error handling, it becomes easier to diagnose issues and prevent potential crashes. The modifications also optimize memory usage by using dynamic slices and fix a potential integer overflow bug in block range calculations.

Author: iuwqyir

internal/orchestrator/poller.go

@@ -98,7 +98,7 @@ func (p *Poller) Start() {
 						return
 					}
 				}
-				log.Debug().Msgf("Polling blocks %s to %s", blockNumbers[0], endBlock)
+				log.Debug().Msgf("Polling %d blocks starting from %s to %s", len(blockNumbers), blockNumbers[0], endBlock)
 
 				worker := worker.NewWorker(p.rpc)
 				results := worker.Run(blockNumbers)
@@ -131,11 +131,15 @@ func (p *Poller) getBlockRange() ([]*big.Int, error) {
 	startBlock := new(big.Int).Add(p.lastPolledBlock, big.NewInt(1))
 	endBlock := new(big.Int).Add(startBlock, big.NewInt(p.blocksPerPoll-1))
 
+	if startBlock.Cmp(latestBlock) > 0 {
+		log.Debug().Msgf("Start block %s is greater than latest block %s, skipping", startBlock, latestBlock)
+		return nil, nil
+	}
 	if endBlock.Cmp(latestBlock) > 0 {
 		endBlock = latestBlock
 	}
 
-	blockCount := endBlock.Sub(endBlock, startBlock).Int64() + 1
+	blockCount := new(big.Int).Sub(endBlock, startBlock).Int64() + 1
 	blockNumbers := make([]*big.Int, blockCount)
 	for i := int64(0); i < blockCount; i++ {
 		blockNumbers[i] = new(big.Int).Add(startBlock, big.NewInt(i))

internal/worker/serializer.go

@@ -2,6 +2,7 @@ package worker
 
 import (
 	"encoding/json"
+	"fmt"
 	"math/big"
 	"strconv"
 
@@ -10,7 +11,7 @@ import (
 )
 
 func SerializeWorkerResults(chainId *big.Int, blocks []BatchFetchResult[RawBlock], logs []BatchFetchResult[RawLogs], traces []BatchFetchResult[RawTraces]) []WorkerResult {
-	results := make([]WorkerResult, len(blocks))
+	results := make([]WorkerResult, 0, len(blocks))
 
 	rawLogsMap := make(map[string]BatchFetchResult[RawLogs])
 	for _, rawLogs := range logs {
@@ -22,14 +23,20 @@ func SerializeWorkerResults(chainId *big.Int, blocks []BatchFetchResult[RawBlock
 		rawTracesMap[rawTraces.BlockNumber.String()] = rawTraces
 	}
 
-	for i, rawBlock := range blocks {
+	for _, rawBlock := range blocks {
 		result := WorkerResult{
 			BlockNumber: rawBlock.BlockNumber,
 		}
+		if rawBlock.Result == nil {
+			log.Warn().Msgf("Received a nil block result for block %s.", rawBlock.BlockNumber.String())
+			result.Error = fmt.Errorf("received a nil block result from RPC")
+			results = append(results, result)
+			continue
+		}
 
 		if rawBlock.Error != nil {
 			result.Error = rawBlock.Error
-			results[i] = result
+			results = append(results, result)
 			continue
 		}
 
@@ -55,7 +62,7 @@ func SerializeWorkerResults(chainId *big.Int, blocks []BatchFetchResult[RawBlock
 			}
 		}
 
-		results[i] = result
+		results = append(results, result)
 	}
 
 	return results