perf: cleanup marshaling in batch (#2794)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 

Ex: Closes #<issue number>
-->

This is a small change that avoids calling Hash() as we marshal in the
function and then marshal a few lines below. I was fixing another issue
and saw this. Its a minor optimisation that reduces allocations

Author: tac0turtle

block/internal/submitting/submitter.go

@@ -391,12 +391,13 @@ func (s *Submitter) IsHeightDAIncluded(height uint64, header *types.SignedHeader
 	}
 
 	headerHash := header.Hash().String()
-	dataHash := data.DACommitment().String()
+	dataCommitment := data.DACommitment()
+	dataHash := dataCommitment.String()
 
 	_, headerIncluded := s.cache.GetHeaderDAIncluded(headerHash)
 	_, dataIncluded := s.cache.GetDataDAIncluded(dataHash)
 
-	dataIncluded = bytes.Equal(data.DACommitment(), common.DataHashForEmptyTxs) || dataIncluded
+	dataIncluded = bytes.Equal(dataCommitment, common.DataHashForEmptyTxs) || dataIncluded
 
 	return headerIncluded && dataIncluded, nil
 }

block/internal/syncing/syncer.go

@@ -418,6 +418,7 @@ func (s *Syncer) trySyncNextBlock(event *common.DAHeightEvent) error {
 	data := event.Data
 	nextHeight := event.Header.Height()
 	currentState := s.GetLastState()
+	headerHash := header.Hash().String()
 
 	s.logger.Info().Uint64("height", nextHeight).Msg("syncing block")
 
@@ -426,7 +427,7 @@ func (s *Syncer) trySyncNextBlock(event *common.DAHeightEvent) error {
 	// The header validation must be done before applying the block to avoid executing gibberish
 	if err := s.validateBlock(header, data); err != nil {
 		// remove header as da included (not per se needed, but keep cache clean)
-		s.cache.RemoveHeaderDAIncluded(header.Hash().String())
+		s.cache.RemoveHeaderDAIncluded(headerHash)
 		return errors.Join(errInvalidBlock, fmt.Errorf("failed to validate block: %w", err))
 	}
 
@@ -467,7 +468,7 @@ func (s *Syncer) trySyncNextBlock(event *common.DAHeightEvent) error {
 	s.metrics.Height.Set(float64(newState.LastBlockHeight))
 
 	// Mark as seen
-	s.cache.SetHeaderSeen(header.Hash().String(), header.Height())
+	s.cache.SetHeaderSeen(headerHash, header.Height())
 	if !bytes.Equal(header.DataHash, common.DataHashForEmptyTxs) {
 		s.cache.SetDataSeen(data.DACommitment().String(), newState.LastBlockHeight)
 	}

pkg/store/batch.go

@@ -47,7 +47,6 @@ func (b *DefaultBatch) SetHeight(height uint64) error {
 
 // SaveBlockData saves block data to the batch
 func (b *DefaultBatch) SaveBlockData(header *types.SignedHeader, data *types.Data, signature *types.Signature) error {
-	hash := header.Hash()
 	height := header.Height()
 	signatureHash := *signature
 
@@ -70,8 +69,9 @@ func (b *DefaultBatch) SaveBlockData(header *types.SignedHeader, data *types.Dat
 		return fmt.Errorf("failed to put signature blob in batch: %w", err)
 	}
 
+	headerHash := types.HeaderHash(headerBlob)
 	heightBytes := encodeHeight(height)
-	if err := b.batch.Put(b.ctx, ds.NewKey(getIndexKey(hash)), heightBytes); err != nil {
+	if err := b.batch.Put(b.ctx, ds.NewKey(getIndexKey(headerHash)), heightBytes); err != nil {
 		return fmt.Errorf("failed to put index key in batch: %w", err)
 	}
 

pkg/store/store.go

@@ -228,7 +228,8 @@ func (s *DefaultStore) Rollback(ctx context.Context, height uint64, aggregator b
 	}
 
 	for currentHeight > height {
-		header, err := s.GetHeader(ctx, currentHeight)
+		// Get header blob directly to reuse for hash calculation
+		headerBlob, err := s.db.Get(ctx, ds.NewKey(getHeaderKey(currentHeight)))
 		if err != nil {
 			return fmt.Errorf("failed to get header at height %d: %w", currentHeight, err)
 		}
@@ -245,7 +246,8 @@ func (s *DefaultStore) Rollback(ctx context.Context, height uint64, aggregator b
 			return fmt.Errorf("failed to delete signature of block blob in batch: %w", err)
 		}
 
-		hash := header.Hash()
+		// Use HeaderHash to avoid re-marshaling the header
+		hash := types.HeaderHash(headerBlob)
 		if err := batch.Delete(ctx, ds.NewKey(getIndexKey(hash))); err != nil {
 			return fmt.Errorf("failed to delete index key in batch: %w", err)
 		}

types/hashing.go

@@ -15,6 +15,13 @@ func (h *Header) Hash() Hash {
 	if err != nil {
 		return nil
 	}
+	return HeaderHash(bytes)
+}
+
+// HeaderHash returns the SHA256 hash of pre-marshaled header bytes.
+// Use this function when you already have marshaled header bytes to avoid
+// redundant marshaling operations. For convenience, use Header.Hash() instead.
+func HeaderHash(bytes []byte) Hash {
 	hash := sha256.Sum256(bytes)
 	return hash[:]
 }

types/hashing_test.go

@@ -96,3 +96,21 @@ func TestLeafHashOpt(t *testing.T) {
 	assert.Equal(t, expectedHash2, hash2)
 	assert.NotEqual(t, hash1, hash2)
 }
+
+// TestHeaderHashWithBytes tests the HeaderHash function directly
+func TestHeaderHashWithBytes(t *testing.T) {
+	header := &Header{
+		BaseHeader: BaseHeader{Height: 1, Time: 1234567890},
+		DataHash:   []byte("datahash"),
+	}
+
+	// Hash using the method
+	hash1 := header.Hash()
+
+	// Hash using the function directly
+	headerBytes, err := header.MarshalBinary()
+	require.NoError(t, err)
+	hash2 := HeaderHash(headerBytes)
+
+	assert.Equal(t, hash1, hash2, "HeaderHash should produce same result as Header.Hash()")
+}