Add sentinel errors, edge-case tests, warning logs, and init.go fix

- Add ErrNilBatchFetcher, ErrBatchHashMismatch, ErrParseBatchPostingReport
  sentinel errors with %w wrapping for programmatic error checking
- Remove redundant nil guard in delayed.go since
  FillInBatchGasFieldsWithParentBlock handles non-BatchPostingReport
- Add edge-case tests: nil fetcher data, empty batch, idempotent calls,
  WithParentBlock nil data, and all non-BatchPostingReport message kinds
- Add warning logs for swallowed FillInBatchGasFields errors in replay
  binary and GetMessage; fix misleading reorg log message
- Use log.Error instead of log.Warn in replay binary (log level filtering)
- Provide stub batchFetcher in init.go to satisfy non-nil contract

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: joshuacolvin0

arbnode/delayed.go

@@ -239,11 +239,9 @@ func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []type
 			},
 			ParentChainBlockNumber: parsedLog.Raw.BlockNumber,
 		}
-		if batchFetcher != nil {
-			err := msg.Message.FillInBatchGasFieldsWithParentBlock(batchFetcher, msg.ParentChainBlockNumber)
-			if err != nil {
-				return nil, err
-			}
+		err := msg.Message.FillInBatchGasFieldsWithParentBlock(batchFetcher, msg.ParentChainBlockNumber)
+		if err != nil {
+			return nil, err
 		}
 		messages = append(messages, msg)
 	}

arbnode/transaction_streamer.go

@@ -388,7 +388,7 @@ func (s *TransactionStreamer) addMessagesAndReorg(batch ethdb.Batch, msgIdxOfFir
 				}
 				delayedInBlock, err := s.delayedBridge.LookupMessagesInRange(s.GetContext(), msgBlockNum, msgBlockNum, batchFetcher)
 				if err != nil {
-					log.Error("reorg-resequence: failed to serialize old delayed message from database", "err", err)
+					log.Error("reorg-resequence: failed to look up old delayed message from L1", "err", err)
 					continue
 				}
 				messageFound := false
@@ -542,6 +542,8 @@ func (s *TransactionStreamer) GetMessage(msgIdx arbutil.MessageIndex) (*arbostyp
 		if err != nil {
 			return nil, err
 		}
+	} else if message.Message.Header.Kind == arbostypes.L1MessageType_BatchPostingReport {
+		log.Warn("GetMessage: cannot fill in batch gas fields for BatchPostingReport without inboxReader", "msgIdx", msgIdx)
 	}
 	return &message, nil
 }

arbos/arbostypes/incomingmessage.go

