shot4

Author: alpe

block/internal/executing/executor.go

@@ -90,6 +90,9 @@ type Executor struct {
 	cachedPubKey        crypto.PubKey
 	cachedValidatorHash types.Hash
 	signerInfoCached    bool
+
+	// cachedChainID avoids per-block allocation in RetrieveBatch
+	cachedChainID []byte
 }
 
 // NewExecutor creates a new block executor.
@@ -152,6 +155,7 @@ func NewExecutor(
 		txNotifyCh:        make(chan struct{}, 1),
 		errorCh:           errorCh,
 		logger:            logger.With().Str("component", "executor").Logger(),
+		cachedChainID:     []byte(genesis.ChainID),
 	}
 	e.blockProducer = e
 	return e, nil
@@ -608,7 +612,7 @@ func (e *Executor) ProduceBlock(ctx context.Context) error {
 // RetrieveBatch gets the next batch of transactions from the sequencer.
 func (e *Executor) RetrieveBatch(ctx context.Context) (*BatchData, error) {
 	req := coresequencer.GetNextBatchRequest{
-		Id:            []byte(e.genesis.ChainID),
+		Id:            e.cachedChainID,
 		MaxBytes:      common.DefaultMaxBlobSize,
 		LastBatchData: [][]byte{}, // Can be populated if needed for sequencer context
 	}

execution/evm/engine_rpc_client.go

@@ -19,7 +19,7 @@ func NewEngineRPCClient(client *rpc.Client) EngineRPCClient {
 	return &engineRPCClient{client: client}
 }
 
-func (e *engineRPCClient) ForkchoiceUpdated(ctx context.Context, state engine.ForkchoiceStateV1, args map[string]any) (*engine.ForkChoiceResponse, error) {
+func (e *engineRPCClient) ForkchoiceUpdated(ctx context.Context, state engine.ForkchoiceStateV1, args interface{}) (*engine.ForkChoiceResponse, error) {
 	var result engine.ForkChoiceResponse
 	err := e.client.CallContext(ctx, &result, "engine_forkchoiceUpdatedV3", state, args)
 	if err != nil {

execution/evm/engine_rpc_tracing.go

@@ -26,7 +26,7 @@ func withTracingEngineRPCClient(inner EngineRPCClient) EngineRPCClient {
 	}
 }
 
-func (t *tracedEngineRPCClient) ForkchoiceUpdated(ctx context.Context, state engine.ForkchoiceStateV1, args map[string]any) (*engine.ForkChoiceResponse, error) {
+func (t *tracedEngineRPCClient) ForkchoiceUpdated(ctx context.Context, state engine.ForkchoiceStateV1, args interface{}) (*engine.ForkChoiceResponse, error) {
 	ctx, span := t.tracer.Start(ctx, "Engine.ForkchoiceUpdated",
 		trace.WithAttributes(
 			attribute.String("method", "engine_forkchoiceUpdatedV3"),

execution/evm/execution.go

@@ -152,7 +152,7 @@ func retryWithBackoffOnPayloadStatus(ctx context.Context, fn func() error, maxRe
 // EngineRPCClient abstracts Engine API RPC calls for tracing and testing.
 type EngineRPCClient interface {
 	// ForkchoiceUpdated updates the forkchoice state and optionally starts payload building.
-	ForkchoiceUpdated(ctx context.Context, state engine.ForkchoiceStateV1, args map[string]any) (*engine.ForkChoiceResponse, error)
+	ForkchoiceUpdated(ctx context.Context, state engine.ForkchoiceStateV1, args interface{}) (*engine.ForkChoiceResponse, error)
 
 	// GetPayload retrieves a previously requested execution payload.
 	GetPayload(ctx context.Context, payloadID engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error)
@@ -396,7 +396,16 @@ func (c *EngineClient) ExecuteTxs(ctx context.Context, txs [][]byte, blockHeight
 	}
 
 	// 2. Prepare payload attributes
-	txsPayload := c.filterTransactions(txs)
+	// Use zero-alloc struct instead of map to avoid reflection overhead
+	evPayloadAttrs := PayloadAttributesV3{
+		Timestamp:             timestamp.Unix(),
+		PrevRandao:            c.derivePrevRandao(blockHeight).Hex(),
+		SuggestedFeeRecipient: c.feeRecipient.Hex(),
+		Withdrawals:           emptyWithdrawals,
+		ParentBeaconBlockRoot: zeroHashHex,
+		Transactions:          PayloadTransactions(txs),
+		GasLimit:              prevGasLimit,
+	}
 
 	// Cache parent block hash for safe-block lookups.
 	c.cacheBlockHash(blockHeight-1, prevBlockHash)
@@ -411,20 +420,6 @@ func (c *EngineClient) ExecuteTxs(ctx context.Context, txs [][]byte, blockHeight
 	}
 	c.mu.Unlock()
 
-	// update forkchoice to get the next payload id
-	evPayloadAttrs := map[string]any{
-		// Standard Ethereum payload attributes (flattened) - using camelCase as expected by JSON
-		"timestamp":             timestamp.Unix(),
-		"prevRandao":            c.derivePrevRandao(blockHeight),
-		"suggestedFeeRecipient": c.feeRecipient,
-		"withdrawals":           emptyWithdrawals,
-		// V3 requires parentBeaconBlockRoot
-		"parentBeaconBlockRoot": zeroHashHex, // Use zero hash for evolve
-		// evolve-specific fields
-		"transactions": txsPayload,
-		"gasLimit":     prevGasLimit, // Use camelCase to match JSON conventions
-	}
-
 	c.logger.Debug().
 		Uint64("height", blockHeight).
 		Int("tx_count", len(txs)).
@@ -874,20 +869,6 @@ func (c *EngineClient) reconcileExecutionAtHeight(ctx context.Context, height ui
 	return nil, nil, false, nil
 }
 
-// filterTransactions formats transactions for the payload.
-// DA transactions should already be filtered via FilterTxs before reaching here.
-// Mempool transactions are already validated when added to mempool.
-func (c *EngineClient) filterTransactions(txs [][]byte) []string {
-	validTxs := make([]string, 0, len(txs))
-	for _, tx := range txs {
-		if len(tx) == 0 {
-			continue
-		}
-		validTxs = append(validTxs, "0x"+hex.EncodeToString(tx))
-	}
-	return validTxs
-}
-
 // GetExecutionInfo returns current execution layer parameters.
 func (c *EngineClient) GetExecutionInfo(ctx context.Context) (execution.ExecutionInfo, error) {
 	if cached := c.cachedExecutionInfo.Load(); cached != nil {
@@ -1170,3 +1151,77 @@ func getAuthToken(jwtSecret []byte) (string, error) {
 	}
 	return authToken, nil
 }
+
+// PayloadAttributesV3 replaces the untyped map for better performance (no reflection)
+type PayloadAttributesV3 struct {
+	Timestamp             int64               `json:"timestamp"`
+	PrevRandao            string              `json:"prevRandao"`
+	SuggestedFeeRecipient string              `json:"suggestedFeeRecipient"`
+	Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+	ParentBeaconBlockRoot string              `json:"parentBeaconBlockRoot"`
+	Transactions          PayloadTransactions `json:"transactions"`
+	GasLimit              uint64              `json:"gasLimit"`
+}
+
+// PayloadTransactions implements custom JSON marshaling to avoid intermediate string allocations.
+type PayloadTransactions [][]byte
+
+// MarshalJSON encodes transactions as a JSON array of hex strings directly to bytes.
+func (txs PayloadTransactions) MarshalJSON() ([]byte, error) {
+	if len(txs) == 0 {
+		return []byte("[]"), nil
+	}
+
+	// Pre-calculate full size to perform a single allocation:
+	// 2 bytes for [] + (len(txs)-1) commas + per tx: 2 quotes + 2 prefix + hex len
+	size := 2
+	count := 0
+	for _, tx := range txs {
+		if len(tx) == 0 {
+			continue
+		}
+		// comma
+		if count > 0 {
+			size++
+		}
+		// "0x..."
+		size += 4 + hex.EncodedLen(len(tx))
+		count++
+	}
+
+	if count == 0 {
+		return []byte("[]"), nil
+	}
+
+	buf := make([]byte, 0, size)
+	buf = append(buf, '[')
+	written := 0
+	for _, tx := range txs {
+		if len(tx) == 0 {
+			continue
+		}
+		if written > 0 {
+			buf = append(buf, ',')
+		}
+		buf = append(buf, '"', '0', 'x')
+
+		// Append encoded hex directly
+		n := hex.EncodedLen(len(tx))
+		start := len(buf)
+		// Ensure capacity
+		if cap(buf) < start+n {
+			// grow logic if needed, but make() with exact size should cover it
+			newBuf := make([]byte, len(buf), start+n*2)
+			copy(newBuf, buf)
+			buf = newBuf
+		}
+		// Expand length
+		buf = buf[:start+n]
+		hex.Encode(buf[start:], tx)
+
+		buf = append(buf, '"')
+		written++
+	}
+	buf = append(buf, ']')
+	return buf, nil
+}

execution/evm/payload_test.go

@@ -0,0 +1,101 @@
+package evm
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPayloadTransactionsMarshalJSON(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    [][]byte
+		expected string
+	}{
+		{
+			name:     "empty",
+			input:    [][]byte{},
+			expected: "[]",
+		},
+		{
+			name:     "nil",
+			input:    nil,
+			expected: "[]",
+		},
+		{
+			name: "single tx",
+			input: [][]byte{
+				{0x01, 0x02, 0x03},
+			},
+			expected: `["0x010203"]`,
+		},
+		{
+			name: "multiple txs",
+			input: [][]byte{
+				{0xaa, 0xbb},
+				{0xcc, 0xdd},
+			},
+			expected: `["0xaabb","0xccdd"]`,
+		},
+		{
+			name: "skip empty tx",
+			input: [][]byte{
+				{0x01},
+				{},
+				{0x02},
+			},
+			expected: `["0x01","0x02"]`,
+		},
+		{
+			name: "all empty",
+			input: [][]byte{
+				{},
+				{},
+			},
+			expected: "[]",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pt := PayloadTransactions(tt.input)
+			b, err := pt.MarshalJSON()
+			require.NoError(t, err)
+			require.Equal(t, tt.expected, string(b))
+		})
+	}
+}
+
+func BenchmarkPayloadTransactionsMarshalJSON(b *testing.B) {
+	// Setup large payload
+	txs := make([][]byte, 1000)
+	for i := range txs {
+		txs[i] = make([]byte, 1024) // 1KB tx
+	}
+	pt := PayloadTransactions(txs)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = pt.MarshalJSON()
+	}
+}
+
+func BenchmarkStandardJSONMarshal(b *testing.B) {
+	// Setup large payload
+	txs := make([][]byte, 1000)
+	for i := range txs {
+		txs[i] = make([]byte, 1024) // 1KB tx
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		// Simulate old behavior: allocate strings + json marshal
+		validTxs := make([]string, 0, len(txs))
+		for _, tx := range txs {
+			validTxs = append(validTxs, hexutil.Encode(tx))
+		}
+		_, _ = json.Marshal(validTxs)
+	}
+}