How the Ethereum network works
A compact technical reference: the two-layer architecture, the software that implements it, how time, fees, accounts and staking operate, and what secures the whole arrangement. Figures are approximate as of October 2026; the official developer documentation is the authoritative source.
Two layers, one chain
Since the 2022 Merge, a full Ethereum node consists of two cooperating programs. The execution layer executes transactions, maintains the state of all accounts and contracts, and runs the Ethereum Virtual Machine (EVM). The consensus layer runs the proof-of-stake protocol: it decides which block is canonical at each step and finalizes history. The two sides communicate through a defined interface, and the consensus layer instructs the execution layer to build and validate blocks.
This split is why the transition away from proof-of-work could happen without stopping the chain: a separate beacon chain ran alongside Ethereum from December 2020, and at the Merge the execution layer simply plugged into it.
Client software
Multiple independent implementations exist for each layer; running a minority client is a public good, because a bug in one implementation cannot take down the network.
| Layer | Client | Maintainer | Notes |
|---|---|---|---|
| Execution | Geth | Ethereum Foundation | Go; the most widely used execution client |
| Execution | Nethermind | Nethermind | .NET; strong performance and tooling |
| Execution | Besu | Hyperledger | Java; enterprise-oriented |
| Execution | Reth | Paradigm | Rust; performance-focused, increasingly popular |
| Execution | Erigon | Erigon team | Go; archive-friendly architecture |
| Consensus | Lighthouse | Sigma Prime | Rust |
| Consensus | Prysm | Prysmatic Labs | Go |
| Consensus | Nimbus | Status | Nim; designed for resource-constrained hardware |
| Consensus | Teku | Consensys | Java |
| Consensus | Lodestar | ChainSafe | TypeScript |
Time: slots and epochs
Consensus time is divided into slots of 12 seconds. In each slot the protocol pseudo-randomly selects one validator to propose a block; the others attest to what they see as the head of the chain. 32 slots form an epoch (about 6.4 minutes). Attestations are accumulated, and after two epochs under normal operation a block becomes final: changing it would require burning at least one third of all staked ETH, which is what gives Ethereum's finality its economic weight. In practice, finality arrives roughly 13 minutes after a block is produced.
Gas and fees
Every computation and every byte of storage a transaction touches is measured in a unit called gas, paid for in ETH. Since the 2021 London upgrade (EIP-1559), each block has a gas target, and the base fee adjusts automatically, by up to 12.5% per block, so that usage tracks the target. The base fee is burned, removing that ETH from circulation permanently. Users also set an optional priority fee, a tip that makes inclusion in a busy block more likely.
| Typical operation | Approximate gas | Notes |
|---|---|---|
| Simple ETH transfer | 21,000 | Fixed cost, the unit of comparison |
| ERC-20 token transfer | ~50,000 to 65,000 | Depends on the token contract |
| Token swap on a decentralized exchange | ~100,000 to 300,000 | Routing and pool complexity dominate |
| First-time entry into a lending market | ~150,000 to 400,000 | Subsequent operations are cheaper |
| Same operations on a layer 2 | Fractions of the above | Dramatically cheaper since the 2024 blob upgrade |
Gas prices float with demand; gas costs (the unit counts above) are properties of the operations themselves. Blocks carry a gas limit that validators adjust over time, with the EIP-1559 target set at half the limit.
Accounts and addresses
There are two kinds of accounts. An externally owned account is controlled by a private key, typically held in a wallet. A contract account is a program; it has no private key and acts only when a transaction calls it. Both live in the same address space, are 20 bytes long, and are usually shown in hexadecimal with a checksum (mixed case) that catches typos.
The 2025 Pectra upgrade began blurring the line: EIP-7702 lets a regular account delegate to contract code for a transaction, enabling features such as batched actions, sponsored fees and passkey signing without abandoning the existing address. Smart-contract wallets built on earlier standards (ERC-4337) offer the same class of features as a separate account type.
A transaction's life
A wallet signs a transaction that names a recipient, an amount, a gas allowance, fee parameters and a nonce, a per-account counter that enforces ordering and prevents replays. The signed transaction propagates through a gossip network (the mempool), a block proposer includes it, and executors apply it. If the chain reorganizes around a competing block, transactions simply return to the front of the queue; once two epochs pass, the block containing them is final and cannot be reordered without destroying staked value.
Staking in detail
A validator deposits 32 ETH as its effective balance. Since the 2025 Pectra upgrade, a single validator's effective balance can be consolidated up to 2,048 ETH, so the number of active validators no longer grows in lockstep with the amount staked. Rewards, issued from protocol issuance, currently sit in the rough range of 3 to 4% per year on staked ETH, decreasing as total stake grows; attesters and proposers earn them for correct, timely work.
Failure has graduated consequences. Offline validators leak small amounts until the chain finalizes again. Provable attacks, such as signing two conflicting blocks or constructing surrounding votes, trigger slashing: the validator is forcibly exited and a portion of its stake is burned, growing with the number of co-offenders. Entering and leaving pass through queues that rate-limit change; withdrawals in normal conditions have been possible since the April 2023 Shapella upgrade.
Nodes and access
Anyone can run a node: an execution client plus a consensus client, with options ranging from pruned nodes that keep recent state to archive nodes that keep everything. Running one means verifying the chain yourself rather than trusting a third party, and it is the ordinary way applications query the network over the JSON-RPC interface. Many applications instead use shared RPC providers, which is convenient but reintroduces a trusted intermediary; the ecosystem's long-standing advice is that anything handling significant value should verify against its own node.
What secures the network
Security rests on several redundant props: a very large validator set with no privileged operator, client diversity so no single implementation is load-bearing, economic finality that makes history rewriting cost at least a third of all staked ETH, and an active research and auditing culture with a public bug bounty program for the protocol's critical code. The Ethereum Foundation coordinates some of this work, but it does not own or control the network; upgrades ship only when client teams and stakers adopt them.