chore: initial EVM Execution Client Implementation

.gitignore

@@ -0,0 +1 @@
+docker/jwttoken/ 

README.md

@@ -0,0 +1,80 @@
+## Architecture
+
+```mermaid
+graph LR
+    subgraph Test Environment
+        TestClient[Test Client]
+        MockExecutor[Mock Executor]
+    end
+
+    subgraph Execution Client
+        EngineAPIExecutionClient
+        subgraph Client Components
+            EthClient[Eth Client]
+            ProxyClient[JSON-RPC Proxy Client]
+        end
+    end
+
+    subgraph Proxy Layer
+        ProxyServer[JSON-RPC Proxy Server]
+    end
+
+    subgraph Execution Layer
+        Reth[Reth Node]
+        subgraph Reth APIs
+            EngineAPI[Engine API]
+            JsonRPC[JSON-RPC API]
+        end
+    end
+
+    %% Test Environment Connections
+    TestClient -->|uses| EngineAPIExecutionClient
+    ProxyServer -->|delegates to| MockExecutor
+
+    %% Execution Client Connections
+    EngineAPIExecutionClient -->|eth calls| EthClient
+    EngineAPIExecutionClient -->|engine calls| ProxyClient
+    EthClient -->|eth/net/web3| JsonRPC
+    ProxyClient -->|forwards requests| ProxyServer
+
+    %% Proxy to Reth Connections
+    ProxyServer -->|authenticated requests| EngineAPI
+    JsonRPC -->|internal| Reth
+    EngineAPI -->|internal| Reth
+
+    %% Styling
+    classDef primary fill:#f9f,stroke:#333,stroke-width:2px
+    classDef secondary fill:#bbf,stroke:#333,stroke-width:1px
+    class EngineAPIExecutionClient,ProxyServer primary
+    class EthClient,ProxyClient,MockExecutor,EngineAPI,JsonRPC secondary
+```
+
+The architecture consists of several key components:
+
+1. **Execution Client**
+
+   - `EngineAPIExecutionClient`: Main client interface
+   - `EthClient`: Handles standard Ethereum JSON-RPC calls
+   - `ProxyClient`: Handles Engine API calls through the proxy
+
+2. **Proxy Layer**
+
+   - `JSON-RPC Proxy Server`: Authenticates and forwards Engine API requests
+   - Handles JWT authentication with Reth
+
+3. **Execution Layer**
+
+   - `Reth Node`: Ethereum execution client
+   - Exposes Engine API and standard JSON-RPC endpoints
+
+4. **Test Environment**
+   - `Test Client`: Integration tests
+   - `Mock Executor`: Simulates execution behavior for unit tests
+
+## Development
+
+```bash
+$ cd docker
+$ docker compose up -d
+$ docker compose down
+```

docker/docker-compose.yml

@@ -0,0 +1,54 @@
+name: "reth"
+
+services:
+  jwt-init:
+    container_name: jwt-init
+    image: alpine
+    volumes:
+      - ./jwttoken:/jwt
+    command: >
+      /bin/sh -c "mkdir -p /jwt && 
+      if [ ! -f /jwt/jwt.hex ]; then 
+        apk add --no-cache openssl &&
+        openssl rand -hex 32 | tr -d '\n' > /jwt/jwt.hex; 
+      fi"
+
+  reth:
+    container_name: reth
+    restart: unless-stopped
+    image: ghcr.io/paradigmxyz/reth
+    depends_on:
+      jwt-init:
+        condition: service_completed_successfully
+    ports:
+      - "9001:9001" # metrics
+      - "30303:30303" # eth/66 peering
+      - "8545:8545" # rpc
+      - "8551:8551" # engine
+    volumes:
+      - mainnet_data:/root/.local/share/reth/mainnet
+      - sepolia_data:/root/.local/share/reth/sepolia
+      - holesky_data:/root/.local/share/reth/holesky
+      - logs:/root/logs
+      - ./jwttoken:/root/jwt:ro
+    pid: host
+    command: >
+      node
+      --chain sepolia
+      --metrics 0.0.0.0:9001
+      --log.file.directory /root/logs
+      --authrpc.addr 0.0.0.0
+      --authrpc.port 8551
+      --authrpc.jwtsecret /root/jwt/jwt.hex
+      --http --http.addr 0.0.0.0 --http.port 8545
+      --http.api "eth,net,web3"
+
+volumes:
+  mainnet_data:
+    driver: local
+  sepolia_data:
+    driver: local
+  holesky_data:
+    driver: local
+  logs:
+    driver: local

