Execution Client

An execution client (historically called an Ethereum client) is the software component of a blockchain node that manages the state, processes transactions, and runs smart contract code. Following Ethereum's transition to proof-of-stake, the network's architecture was split into the execution layer and the consensus layer. The execution client is solely responsible for the former, handling the computational workload defined by the Ethereum Virtual Machine (EVM). It receives transactions from users, executes them in a deterministic environment, and updates the global state—comprising account balances and smart contract storage.

The primary function of an execution client is to compute the new state of the blockchain. It does this by taking a set of pending transactions, running them through the EVM, and producing an execution payload. This payload contains the resulting state changes and transaction receipts. Popular execution clients include Geth (Go-Ethereum), Nethermind, Besu, and Erigon. Each implements the same core specifications but with different programming languages and performance optimizations, promoting network resilience and client diversity to prevent a single point of failure.

For the network to finalize blocks, the execution client must work in tandem with a consensus client (like Prysm or Lighthouse). The two clients communicate via a local Engine API. The execution client validates and executes transactions, then passes the execution payload to the consensus client. The consensus client is responsible for block propagation, attestations, and the proof-of-stake consensus mechanism. This separation of concerns, known as the merge, allows each layer to specialize, improving overall network security and enabling future scalability upgrades like danksharding.

Node operators must run both an execution client and a consensus client together to participate in validating the Ethereum network. The execution client requires synchronized access to the full world state and historical data, which demands significant storage and bandwidth. For developers, interacting directly with an execution client via its JSON-RPC API (using methods like eth_sendTransaction or eth_call) is how decentralized applications (dApps) read blockchain state and broadcast new transactions to the network.

An execution client (historically called an Ethereum client) is a node software, such as Geth, Nethermind, or Erigon, that manages the state of the Ethereum Virtual Machine (EVM). Its primary functions are to validate incoming transactions, execute the computational logic defined in smart contracts, and maintain the entire world state—a database of all account balances, contract code, and storage. It processes transactions in the order they appear in a block, updating this global state with each operation. The client also generates an execution payload, which contains the list of transactions and the resulting state changes, ready to be proposed to the network.

The client operates by receiving raw, signed transactions from users via its peer-to-peer (P2P) network. It first performs a series of validity checks, verifying cryptographic signatures, ensuring the sender has sufficient ETH for gas, and checking the transaction nonce. Valid transactions enter the mempool (transaction pool) to await inclusion in a block. When it's time to construct a block, the client selects transactions from its mempool, executes them in sequence within the EVM, and calculates the resulting state root. This process consumes gas, with each computational step having a predefined cost to meter resource usage and prevent infinite loops.

Following Ethereum's transition to proof-of-stake (The Merge), the execution client works in tandem with a consensus client (like Prysm or Lighthouse). The two clients communicate via a local Engine API. The consensus client proposes or attests to the next block, but it requests the execution payload—the actual block body with transactions—from the execution client. This separation of concerns allows the consensus layer to focus on block validation and chain finality while the execution layer handles all state computation. The execution client returns the payload and a proof of its validity, which the consensus client then packages into a beacon block.

Key internal components of an execution client include the EVM interpreter, which runs smart contract bytecode; the state trie, a Merkle Patricia Trie that cryptographically commits to the world state; and the transaction pool logic for managing pending transactions. Execution clients also expose JSON-RPC endpoints (e.g., eth_sendTransaction, eth_getBalance) that allow external applications, wallets, and developers to interact with the blockchain. This interface is how decentralized applications (dApps) query data and submit transactions to the network.

Running an execution client is resource-intensive, as it must store the entire historical state and process all new transactions. To sync, a node can perform a full sync, downloading and executing every block from genesis, or a snap sync, which downloads a recent snapshot of the state and verifies it against block headers. Operators must ensure their client is consistently updated to handle network upgrades (hard forks) and changes to the EVM or transaction types, such as those introduced with EIP-1559 or EIP-4844.

An execution client (historically called an Eth1 client) is the software component in Ethereum's post-Merge architecture responsible for managing the state, processing transactions, and executing smart contracts. It handles the computational workload of the network by running the Ethereum Virtual Machine (EVM). Popular execution clients include Geth, Nethermind, Erigon, and Besu. This client works in tandem with a consensus client (Beacon Node), which is responsible for block proposal and attestation duties under Proof-of-Stake.

The execution client's primary functions are to maintain the world state—a database of all account balances and smart contract storage—and to execute new transactions to update this state. It receives transaction bundles from users, validates them against the current state and consensus rules, and computes the resulting state changes. This process involves executing EVM opcodes, deducting gas fees, and generating execution receipts. The finalized state updates and transaction receipts are then packaged into an execution payload, which is passed to the connected consensus client for inclusion in a new block.

This separation of concerns, formalized by The Merge, creates a more modular and resilient network architecture. The execution and consensus clients communicate via a standardized Engine API, allowing different client software to interoperate. This design mitigates the risk of a single client bug taking down the entire network, as issues are typically contained to one layer. Node operators must run both an execution client and a consensus client together to participate in validating the Ethereum network.