feat: cache data hash to optimize performance for empty blocks

proto/evnode/v1/evnode.proto

@@ -93,6 +93,7 @@ message Metadata {
 message Data {
   Metadata       metadata = 1;
   repeated bytes txs      = 2;
+  bytes          cached_hash = 3; // Optional cached hash for performance
 }
 
 // SignedData is a data with a signature and a signer.

types/data.go

@@ -33,6 +33,10 @@ type Metadata struct {
 type Data struct {
 	*Metadata
 	Txs Txs
+
+	// cachedHash stores the computed hash to avoid recalculation
+	// This field is set once when Hash() is first called and never modified after that
+	cachedHash Hash
 }
 
 // SignedData combines Data and its signature.

types/hashing.go

@@ -21,10 +21,22 @@ func (h *Header) Hash() Hash {
 
 // Hash returns hash of the Data
 func (d *Data) Hash() Hash {
+	// Return cached hash if already computed
+	if d.cachedHash != nil {
+		return d.cachedHash
+	}
+
+	// Compute hash if not cached
 	// Ignoring the marshal error for now to satisfy the go-header interface
 	// Later on the usage of Hash should be replaced with DA commitment
-	dBytes, _ := d.MarshalBinary()
-	return leafHashOpt(sha256.New(), dBytes)
+	// Use MarshalBinaryWithoutCache to avoid circular dependency with cached hash
+	dBytes, _ := d.MarshalBinaryWithoutCache()
+	hash := leafHashOpt(sha256.New(), dBytes)
+
+	// Cache the result - no synchronization needed since hash computation is idempotent
+	// If multiple goroutines compute this simultaneously, they'll get the same result
+	d.cachedHash = hash
+	return hash
 }
 
 // DACommitment returns the DA commitment of the Data excluding the Metadata

types/hashing_test.go

@@ -48,7 +48,8 @@ func TestDataHash(t *testing.T) {
 
 	hash1 := data.Hash()
 
-	dataBytes, err := data.MarshalBinary()
+	// Use MarshalBinaryWithoutCache for consistent hash calculation
+	dataBytes, err := data.MarshalBinaryWithoutCache()
 	require.NoError(t, err)
 
 	hasher := sha256.New()
@@ -60,14 +61,36 @@ func TestDataHash(t *testing.T) {
 	assert.Len(t, hash1, sha256.Size)
 	assert.Equal(t, Hash(expectedHash), hash1, "Data hash should match manual calculation with prefix")
 
-	data.Txs = Txs{Tx("tx3")}
-	hash2 := data.Hash()
+	// Test that different Data objects with different Txs have different hashes
+	data2 := Data{
+		Txs: Txs{Tx("tx3")},
+		Metadata: &Metadata{
+			ChainID:      "test-chain",
+			Height:       1,
+			Time:         1234567890,
+			LastDataHash: []byte("lastdatahash"),
+		},
+	}
+	hash2 := data2.Hash()
 	assert.NotEqual(t, hash1, hash2, "Different data (Txs) should have different hashes")
 
-	data.Metadata.Height = 2
-	hash3 := data.Hash()
+	// Test that different Data objects with different Metadata have different hashes
+	data3 := Data{
+		Txs: Txs{Tx("tx1"), Tx("tx2")},
+		Metadata: &Metadata{
+			ChainID:      "test-chain",
+			Height:       2, // Different height
+			Time:         1234567890,
+			LastDataHash: []byte("lastdatahash"),
+		},
+	}
+	hash3 := data3.Hash()
 	assert.NotEqual(t, hash1, hash3, "Different data (Metadata) should have different hashes")
 	assert.NotEqual(t, hash2, hash3)
+
+	// Test that calling Hash() multiple times on the same object returns the same result (caching)
+	hash1Again := data.Hash()
+	assert.Equal(t, hash1, hash1Again, "Hash should be cached and return same result")
 }
 
 // TestLeafHashOpt tests the helper function leafHashOpt directly.

types/serialization.go

@@ -47,6 +47,11 @@ func (d *Data) MarshalBinary() ([]byte, error) {
 	return proto.Marshal(d.ToProto())
 }
 
+// MarshalBinaryWithoutCache encodes Data without cached hash for hash calculation
+func (d *Data) MarshalBinaryWithoutCache() ([]byte, error) {
+	return proto.Marshal(d.ToProtoWithoutCache())
+}
+
 // UnmarshalBinary decodes binary form of Data into object.
 func (d *Data) UnmarshalBinary(data []byte) error {
 	var pData pb.Data
@@ -244,13 +249,28 @@ func (m *Metadata) FromProto(other *pb.Metadata) error {
 
 // ToProto converts Data into protobuf representation and returns it.
 func (d *Data) ToProto() *pb.Data {
+	var mProto *pb.Metadata
+	if d.Metadata != nil {
+		mProto = d.Metadata.ToProto()
+	}
+	return &pb.Data{
+		Metadata:   mProto,
+		Txs:        txsToByteSlices(d.Txs),
+		CachedHash: d.cachedHash,
+	}
+}
+
+// ToProtoWithoutCache converts Data to protobuf without the cached hash
+// This is used for hash calculation to avoid circular dependency
+func (d *Data) ToProtoWithoutCache() *pb.Data {
 	var mProto *pb.Metadata
 	if d.Metadata != nil {
 		mProto = d.Metadata.ToProto()
 	}
 	return &pb.Data{
 		Metadata: mProto,
 		Txs:      txsToByteSlices(d.Txs),
+		// CachedHash is intentionally omitted for hash calculation
 	}
 }
 
@@ -270,6 +290,13 @@ func (d *Data) FromProto(other *pb.Data) error {
 		d.Metadata = nil
 	}
 	d.Txs = byteSlicesToTxs(other.GetTxs())
+
+	// Restore cached hash from protobuf if available
+	if other.CachedHash != nil {
+		d.cachedHash = other.CachedHash
+	} else {
+		d.cachedHash = nil
+	}
 	return nil
 }