execution.go

@@ -0,0 +1,50 @@
+package execution
+
+import (
+	"time"
+
+	execution "github.com/rollkit/go-execution"
+	rollkitTypes "github.com/rollkit/rollkit/types"
+)
+
+type EngineAPIExecutionClient struct {
+	execute execution.Execute
+}
+
+// NewEngineAPIExecutionClient creates a new instance of EngineAPIExecutionClient.
+func NewEngineAPIExecutionClient(execute execution.Execute) (*EngineAPIExecutionClient, error) {
+	return &EngineAPIExecutionClient{
+		execute: execute,
+	}, nil
+}
+
+var _ execution.Execute = (*EngineAPIExecutionClient)(nil)
+
+// InitChain initializes the blockchain with genesis information.
+func (c *EngineAPIExecutionClient) InitChain(
+	genesisTime time.Time,
+	initialHeight uint64,
+	chainID string,
+) (rollkitTypes.Hash, uint64, error) {
+	return c.execute.InitChain(genesisTime, initialHeight, chainID)
+}
+
+// GetTxs retrieves transactions from the transaction pool.
+func (c *EngineAPIExecutionClient) GetTxs() ([]rollkitTypes.Tx, error) {
+	return c.execute.GetTxs()
+}
+
+// ExecuteTxs executes the given transactions and returns the new state root and gas used.
+func (c *EngineAPIExecutionClient) ExecuteTxs(
+	txs []rollkitTypes.Tx,
+	blockHeight uint64,
+	timestamp time.Time,
+	prevStateRoot rollkitTypes.Hash,
+) (rollkitTypes.Hash, uint64, error) {
+	return c.execute.ExecuteTxs(txs, blockHeight, timestamp, prevStateRoot)
+}
+
+// SetFinal marks a block at the given height as final.
+func (c *EngineAPIExecutionClient) SetFinal(blockHeight uint64) error {
+	return c.execute.SetFinal(blockHeight)
+}

execution_test.go