@@ -36,6 +36,12 @@ const (
 
 const MaxL2MessageSize = 256 * 1024
 
+var (
+	ErrNilBatchFetcher         = errors.New("batch fetcher is nil")
+	ErrBatchHashMismatch       = errors.New("batch data hash mismatch")
+	ErrParseBatchPostingReport = errors.New("failed to parse batch posting report")
+)
+
 func ValidateMaxTxDataSize(maxTxDataSize uint64) error {
 	// tighter limit https://github.com/OffchainLabs/nitro/commit/ed015e752d7d24e59ec9e6f894fe1a26ffa19036
 	// The default block gas limit can fit 1523 txs
@@ -201,15 +207,15 @@ func (msg *L1IncomingMessage) FillInBatchGasFieldsWithParentBlock(batchFetcher F
 		return nil
 	}
 	if batchFetcher == nil {
-		return fmt.Errorf("batch fetcher is nil, cannot fill in batch gas fields for batch posting report (parentChainBlockNumber %d)", parentChainBlockNumber)
+		return fmt.Errorf("%w: cannot fill in batch gas fields for batch posting report (parentChainBlockNumber %d)", ErrNilBatchFetcher, parentChainBlockNumber)
 	}
 	if msg.BatchDataStats != nil && msg.LegacyBatchGasCost != nil {
 		return nil
 	}
 	if msg.BatchDataStats == nil {
 		_, _, batchHash, batchNum, _, _, err := ParseBatchPostingReportMessageFields(bytes.NewReader(msg.L2msg))
 		if err != nil {
-			return fmt.Errorf("failed to parse batch posting report: %w", err)
+			return fmt.Errorf("%w: %w", ErrParseBatchPostingReport, err)
 		}
 		batchData, err := batchFetcher(batchNum, parentChainBlockNumber)
 		if err != nil {
@@ -232,7 +238,7 @@ func (msg *L1IncomingMessage) FillInBatchGasFieldsWithParentBlock(batchFetcher F
 		} else {
 			gotHash := crypto.Keccak256Hash(batchData)
 			if gotHash != batchHash {
-				return fmt.Errorf("batch fetcher returned incorrect data hash %v (wanted %v for batch %v)", gotHash, batchHash, batchNum)
+				return fmt.Errorf("%w: got %v, wanted %v for batch %v", ErrBatchHashMismatch, gotHash, batchHash, batchNum)
 			}
 			msg.BatchDataStats = GetDataStats(batchData)
 		}

arbos/arbostypes/incomingmessage_test.go

@@ -7,7 +7,6 @@ import (
 	"bytes"
 	"errors"
 	"math/big"
-	"strings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -24,9 +23,13 @@ func TestFillInBatchGasFieldsNilFetcherBatchPostingReport(t *testing.T) {
 		},
 		L2msg: make([]byte, 148),
 	}
-	if err := msg.FillInBatchGasFields(nil); err == nil {
+	err := msg.FillInBatchGasFields(nil)
+	if err == nil {
 		t.Fatal("expected error when batchFetcher is nil for BatchPostingReport")
 	}
+	if !errors.Is(err, ErrNilBatchFetcher) {
+		t.Fatalf("expected ErrNilBatchFetcher, got: %v", err)
+	}
 }
 
 func TestFillInBatchGasFieldsNilFetcherNonBatchPostingReport(t *testing.T) {
@@ -56,8 +59,8 @@ func TestFillInBatchGasFieldsWithParentBlockNilFetcherBatchPostingReport(t *test
 	if err == nil {
 		t.Fatal("expected error when batchFetcher is nil for BatchPostingReport")
 	}
-	if !strings.Contains(err.Error(), "parentChainBlockNumber 42") {
-		t.Fatalf("error should contain parentChainBlockNumber context, got: %v", err)
+	if !errors.Is(err, ErrNilBatchFetcher) {
+		t.Fatalf("expected ErrNilBatchFetcher, got: %v", err)
 	}
 }
 
@@ -104,7 +107,9 @@ func TestParseIncomingL1MessageNilFetcherNonBatchPostingReport(t *testing.T) {
 }
 
 // buildBatchPostingReportL2msg constructs an L2msg payload for a
-// BatchPostingReport that references batchData with the given batchNum.
+// BatchPostingReport that embeds the Keccak256 hash of batchData along with
+// the given batchNum, matching the format expected by
+// ParseBatchPostingReportMessageFields.
 func buildBatchPostingReportL2msg(t *testing.T, batchData []byte, batchNum uint64) []byte {
 	t.Helper()
 	dataHash := crypto.Keccak256Hash(batchData)
@@ -119,7 +124,7 @@ func buildBatchPostingReportL2msg(t *testing.T, batchData []byte, batchNum uint6
 }
 
 // buildBatchPostingReportMsg constructs a serialized BatchPostingReport message
-// whose L2msg references batchData with the given batchNum.
+// whose L2msg embeds the Keccak256 hash of batchData along with the given batchNum.
 func buildBatchPostingReportMsg(t *testing.T, batchData []byte, batchNum uint64) []byte {
 	t.Helper()
 	msg := &L1IncomingMessage{
@@ -149,6 +154,9 @@ func TestParseIncomingL1MessageNilFetcherBatchPostingReport(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error when batchFetcher is nil for BatchPostingReport")
 	}
+	if !errors.Is(err, ErrNilBatchFetcher) {
+		t.Fatalf("expected ErrNilBatchFetcher, got: %v", err)
+	}
 }
 
 func TestParseAndFillGasFieldsWithFetcher(t *testing.T) {
@@ -217,9 +225,10 @@ func TestFillInBatchGasFieldsSkipsWhenAlreadyPopulated(t *testing.T) {
 	}
 }
 
-func TestFillInBatchGasFieldsHashMismatch(t *testing.T) {
-	// If the fetcher returns data whose hash doesn't match the batch
-	// posting report, an error must be returned.
+func TestParseIncomingL1MessageHashMismatch(t *testing.T) {
+	// ParseIncomingL1Message must return ErrBatchHashMismatch when the
+	// fetcher returns data whose Keccak256 hash doesn't match the hash
+	// embedded in the BatchPostingReport's L2msg.
 	batchData := []byte("correct batch data")
 	var batchNum uint64 = 3
 	serialized := buildBatchPostingReportMsg(t, batchData, batchNum)
@@ -230,6 +239,9 @@ func TestFillInBatchGasFieldsHashMismatch(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for hash mismatch")
 	}
+	if !errors.Is(err, ErrBatchHashMismatch) {
+		t.Fatalf("expected ErrBatchHashMismatch, got: %v", err)
+	}
 	if msg != nil {
 		t.Fatal("expected nil message on error")
 	}
@@ -388,10 +400,8 @@ func TestFillInBatchGasFieldsOnlyBatchDataStatsSet(t *testing.T) {
 }
 
 func TestFillInBatchGasFieldsPopulatesFields(t *testing.T) {
-	// FillInBatchGasFields with a real fetcher must populate both
-	// BatchDataStats and LegacyBatchGasCost, and must pass
-	// msg.Header.BlockNumber as the parentChainBlockNumber to the
-	// underlying FallibleBatchFetcherWithParentBlock.
+	// FillInBatchGasFields with a working fetcher must populate both
+	// BatchDataStats and LegacyBatchGasCost.
 	batchData := []byte("test batch data direct")
 	var batchNum uint64 = 3
 	var blockNumber uint64 = 42
@@ -472,4 +482,158 @@ func TestFillInBatchGasFieldsTruncatedL2msg(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for truncated L2msg")
 	}
+	if !errors.Is(err, ErrParseBatchPostingReport) {
+		t.Fatalf("expected ErrParseBatchPostingReport, got: %v", err)
+	}
+}
+
+func TestFillInBatchGasFieldsFetcherReturnsNilData(t *testing.T) {
+	// When the fetcher returns (nil, nil) — no error but nil data — the
+	// Keccak256 hash of an empty input won't match the expected hash, so
+	// the function must return ErrBatchHashMismatch.
+	batchData := []byte("real batch data")
+	var batchNum uint64 = 4
+	msg := &L1IncomingMessage{
+		Header: &L1IncomingMessageHeader{
+			Kind: L1MessageType_BatchPostingReport,
+		},
+		L2msg: buildBatchPostingReportL2msg(t, batchData, batchNum),
+	}
+	fetcher := func(num uint64) ([]byte, error) {
+		return nil, nil
+	}
+	err := msg.FillInBatchGasFields(fetcher)
+	if err == nil {
+		t.Fatal("expected error when fetcher returns nil data")
+	}
+	if !errors.Is(err, ErrBatchHashMismatch) {
+		t.Fatalf("expected ErrBatchHashMismatch, got: %v", err)
+	}
+}
+
+func TestFillInBatchGasFieldsEmptyBatchData(t *testing.T) {
+	// When the fetcher returns empty (non-nil) batch data whose hash
+	// matches the L2msg, both fields should be populated correctly.
+	batchData := []byte{}
+	var batchNum uint64 = 8
+	msg := &L1IncomingMessage{
+		Header: &L1IncomingMessageHeader{
+			Kind:        L1MessageType_BatchPostingReport,
+			BlockNumber: 50,
+		},
+		L2msg: buildBatchPostingReportL2msg(t, batchData, batchNum),
+	}
+	fetcher := func(num uint64) ([]byte, error) {
+		if num != batchNum {
+			t.Fatalf("fetcher called with unexpected batch number %d, want %d", num, batchNum)
+		}
+		return batchData, nil
+	}
+	if err := msg.FillInBatchGasFields(fetcher); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if msg.BatchDataStats == nil {
+		t.Fatal("expected BatchDataStats to be populated")
+	}
+	expectedStats := GetDataStats(batchData)
+	if msg.BatchDataStats.Length != expectedStats.Length {
+		t.Fatalf("BatchDataStats.Length = %d, want %d", msg.BatchDataStats.Length, expectedStats.Length)
+	}
+	if msg.BatchDataStats.NonZeros != expectedStats.NonZeros {
+		t.Fatalf("BatchDataStats.NonZeros = %d, want %d", msg.BatchDataStats.NonZeros, expectedStats.NonZeros)
+	}
+	if msg.LegacyBatchGasCost == nil {
+		t.Fatal("expected LegacyBatchGasCost to be populated")
+	}
+}
+
+func TestFillInBatchGasFieldsWithParentBlockFetcherReturnsNilData(t *testing.T) {
+	// Same as TestFillInBatchGasFieldsFetcherReturnsNilData but exercises
+	// the WithParentBlock variant directly.
+	batchData := []byte("real batch data")
+	var batchNum uint64 = 4
+	msg := &L1IncomingMessage{
+		Header: &L1IncomingMessageHeader{
+			Kind:        L1MessageType_BatchPostingReport,
+			BlockNumber: 10,
+		},
+		L2msg: buildBatchPostingReportL2msg(t, batchData, batchNum),
+	}
+	fetcher := func(num uint64, parentBlock uint64) ([]byte, error) {
+		return nil, nil
+	}
+	err := msg.FillInBatchGasFieldsWithParentBlock(fetcher, 10)
+	if err == nil {
+		t.Fatal("expected error when fetcher returns nil data")
+	}
+	if !errors.Is(err, ErrBatchHashMismatch) {
+		t.Fatalf("expected ErrBatchHashMismatch, got: %v", err)
+	}
+}
+
+func TestFillInBatchGasFieldsIdempotent(t *testing.T) {
+	// Calling FillInBatchGasFields twice must be idempotent — the second
+	// call should be a no-op since both fields are already populated.
+	batchData := []byte("idempotent batch data")
+	var batchNum uint64 = 6
+	msg := &L1IncomingMessage{
+		Header: &L1IncomingMessageHeader{
+			Kind:        L1MessageType_BatchPostingReport,
+			BlockNumber: 20,
+		},
+		L2msg: buildBatchPostingReportL2msg(t, batchData, batchNum),
+	}
+	callCount := 0
+	fetcher := func(num uint64) ([]byte, error) {
+		callCount++
+		return batchData, nil
+	}
+	if err := msg.FillInBatchGasFields(fetcher); err != nil {
+		t.Fatalf("first call: unexpected error: %v", err)
+	}
+	if callCount != 1 {
+		t.Fatalf("expected fetcher to be called once, got %d", callCount)
+	}
+	firstStats := *msg.BatchDataStats
+	firstCost := *msg.LegacyBatchGasCost
+
+	if err := msg.FillInBatchGasFields(fetcher); err != nil {
+		t.Fatalf("second call: unexpected error: %v", err)
+	}
+	if callCount != 1 {
+		t.Fatalf("expected fetcher not to be called again, got %d calls", callCount)
+	}
+	if msg.BatchDataStats.Length != firstStats.Length || msg.BatchDataStats.NonZeros != firstStats.NonZeros {
+		t.Fatal("BatchDataStats changed on second call")
+	}
+	if *msg.LegacyBatchGasCost != firstCost {
+		t.Fatalf("LegacyBatchGasCost changed on second call: got %d, want %d", *msg.LegacyBatchGasCost, firstCost)
+	}
+}
+
+func TestFillInBatchGasFieldsAllMessageKindsWithNilFetcher(t *testing.T) {
+	// All non-BatchPostingReport message kinds must succeed with a nil
+	// fetcher, since there are no batch gas fields to fill.
+	kinds := []uint8{
+		L1MessageType_L2Message,
+		L1MessageType_EndOfBlock,
+		L1MessageType_L2FundedByL1,
+		L1MessageType_RollupEvent,
+		L1MessageType_SubmitRetryable,
+		L1MessageType_BatchForGasEstimation,
+		L1MessageType_Initialize,
+		L1MessageType_EthDeposit,
+		L1MessageType_Invalid,
+	}
+	for _, kind := range kinds {
+		msg := &L1IncomingMessage{
+			Header: &L1IncomingMessageHeader{
+				Kind: kind,
+			},
+			L2msg: make([]byte, 32),
+		}
+		if err := msg.FillInBatchGasFields(nil); err != nil {
+			t.Fatalf("kind %d: unexpected error with nil fetcher: %v", kind, err)
+		}
+	}
 }

cmd/nitro/init/init.go

@@ -1040,7 +1040,14 @@ func GetConsensusParsedInitMsg(ctx context.Context, parentChainReaderEnabled boo
 			return nil, fmt.Errorf("failed creating delayed bridge while attempting to get serialized chain config from init message: %w", err)
 		}
 		deployedAt := new(big.Int).SetUint64(rollupAddrs.DeployedAt)
-		delayedMessages, err := delayedBridge.LookupMessagesInRange(ctx, deployedAt, deployedAt, nil)
+		// This fetcher is only needed for BatchPostingReport messages, which
+		// should not appear at the deployment block. We only need Initialize
+		// messages here, but LookupMessagesInRange processes all messages in
+		// the block and requires a non-nil fetcher for BatchPostingReport.
+		batchFetcher := func(batchNum uint64, parentChainBlockNumber uint64) ([]byte, error) {
+			return nil, fmt.Errorf("batch data not available during init (batch %d at L1 block %d)", batchNum, parentChainBlockNumber)
+		}
+		delayedMessages, err := delayedBridge.LookupMessagesInRange(ctx, deployedAt, deployedAt, batchFetcher)
 		if err != nil {
 			return nil, fmt.Errorf("failed getting delayed messages while attempting to get serialized chain config from init message: %w", err)
 		}

cmd/replay/main.go

@@ -356,6 +356,7 @@ func main() {
 
 		err = message.Message.FillInBatchGasFields(batchFetcher)
 		if err != nil {
+			log.Error("Failed to fill in batch gas fields, treating as invalid message", "err", err)
 			message.Message = arbostypes.InvalidL1Message
 		}
 		return message