feat: fuzzer benching (#504)

* feat: fuzzer benching

* feat: refactor benchmarks to run agains the conformance node

---------

Co-authored-by: Emanuel Pargov <bamzedev@gmail.com>

Author: danielvladco

tests/integration/traces_bench_test.go

@@ -3,17 +3,19 @@
 package integration
 
 import (
+	"context"
 	"fmt"
+	"net"
 	"os"
 	"path/filepath"
 	"sort"
 	"testing"
 
-	"github.com/eigerco/strawberry/internal/state/serialization"
-	"github.com/eigerco/strawberry/internal/state/serialization/statekey"
-	"github.com/eigerco/strawberry/internal/statetransition"
-	"github.com/eigerco/strawberry/internal/store"
-	"github.com/eigerco/strawberry/pkg/db/pebble"
+	"github.com/stretchr/testify/require"
+
+	"github.com/eigerco/strawberry/internal/block"
+	"github.com/eigerco/strawberry/pkg/conformance"
+	"github.com/eigerco/strawberry/pkg/network/handlers"
 	"github.com/eigerco/strawberry/pkg/serialization/codec/jam"
 )
 
@@ -49,56 +51,58 @@ func BenchmarkTraceFuzzyLight(b *testing.B) {
 	runTracesBenchmark(b, "traces/fuzzy_light")
 }
 
-func runTraceBenchmark(b *testing.B, filename string) {
+func runTraceBenchmark(b *testing.B, conn net.Conn, filename string) {
 	data, err := os.ReadFile(filename)
 	if err != nil {
 		b.Fatalf("failed to read trace file %q: %v", filename, err)
 	}
+	var trace Trace
+	err = jam.Unmarshal(data, &trace)
+	if err != nil {
+		b.Fatalf("failed to unmarshal trace from %q: %v", filename, err)
+	}
 
+	ctx := context.Background()
+	// Serialize Initialize message
+	initMsgBytes, err := jam.Marshal(conformance.NewMessage(conformance.Initialize{
+		Header: block.Header{},
+		State: conformance.State{
+			StateItems: trace.PreState.KeyValues,
+		},
+		Ancestry: conformance.Ancestry{
+			Items: []conformance.AncestryItem{},
+		},
+	}))
+	require.NoError(b, err)
+
+	// Serialize ImportBlock message
+	blockImportMsgBytes, err := jam.Marshal(conformance.NewMessage(conformance.ImportBlock{
+		Block: trace.Block,
+	}))
+	require.NoError(b, err)
+
+	b.ResetTimer() // Wipes the "setup" time and allocations.
+	b.StopTimer()
 	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		db, err := pebble.NewKVStore()
-		if err != nil {
-			b.Fatalf("failed to create pebble KV store: %v", err)
-		}
-
-		trieDB := store.NewTrie(db)
-		chainDB := store.NewChain(db)
-
-		var trace Trace
-		err = jam.Unmarshal(data, &trace)
-		if err != nil {
-			b.Fatalf("failed to unmarshal trace from %q: %v", filename, err)
-		}
-
-		serializedState := map[statekey.StateKey][]byte{}
-		for _, entry := range trace.PreState.KeyValues {
-			serializedState[entry.Key] = entry.Value
-		}
-
-		currentState, err := serialization.DeserializeState(serializedState)
-		if err != nil {
-			b.Fatalf("failed to deserialize state: %v", err)
-		}
-
+		// Create the Initialize message (Prestate)
+		// Send the Initialize message
+		err = handlers.WriteMessageWithContext(ctx, conn, initMsgBytes)
+		require.NoError(b, err)
+		// Read the response to the Initialize message
+		initResponse, err := handlers.ReadMessageWithContext(ctx, conn)
+		require.NoError(b, err)
+		require.NotEmpty(b, initResponse)
+
+		// Only time the import block logic
 		b.StartTimer()
-
-		block := trace.Block
-		err = statetransition.UpdateState(
-			&currentState,
-			block,
-			chainDB,
-			trieDB,
-		)
-		if err != nil {
-			b.Fatalf("failed to update state for block: %v", err)
-		}
-
+		// Send the ImportBlock message
+		err = handlers.WriteMessageWithContext(ctx, conn, blockImportMsgBytes)
+		require.NoError(b, err)
+		// Read the response to the ImportBlock message (StateRoot)
+		importResponse, err := handlers.ReadMessageWithContext(ctx, conn)
+		require.NoError(b, err)
+		require.NotEmpty(b, importResponse)
 		b.StopTimer()
-		err = db.Close()
-		if err != nil {
-			b.Fatalf("failed to close database: %v", err)
-		}
 	}
 }
 
@@ -114,12 +118,80 @@ func runTracesBenchmark(b *testing.B, directory string) {
 
 	sort.Strings(files)
 
+	// Create a connection and first message (PeerInfo)
+	conn, err := net.Dial("unix", "/tmp/jam_target.sock")
+	require.NoError(b, err)
+	defer func() {
+		require.NoError(b, conn.Close())
+	}()
+	msgBytes, err := jam.Marshal(peerInfo)
+	require.NoError(b, err)
+	// Send PeerInfo message
+	ctx := context.Background()
+	err = handlers.WriteMessageWithContext(ctx, conn, msgBytes)
+	require.NoError(b, err)
+	// Read the response
+	response, err := handlers.ReadMessageWithContext(ctx, conn)
+	require.NoError(b, err)
+	require.NotEmpty(b, response)
+	respMsg := &conformance.Message{}
+	err = jam.Unmarshal(response.Content, respMsg)
+	require.NoError(b, err)
+	require.NotNil(b, respMsg)
+
+	data, err := os.ReadFile(filepath.Join(directory, "genesis.bin"))
+	if err != nil {
+		b.Fatalf("failed to genesis.bin: %v", err)
+	}
+	var genesis Genesis
+	err = jam.Unmarshal(data, &genesis)
+	if err != nil {
+		b.Fatalf("failed to genesis.bin: %v", err)
+	}
+	require.NoError(b, err)
+	require.NotEmpty(b, genesis)
+
+	// Create the Initialize message (Prestate)
+	initMessage := conformance.Initialize{
+		Header: genesis.Header,
+		State: conformance.State{
+			StateItems: genesis.State.KeyValues,
+		},
+		Ancestry: conformance.Ancestry{Items: []conformance.AncestryItem{}},
+	}
+	initMsg := conformance.NewMessage(initMessage)
+	initMsgBytes, err := jam.Marshal(initMsg)
+	require.NoError(b, err)
+	// Send the Initialize genesis message
+	err = handlers.WriteMessageWithContext(ctx, conn, initMsgBytes)
+	require.NoError(b, err)
+	// Read the response to the Initialize genesis message
+	initResponse, err := handlers.ReadMessageWithContext(ctx, conn)
+	require.NoError(b, err)
+	require.NotEmpty(b, initResponse)
+
 	for _, file := range files {
 		if filepath.Base(file) == "genesis.bin" {
 			continue // Skip the genesis trace since this is mostly there for reference.
 		}
 		b.Run(filepath.Base(file), func(b *testing.B) {
-			runTraceBenchmark(b, file)
+			runTraceBenchmark(b, conn, file)
 		})
 	}
 }
+
+var peerInfo = conformance.NewMessage(conformance.PeerInfo{
+	FuzzVersion:  1,
+	FuzzFeatures: conformance.FeatureFork,
+	JamVersion: conformance.Version{
+		Major: 0,
+		Minor: 7,
+		Patch: 2,
+	},
+	AppVersion: conformance.Version{
+		Major: 1,
+		Minor: 0,
+		Patch: 0,
+	},
+	Name: []byte("test-node"),
+})