@@ -0,0 +1,162 @@
+package execution
+
+import (
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/rollkit/go-execution-evm/proxy"
+	"github.com/rollkit/go-execution/mocks"
+	proxy_json_rpc "github.com/rollkit/go-execution/proxy/jsonrpc"
+	rollkitTypes "github.com/rollkit/rollkit/types"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	jwtSecretFile = "jwt.hex"
+)
+
+type testEnv struct {
+	server    *httptest.Server
+	jwtSecret string
+	cleanup   func()
+	client    *EngineAPIExecutionClient
+	proxyConf *proxy_json_rpc.Config
+	mockExec  *mocks.MockExecute
+}
+
+func setupTestEnv(t *testing.T) *testEnv {
+	t.Helper()
+
+	tmpDir, err := os.MkdirTemp("", "execution-test-*")
+	require.NoError(t, err)
+
+	cleanup := func() {
+		os.RemoveAll(tmpDir)
+	}
+
+	// setup a proxy config
+	proxyConf := &proxy_json_rpc.Config{
+		DefaultTimeout: 5 * time.Second,
+		MaxRequestSize: 1024 * 1024,
+	}
+
+	// create a mock execute from mocks package
+	mockExec := mocks.NewMockExecute(t)
+
+	// create a proxy server with mock execute
+	server := proxy_json_rpc.NewServer(mockExec, proxyConf)
+	testServer := httptest.NewServer(server)
+
+	// create a proxy client that implements the Execute interface
+	ethURL := "http://localhost:8545"
+	engineURL := "http://localhost:8551"
+	genesisHash := common.HexToHash("0x0")
+	feeRecipient := common.HexToAddress("0x0")
+
+	proxyClient, err := proxy.NewClient(proxyConf, ethURL, engineURL, genesisHash, feeRecipient)
+	require.NoError(t, err)
+
+	err = proxyClient.Start(testServer.URL)
+	require.NoError(t, err)
+
+	// create an execution client with the proxy client
+	client, err := NewEngineAPIExecutionClient(proxyClient)
+	require.NoError(t, err)
+
+	return &testEnv{
+		server:    testServer,
+		jwtSecret: "",
+		cleanup: func() {
+			cleanup()
+			testServer.Close()
+			proxyClient.Stop()
+		},
+		client:    client,
+		proxyConf: proxyConf,
+		mockExec:  mockExec,
+	}
+}
+
+func TestEngineAPIExecutionClient_InitChain(t *testing.T) {
+	env := setupTestEnv(t)
+	defer env.cleanup()
+
+	genesisTime := time.Now().UTC().Truncate(time.Second)
+	initialHeight := uint64(0)
+	chainID := "11155111" // sepolia chain id
+
+	expectedStateRoot := rollkitTypes.Hash{}
+	copy(expectedStateRoot[:], []byte{1, 2, 3})
+	expectedGasLimit := uint64(1000000)
+
+	env.mockExec.On("InitChain", genesisTime, initialHeight, chainID).
+		Return(expectedStateRoot, expectedGasLimit, nil)
+
+	stateRoot, gasLimit, err := env.client.InitChain(genesisTime, initialHeight, chainID)
+	require.NoError(t, err)
+	require.Equal(t, expectedStateRoot, stateRoot)
+	require.Equal(t, expectedGasLimit, gasLimit)
+
+	env.mockExec.AssertExpectations(t)
+}
+
+func TestEngineAPIExecutionClient_GetTxs(t *testing.T) {
+	env := setupTestEnv(t)
+	defer env.cleanup()
+
+	expectedTxs := []rollkitTypes.Tx{[]byte("tx1"), []byte("tx2")}
+	env.mockExec.On("GetTxs").Return(expectedTxs, nil)
+
+	txs, err := env.client.GetTxs()
+	require.NoError(t, err)
+	require.Equal(t, expectedTxs, txs)
+
+	env.mockExec.AssertExpectations(t)
+}
+
+func TestEngineAPIExecutionClient_ExecuteTxs(t *testing.T) {
+	env := setupTestEnv(t)
+	defer env.cleanup()
+
+	blockHeight := uint64(1)
+	timestamp := time.Now().UTC().Truncate(time.Second)
+	prevStateRoot := rollkitTypes.Hash{}
+	copy(prevStateRoot[:], []byte{1, 2, 3})
+	testTx := rollkitTypes.Tx("test transaction")
+
+	expectedStateRoot := rollkitTypes.Hash{}
+	copy(expectedStateRoot[:], []byte{4, 5, 6})
+	expectedGasUsed := uint64(21000)
+
+	env.mockExec.On("ExecuteTxs", []rollkitTypes.Tx{testTx}, blockHeight, timestamp, prevStateRoot).
+		Return(expectedStateRoot, expectedGasUsed, nil)
+
+	stateRoot, gasUsed, err := env.client.ExecuteTxs(
+		[]rollkitTypes.Tx{testTx},
+		blockHeight,
+		timestamp,
+		prevStateRoot,
+	)
+	require.NoError(t, err)
+	require.Equal(t, expectedStateRoot, stateRoot)
+	require.Equal(t, expectedGasUsed, gasUsed)
+
+	env.mockExec.AssertExpectations(t)
+}
+
+func TestEngineAPIExecutionClient_SetFinal(t *testing.T) {
+	env := setupTestEnv(t)
+	defer env.cleanup()
+
+	blockHeight := uint64(1)
+
+	env.mockExec.On("SetFinal", blockHeight).Return(nil)
+
+	err := env.client.SetFinal(blockHeight)
+	require.NoError(t, err)
+
+	env.mockExec.AssertExpectations(t)
+}