docs: update README to reflect PureEngineClient implementation and usage

- Revise architecture section to introduce the `PureEngineClient` and its compatibility with the Engine API
- Detail how the Eth API is utilized for block information retrieval and transaction execution
- Explain the payload ID management and its significance in transaction processing
- Add new sections on development, testing, and reading genesis information with updated commands

Author: tzdybal

README.md

@@ -1,91 +1,79 @@
-# Architecture
+# Go Execution EVM
 
-```mermaid
-graph LR
-    subgraph Test Environment
-        TestClient[Test Client]
-        MockExecutor[Mock Executor]
-    end
+This repository implements the `execution.Executor` interface from `github.com/rollkit/rollkit/core/execution` (currently on feature branch `feature/exec_api`). It provides a pure Engine API-based execution client for Rollkit.
 
-    subgraph Execution Client
-        EngineAPIExecutionClient
-        subgraph Client Components
-            EthClient[Eth Client]
-            JsonRpcClient[JSON-RPC Client]
-        end
-    end
+## PureEngineClient Implementation
 
-    subgraph Execution Layer
-        Reth[Reth Node]
-        subgraph Reth APIs
-            EngineAPI[Engine API]
-            JsonRPC[JSON-RPC API]
-        end
-    end
+The `PureEngineClient` is a 100% Engine API compatible implementation of the `execution.Executor` interface. It connects to an Ethereum execution client (like Reth) and uses both the Engine API and standard Ethereum JSON-RPC API to execute transactions.
 
-    %% Test Environment Connections
-    TestClient -->|uses| EngineAPIExecutionClient
-    JsonRpcClient -->|test mode| MockExecutor
-
-    %% Execution Client Connections
-    EngineAPIExecutionClient -->|eth calls| EthClient
-    EngineAPIExecutionClient -->|engine calls| JsonRpcClient
-    EthClient -->|eth/net/web3| JsonRPC
-    JsonRpcClient -->|engine api| EngineAPI
-
-    %% Reth Internal Connections
-    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 primary
-    class EthClient,JsonRpcClient,MockExecutor,EngineAPI,JsonRPC secondary
-```
+### How Eth API is Used
 
-The architecture consists of several key components:
+The `PureEngineClient` uses the standard Ethereum JSON-RPC API for:
 
-1. **Execution Client**
+1. Retrieving block information (via `HeaderByNumber`)
+2. Reading the genesis block hash and state root
+3. Getting gas limits and other block parameters
 
-   - `EngineAPIExecutionClient`: Main client interface that implements the Execute interface
-   - `EthClient`: Handles standard Ethereum JSON-RPC calls
-   - `JsonRpcClient`: Handles Engine API calls
+This allows the client to interact with the execution layer for read operations while using the Engine API for write operations.
 
-2. **Execution Layer**
+### PayloadID Storage
 
-   - `Reth Node`: Ethereum execution client
-   - Exposes Engine API and standard JSON-RPC endpoints
+The `PureEngineClient` maintains the `payloadID` between calls:
 
-3. **Test Environment**
-   - `Test Client`: Integration tests
-   - `Mock Executor`: Simulates execution behavior for unit tests
+1. During `InitChain`, a payload ID is obtained from the Engine API via `engine_forkchoiceUpdatedV3`
+2. This payload ID is stored in the client instance as `c.payloadID`
+3. The stored payload ID is used in subsequent calls to `GetTxs` to retrieve the current execution payload
+4. After each `ExecuteTxs` call, a new payload ID is obtained and stored for the next block
 
-## Development
+### Payload as First Transaction
 
-Run RETH in docker:
+The `PureEngineClient` implements a unique approach to transaction execution:
 
-```bash
-cd docker
-docker compose up -d
-```
+1. In `GetTxs`, the entire execution payload is serialized to JSON and returned as the first transaction
+2. In `ExecuteTxs`, this first transaction is deserialized back into an execution payload
+3. The remaining transactions are added to the payload's transaction list
+4. The complete payload is then submitted to the execution client via `engine_newPayloadV3`
 
-Compile `evm-middleware` binary:
+This approach ensures that:
+
+- The execution payload structure is preserved between calls
+- All execution happens within the EVM
+- It's not possible to create a payload outside of the EVM
+- Transactions cannot be selected or ordered outside of the EVM
+
+## Deployment Architecture
+
+```mermaid
+graph LR
+    subgraph Rollkit Binary
+        RollkitCore[Rollkit Core]
+        PureEngineClient[PureEngineClient]
+    end
+
+    %% Connections
+    RollkitCore --> PureEngineClient
+    PureEngineClient -->|Engine API| Reth
+    PureEngineClient -->|Eth API| Reth
 
-```bash
-make build
 ```
 
-Run `evm-middleware` binary:
+## Development and Testing
+
+### Running Reth in Docker
 
 ```bash
-./build/evm-middleware run --jwt-secret $(cat docker/jwttoken/jwt.hex)
+cd docker
+docker compose up -d
 ```
 
-Compile rollkit from `feature/exec_api` branch and run it:
+### Reading Genesis Information
+
+If you've modified the genesis file, you can read the genesis hash and state root using the Ethereum JSON-RPC API:
 
 ```bash
-git checkout feature/exec_api
-go build ./cmd/rollkit
-./rollkit start
+# Get genesis block hash
+curl -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x0", false],"id":1}' http://localhost:8545 | jq -r '.result.hash'
+
+# Get genesis state root
+curl -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x0", false],"id":1}' http://localhost:8545 | jq -r '.result.stateRoot'
 ```