pool State.MarshalBinary and use it in UpdateState — saves 2 allocs per block

State.ToProto allocated pb.State + pb.Version + timestamppb.Timestamp per block.
MarshalBinary now pools those structs and returns the marshaled bytes directly.
pkg/store/batch.UpdateState switched from ToProto+proto.Marshal to MarshalBinary.

Author: tac0turtle

autoresearch.jsonl

@@ -6,3 +6,4 @@
 {"run":5,"commit":"0720b44","metric":74,"metrics":{"bytes_per_op":12192,"ns_per_op":31624},"status":"keep","description":"unsafe.Slice in Data.ToProto() — eliminates txsToByteSlices [][]byte allocation","timestamp":1775293190538,"segment":0,"confidence":7,"iterationTokens":9987,"asi":{"hypothesis":"Use unsafe.Slice in Data.ToProto() to avoid txsToByteSlices allocation","next_target":"Data.Hash() marshal + sha256 allocation; Header.ToProto() allocates pb.Header; Data.Size() marshals for metrics","notes":"Biggest single win yet — per-TX allocation eliminated for every protobuf encoding","result":"-3 allocs, ~8KB, ~0.5µs faster"}}
 {"run":6,"commit":"$(git r","metric":74,"metrics":{"bytes_per_op":12187,"ns_per_op":31217},"status":"discard","description":"Reverted hand-written HashSlim wire encoder — produced different hashes than MarshalBinary","timestamp":1775294347584,"segment":0,"confidence":2.8,"iterationTokens":25063,"asi":{"hypothesis":"Direct protobuf wire encoding in HashSlim to avoid pb.Header/pb.Version allocations","result":"Hash mismatch — wire encoding differences in version field (0a02 vs 0a04)","rollback_reason":"Hand-written encoder produces different byte output than protobuf MarshalBinary; would break hash verification","next_action_hint":"Focus on safe optimizations: avoid creating pb.SignedHeader/pb.Signer structs when possible, reduce allocations in store path, look at SignedHeader.ToProto hot path"}}
 {"run":7,"commit":"ccbc2e4","metric":64,"metrics":{"bytes_per_op":11130,"ns_per_op":31570},"status":"keep","description":"sync.Pool for protobuf message structs in MarshalBinary — eliminates 10 allocs per block","timestamp":1775296105928,"segment":0,"confidence":5.666666666666667,"iterationTokens":11490,"asi":{"hypothesis":"Pool pb.Header, pb.Version, pb.Data, pb.Metadata, pb.SignedHeader, pb.Signer, pb.State to avoid struct allocs in marshal hot path","result":"saved 10 allocs, ~1KB — from 74 to 64 allocs/op","key_files":"types/serialization.go","notes":"Only MarshalBinary uses pools (consumes result immediately). ToProto() API unchanged for external callers.","next_target":"Store path: NewBasicBatch, Put, GenerateKey, getIndexKey allocate per-store-op. Also Datastore.Put allocates."}}
+{"run":8,"commit":"805672e","metric":56,"metrics":{"bytes_per_op":10217,"ns_per_op":31037},"status":"keep","description":"Pooled SignedHeader.MarshalBinary — reuse pb.SignedHeader/pb.Header/pb.Signer/pb.Version structs","timestamp":1775296668832,"segment":0,"confidence":8.333333333333334,"iterationTokens":22478,"asi":{"hypothesis":"Pool protobuf structs in SignedHeader.MarshalBinary to eliminate 4 struct allocs per marshal","result":"saved 8 allocs, ~1KB — from 64 to 56 allocs/op","key_files":"types/serialization.go","next_target":"State.ToProto (11.5MB), Hash.String() for metrics (10.5MB), datastore batch/put allocs"}}

pkg/store/batch.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	ds "github.com/ipfs/go-datastore"
-	"google.golang.org/protobuf/proto"
 
 	"github.com/evstack/ev-node/types"
 )
@@ -84,18 +83,14 @@ func (b *DefaultBatch) SaveBlockDataFromBytes(header *types.SignedHeader, header
 	return nil
 }
 
-// UpdateState updates the state in the batch
+// UpdateState updates the state in the batch.
+// Uses pooled State.MarshalBinary to reduce per-block allocations.
 func (b *DefaultBatch) UpdateState(state types.State) error {
-	// Save the state at the height specified in the state itself
 	height := state.LastBlockHeight
 
-	pbState, err := state.ToProto()
+	data, err := state.MarshalBinary()
 	if err != nil {
-		return fmt.Errorf("failed to convert type state to protobuf type: %w", err)
-	}
-	data, err := proto.Marshal(pbState)
-	if err != nil {
-		return fmt.Errorf("failed to marshal state to protobuf: %w", err)
+		return fmt.Errorf("failed to marshal state: %w", err)
 	}
 
 	return b.batch.Put(b.ctx, ds.RawKey(getStateAtHeightKey(height)), data)

types/serialization.go

@@ -528,6 +528,38 @@ func (d *Data) FromProto(other *pb.Data) error {
 	return nil
 }
 
+// MarshalBinary encodes State into binary form using pooled protobuf messages
+// to reduce per-block allocations in the UpdateState hot path.
+func (s *State) MarshalBinary() ([]byte, error) {
+	ps := pbStatePool.Get().(*pb.State)
+	ps.Reset()
+
+	pv := pbVersionPool.Get().(*pb.Version)
+	pv.Block, pv.App = s.Version.Block, s.Version.App
+
+	pts := &timestamppb.Timestamp{
+		Seconds: s.LastBlockTime.Unix(),
+		Nanos:   int32(s.LastBlockTime.Nanosecond()),
+	}
+
+	ps.Version = pv
+	ps.ChainId = s.ChainID
+	ps.InitialHeight = s.InitialHeight
+	ps.LastBlockHeight = s.LastBlockHeight
+	ps.LastBlockTime = pts
+	ps.DaHeight = s.DAHeight
+	ps.AppHash = s.AppHash
+	ps.LastHeaderHash = s.LastHeaderHash
+
+	bz, err := proto.Marshal(ps)
+
+	ps.Reset()
+	pbStatePool.Put(ps)
+	pv.Reset()
+	pbVersionPool.Put(pv)
+	return bz, err
+}
+
 // ToProto converts State into protobuf representation and returns it.
 func (s *State) ToProto() (*pb.State, error) {
 	// Avoid timestamppb.New allocation by constructing inline.