feat: introduce EVM contract benchmarking with new tests and a GitHub Actions workflow.

Author: alpe

.github/workflows/benchmark.yml

@@ -0,0 +1,42 @@
+---
+name: Benchmarks
+permissions: {}
+"on":
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  evm-benchmark:
+    name: EVM Contract Benchmark
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: write
+      issues: write
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Set up Go
+        uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5.5.0
+        with:
+          go-version-file: ./go.mod
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3.10.0
+      - name: Build binaries
+        run: make build-evm build-da
+      - name: Run EVM benchmarks
+        run: |
+          cd test/e2e && go test -tags evm -bench=. -benchmem -run='^$' \
+            -timeout=10m --evm-binary=../../build/evm | tee output.txt
+      - name: Store benchmark result
+        uses: benchmark-action/github-action-benchmark@4bdcce38c94cec68da58d012ac24b7b1155efe8b # v1.20.7
+        with:
+          name: EVM Contract Roundtrip
+          tool: 'go'
+          output-file-path: test/e2e/output.txt
+          auto-push: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          alert-threshold: '150%'
+          fail-on-alert: true
+          comment-on-alert: true

execution/evm/test/test_helpers.go

@@ -18,6 +18,8 @@ import (
 	"github.com/celestiaorg/tastora/framework/types"
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 // Test-scoped Docker client/network mapping to avoid conflicts between tests
@@ -39,7 +41,7 @@ func randomString(n int) string {
 }
 
 // getTestScopedDockerSetup returns a Docker client and network ID that are scoped to the specific test.
-func getTestScopedDockerSetup(t *testing.T) (types.TastoraDockerClient, string) {
+func getTestScopedDockerSetup(t testing.TB) (types.TastoraDockerClient, string) {
 	t.Helper()
 
 	testKey := t.Name()
@@ -59,13 +61,22 @@ func getTestScopedDockerSetup(t *testing.T) (types.TastoraDockerClient, string)
 }
 
 // SetupTestRethNode creates a single Reth node for testing purposes.
-func SetupTestRethNode(t *testing.T) *reth.Node {
+func SetupTestRethNode(t testing.TB) *reth.Node {
 	t.Helper()
 	ctx := context.Background()
 
 	dockerCli, dockerNetID := getTestScopedDockerSetup(t)
 
-	n, err := reth.NewNodeBuilderWithTestName(t, fmt.Sprintf("%s-%s", t.Name(), randomString(6))).
+	testName := fmt.Sprintf("%s-%s", t.Name(), randomString(6))
+	logger := zap.NewNop()
+	if testing.Verbose() {
+		logger = zaptest.NewLogger(t)
+	}
+	n, err := new(reth.NodeBuilder).
+		WithTestName(testName).
+		WithLogger(logger).
+		WithImage(reth.DefaultImage()).
+		WithBin("ev-reth").
 		WithDockerClient(dockerCli).
 		WithDockerNetworkID(dockerNetID).
 		WithGenesis([]byte(reth.DefaultEvolveGenesisJSON())).
@@ -88,7 +99,7 @@ func SetupTestRethNode(t *testing.T) *reth.Node {
 }
 
 // waitForRethContainer waits for the Reth container to be ready by polling the provided endpoints with JWT authentication.
-func waitForRethContainer(t *testing.T, jwtSecret, ethURL, engineURL string) error {
+func waitForRethContainer(t testing.TB, jwtSecret, ethURL, engineURL string) error {
 	t.Helper()
 	client := &http.Client{Timeout: 100 * time.Millisecond}
 	timer := time.NewTimer(30 * time.Second)

execution/evm/test_helpers.go

@@ -16,7 +16,7 @@ import (
 // Transaction Helpers
 
 // GetRandomTransaction creates and signs a random Ethereum legacy transaction using the provided private key, recipient, chain ID, gas limit, and nonce.
-func GetRandomTransaction(t *testing.T, privateKeyHex, toAddressHex, chainID string, gasLimit uint64, lastNonce *uint64) *types.Transaction {
+func GetRandomTransaction(t testing.TB, privateKeyHex, toAddressHex, chainID string, gasLimit uint64, lastNonce *uint64) *types.Transaction {
 	t.Helper()
 	privateKey, err := crypto.HexToECDSA(privateKeyHex)
 	require.NoError(t, err)

test/e2e/evm_contract_bench_test.go

@@ -0,0 +1,104 @@
+//go:build evm
+
+package e2e
+
+import (
+	"context"
+	"math/big"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/stretchr/testify/require"
+)
+
+// BenchmarkEvmContractRoundtrip measures the store → retrieve roundtrip latency
+// against a real reth node with a pre-deployed contract.
+//
+// All transaction generation happens during setup. The timed loop exclusively
+// measures: SendTransaction → wait for receipt → eth_call retrieve → verify.
+//
+// Run with (after building local-da and evm binaries):
+//
+//	PATH="/path/to/binaries:$PATH" go test -tags evm \
+//	  -bench BenchmarkEvmContractRoundtrip -benchmem -benchtime=5x \
+//	  -run='^$' -timeout=10m --evm-binary=/path/to/evm .
+func BenchmarkEvmContractRoundtrip(b *testing.B) {
+	workDir := b.TempDir()
+	sequencerHome := filepath.Join(workDir, "evm-bench-sequencer")
+
+	client, _, cleanup := setupTestSequencer(b, sequencerHome)
+	defer cleanup()
+
+	ctx := b.Context()
+	privateKey, err := crypto.HexToECDSA(TestPrivateKey)
+	require.NoError(b, err)
+	chainID, ok := new(big.Int).SetString(DefaultChainID, 10)
+	require.True(b, ok)
+	signer := types.NewEIP155Signer(chainID)
+
+	// Deploy contract once during setup.
+	contractAddr, nonce := deployContract(b, ctx, client, StorageContractBytecode, 0, privateKey, chainID)
+
+	// Pre-build signed store(42) transactions for all iterations.
+	storeData, err := hexutil.Decode("0x000000000000000000000000000000000000000000000000000000000000002a")
+	require.NoError(b, err)
+
+	const maxIter = 1024
+	signedTxs := make([]*types.Transaction, maxIter)
+	for i := range maxIter {
+		tx := types.NewTx(&types.LegacyTx{
+			Nonce:    nonce + uint64(i),
+			To:       &contractAddr,
+			Value:    big.NewInt(0),
+			Gas:      500000,
+			GasPrice: big.NewInt(30000000000),
+			Data:     storeData,
+		})
+		signedTxs[i], err = types.SignTx(tx, signer, privateKey)
+		require.NoError(b, err)
+	}
+
+	expected := common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000002a").Bytes()
+	callMsg := ethereum.CallMsg{To: &contractAddr, Data: []byte{}}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	var i int
+	for b.Loop() {
+		require.Less(b, i, maxIter, "increase maxIter for longer benchmark runs")
+
+		// 1. Submit pre-signed store(42) transaction.
+		err = client.SendTransaction(ctx, signedTxs[i])
+		require.NoError(b, err)
+
+		// 2. Wait for inclusion.
+		waitForReceipt(b, ctx, client, signedTxs[i].Hash())
+
+		// 3. Retrieve and verify.
+		result, err := client.CallContract(ctx, callMsg, nil)
+		require.NoError(b, err)
+		require.Equal(b, expected, result, "retrieve() should return 42")
+
+		i++
+	}
+}
+
+// waitForReceipt polls for a transaction receipt until it is available.
+func waitForReceipt(t testing.TB, ctx context.Context, client *ethclient.Client, txHash common.Hash) *types.Receipt {
+	t.Helper()
+	var receipt *types.Receipt
+	var err error
+	require.Eventually(t, func() bool {
+		receipt, err = client.TransactionReceipt(ctx, txHash)
+		return err == nil && receipt != nil
+	}, 2*time.Second, 50*time.Millisecond, "transaction %s not included", txHash.Hex())
+	return receipt
+}

test/e2e/evm_contract_e2e_test.go

@@ -240,7 +240,7 @@ func TestEvmContractEvents(t *testing.T) {
 
 // setupTestSequencer sets up a single sequencer node for testing.
 // Returns the ethclient, genesis hash, and a cleanup function.
-func setupTestSequencer(t *testing.T, homeDir string) (*ethclient.Client, string, func()) {
+func setupTestSequencer(t testing.TB, homeDir string) (*ethclient.Client, string, func()) {
 	sut := NewSystemUnderTest(t)
 
 	genesisHash, seqEthURL := setupSequencerOnlyTest(t, sut, homeDir)
@@ -257,7 +257,7 @@ func setupTestSequencer(t *testing.T, homeDir string) (*ethclient.Client, string
 
 // deployContract helps deploy a contract and waits for its inclusion.
 // Returns the deployed contract address and the next nonce.
-func deployContract(t *testing.T, ctx context.Context, client *ethclient.Client, bytecodeStr string, nonce uint64, privateKey *ecdsa.PrivateKey, chainID *big.Int) (common.Address, uint64) {
+func deployContract(t testing.TB, ctx context.Context, client *ethclient.Client, bytecodeStr string, nonce uint64, privateKey *ecdsa.PrivateKey, chainID *big.Int) (common.Address, uint64) {
 	bytecode, err := hexutil.Decode("0x" + bytecodeStr)
 	require.NoError(t, err)
 

test/e2e/evm_test_common.go

@@ -55,7 +55,7 @@ func getAvailablePort() (int, net.Listener, error) {
 }
 
 // same as getAvailablePort but fails test if not successful
-func mustGetAvailablePort(t *testing.T) int {
+func mustGetAvailablePort(t testing.TB) int {
 	t.Helper()
 	port, listener, err := getAvailablePort()
 	require.NoError(t, err)
@@ -221,7 +221,7 @@ const (
 // createPassphraseFile creates a temporary passphrase file and returns its path.
 // The file is created in the provided directory with secure permissions (0600).
 // If the directory doesn't exist, it will be created with 0755 permissions.
-func createPassphraseFile(t *testing.T, dir string) string {
+func createPassphraseFile(t testing.TB, dir string) string {
 	t.Helper()
 	// Ensure the directory exists
 	err := os.MkdirAll(dir, 0755)
@@ -236,7 +236,7 @@ func createPassphraseFile(t *testing.T, dir string) string {
 // createJWTSecretFile creates a temporary JWT secret file and returns its path.
 // The file is created in the provided directory with secure permissions (0600).
 // If the directory doesn't exist, it will be created with 0755 permissions.
-func createJWTSecretFile(t *testing.T, dir, jwtSecret string) string {
+func createJWTSecretFile(t testing.TB, dir, jwtSecret string) string {
 	t.Helper()
 	// Ensure the directory exists
 	err := os.MkdirAll(dir, 0755)
@@ -256,7 +256,7 @@ func createJWTSecretFile(t *testing.T, dir, jwtSecret string) string {
 // - rpcPort: Optional RPC port to use (if empty, uses default port)
 //
 // Returns: The full P2P address (e.g., /ip4/127.0.0.1/tcp/7676/p2p/12D3KooW...)
-func getNodeP2PAddress(t *testing.T, sut *SystemUnderTest, nodeHome string, rpcPort ...string) string {
+func getNodeP2PAddress(t testing.TB, sut *SystemUnderTest, nodeHome string, rpcPort ...string) string {
 	t.Helper()
 
 	// Build command arguments
@@ -313,7 +313,7 @@ func getNodeP2PAddress(t *testing.T, sut *SystemUnderTest, nodeHome string, rpcP
 // - jwtSecret: JWT secret for authenticating with EVM engine
 // - genesisHash: Hash of the genesis block for chain validation
 // - endpoints: TestEndpoints struct containing unique port assignments
-func setupSequencerNode(t *testing.T, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
+func setupSequencerNode(t testing.TB, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
 	t.Helper()
 
 	// Create passphrase file
@@ -357,7 +357,7 @@ func setupSequencerNode(t *testing.T, sut *SystemUnderTest, sequencerHome, jwtSe
 // setupSequencerNodeLazy initializes and starts the sequencer node in lazy mode.
 // In lazy mode, blocks are only produced when transactions are available,
 // not on a regular timer.
-func setupSequencerNodeLazy(t *testing.T, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
+func setupSequencerNodeLazy(t testing.TB, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
 	t.Helper()
 
 	// Create passphrase file
@@ -417,7 +417,7 @@ func setupSequencerNodeLazy(t *testing.T, sut *SystemUnderTest, sequencerHome, j
 // - genesisHash: Hash of the genesis block for chain validation
 // - sequencerP2PAddress: P2P address of the sequencer node to connect to
 // - endpoints: TestEndpoints struct containing unique port assignments
-func setupFullNode(t *testing.T, sut *SystemUnderTest, fullNodeHome, sequencerHome, fullNodeJwtSecret, genesisHash, sequencerP2PAddress string, endpoints *TestEndpoints) {
+func setupFullNode(t testing.TB, sut *SystemUnderTest, fullNodeHome, sequencerHome, fullNodeJwtSecret, genesisHash, sequencerP2PAddress string, endpoints *TestEndpoints) {
 	t.Helper()
 
 	// Initialize full node
@@ -478,7 +478,7 @@ var globalNonce uint64 = 0
 //
 // This is used in full node sync tests to verify that both nodes
 // include the same transaction in the same block number.
-func submitTransactionAndGetBlockNumber(t *testing.T, sequencerClients ...*ethclient.Client) (common.Hash, uint64) {
+func submitTransactionAndGetBlockNumber(t testing.TB, sequencerClients ...*ethclient.Client) (common.Hash, uint64) {
 	t.Helper()
 
 	// Submit transaction to sequencer EVM with unique nonce
@@ -512,7 +512,7 @@ func submitTransactionAndGetBlockNumber(t *testing.T, sequencerClients ...*ethcl
 // - daPort: optional DA port to use (if empty, uses default)
 //
 // Returns: jwtSecret, fullNodeJwtSecret (empty if needsFullNode=false), genesisHash
-func setupCommonEVMTest(t *testing.T, sut *SystemUnderTest, needsFullNode bool, _ ...string) (string, string, string, *TestEndpoints) {
+func setupCommonEVMTest(t testing.TB, sut *SystemUnderTest, needsFullNode bool, _ ...string) (string, string, string, *TestEndpoints) {
 	t.Helper()
 
 	// Reset global nonce for each test to ensure clean state
@@ -570,7 +570,7 @@ func setupCommonEVMTest(t *testing.T, sut *SystemUnderTest, needsFullNode bool,
 // - blockHeight: Height of the block to retrieve (use nil for latest)
 //
 // Returns: block hash, state root, transaction count, block number, and error
-func checkBlockInfoAt(t *testing.T, ethURL string, blockHeight *uint64) (common.Hash, common.Hash, int, uint64, error) {
+func checkBlockInfoAt(t testing.TB, ethURL string, blockHeight *uint64) (common.Hash, common.Hash, int, uint64, error) {
 	t.Helper()
 
 	ctx := context.Background()
@@ -613,7 +613,7 @@ func checkBlockInfoAt(t *testing.T, ethURL string, blockHeight *uint64) (common.
 // - nodeHome: Directory path for sequencer node data
 //
 // Returns: genesisHash for the sequencer
-func setupSequencerOnlyTest(t *testing.T, sut *SystemUnderTest, nodeHome string) (string, string) {
+func setupSequencerOnlyTest(t testing.TB, sut *SystemUnderTest, nodeHome string) (string, string) {
 	t.Helper()
 
 	// Use common setup (no full node needed)
@@ -635,7 +635,7 @@ func setupSequencerOnlyTest(t *testing.T, sut *SystemUnderTest, nodeHome string)
 // - sequencerHome: Directory path for sequencer node data
 // - jwtSecret: JWT secret for sequencer's EVM engine authentication
 // - genesisHash: Hash of the genesis block for chain validation
-func restartDAAndSequencer(t *testing.T, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
+func restartDAAndSequencer(t testing.TB, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
 	t.Helper()
 
 	// First restart the local DA
@@ -685,7 +685,7 @@ func restartDAAndSequencer(t *testing.T, sut *SystemUnderTest, sequencerHome, jw
 // - sequencerHome: Directory path for sequencer node data
 // - jwtSecret: JWT secret for sequencer's EVM engine authentication
 // - genesisHash: Hash of the genesis block for chain validation
-func restartDAAndSequencerLazy(t *testing.T, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
+func restartDAAndSequencerLazy(t testing.TB, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string, endpoints *TestEndpoints) {
 	t.Helper()
 
 	// First restart the local DA
@@ -736,7 +736,7 @@ func restartDAAndSequencerLazy(t *testing.T, sut *SystemUnderTest, sequencerHome
 // - sequencerHome: Directory path for sequencer node data
 // - jwtSecret: JWT secret for sequencer's EVM engine authentication
 // - genesisHash: Hash of the genesis block for chain validation
-func restartSequencerNode(t *testing.T, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string) {
+func restartSequencerNode(t testing.TB, sut *SystemUnderTest, sequencerHome, jwtSecret, genesisHash string) {
 	t.Helper()
 
 	// Start sequencer node (without init - node already exists)
@@ -772,7 +772,7 @@ func restartSequencerNode(t *testing.T, sut *SystemUnderTest, sequencerHome, jwt
 // - nodeName: Human-readable name for logging (e.g., "sequencer", "full node")
 //
 // This function ensures that during lazy mode idle periods, no automatic block production occurs.
-func verifyNoBlockProduction(t *testing.T, client *ethclient.Client, duration time.Duration, nodeName string) {
+func verifyNoBlockProduction(t testing.TB, client *ethclient.Client, duration time.Duration, nodeName string) {
 	t.Helper()
 
 	ctx := context.Background()