Directory Map

Prysm’s core node architecture is designed around the beacon chain logic (beacon-chain/core). It handles block production, attestation duties, and the management of validator sets. Its modular architecture includes efficient mechanisms for managing state transitions and block processing under Ethereum 2.0’s Proof-of-Stake design.

Geth’s core node is centered around modules like node/, core/vm/, which manage Ethereum’s execution engine (EVM) and transaction processing. Geth is highly optimized for Proof-of-Work and Proof-of-Stake Ethereum networks, supporting block validation, state transitions, and transaction execution. The modular design of Geth allows for easy scaling and adaptability, particularly as Ethereum has transitioned to Proof-of-Stake.

Lighthouse’s core node functionality (beacon_node/beacon_chain, validator_client) is centered around the beacon chain’s state transition logic and validator client responsibilities. It is optimized for Ethereum 2.0, with highly efficient block processing and validator management, ensuring that validators can propose and attest blocks quickly. Its event-driven design improves efficiency in managing state transitions.

Nethermind’s Nethermind.Core handles the core operations of the Ethereum client, including block processing, EVM (Ethereum Virtual Machine) execution, and transaction validation. The Nethermind.Blockchain module provides mechanisms for chain synchronization, implementing a highly optimized approach for fast syncing and block propagation​.

Teku's core node processes beacon chain logic, managing validators, proposing and attesting blocks using its event-driven architecture. Its efficient design prioritizes compatibility with Ethereum 2.0 specifications, ensuring that the node can seamlessly interact with the beacon chain

The core node in Besu (modules like ethereum/core and evm/) is responsible for block validation, EVM execution, and transaction processing. It integrates with its plugin API, which allows customization of the blockchain behavior by adding new features​.

Nimbus ETH2’s core node (beacon_chain/) is optimized for lightweight and resource-restricted environments. It implements the beacon chain’s block processing logic, validator interactions, and Ethereum’s fork choice rules, ensuring it adheres to the Ethereum 2.0 specifications with minimal resource consumption.

Erigon’s core node is known for its high-performance EVM execution and blockchain handling. It handles execution state with eth/stagedsync to enable efficient block processing, reducing the overhead of synchronization and ensuring rapid state transitions. Erigon’s architecture is built around performance, making it a preferred client for high-throughput environments.

Reth’s core node (crates/node, crates/evm) is written in Rust, with a focus on performance and safety. It optimizes block execution and transaction processing with robust EVM implementations, ensuring efficient handling of Ethereum’s state transitions.

Lodestar’s core node (beacon-node/) handles beacon chain logic, validator management, and state transitions in Ethereum 2.0. It is highly modular, designed with JavaScript/TypeScript for easy integration into Ethereum-based applications.

Prysm’s consensus logic is found in modules like beacon-chain/forkchoice and beacon-chain/operations, which handle validator duties, including fork-choice rule implementation and transaction operations within blocks. Prysm adheres to Ethereum 2.0’s LMD-GHOST (Latest Message Driven – Greediest Heaviest Observed Subtree) fork-choice rule, ensuring accurate chain selection based on validator votes and attestations.

Geth's consensus module (consensus/beacon) provides support for Ethereum’s proof-of-stake beacon chain as well as legacy proof-of-work consensus mechanisms. The beacon chain consensus follows Ethereum 2.0 specifications, enabling validator duties like block proposals, attestations, and managing state roots.

Lighthouse implements Ethereum 2.0’s Proof-of-Stake consensus through modules like beacon_node/operation_pool and beacon_node/fork_choice. It uses the LMD-GHOST algorithm to determine the canonical chain. The operation pool manages validator operations like attestations and block proposals, while ensuring that the chain head is always selected based on validator participation.

The Nethermind.Consensus module covers multiple consensus mechanisms, such as Ethash and Clique, ensuring flexibility for different Ethereum networks. Its modular architecture allows integration of plugins to support additional consensus methods, including the new Merge features for transitioning to Proof of Stake.

Teku supports the Beacon Chain consensus mechanism, using a Proof-of-Stake model based on validator duties. It ensures that validators are synchronized, and blocks are processed in accordance with Ethereum 2.0’s fork choice rule and chain head updates

Besu supports multiple consensus algorithms, such as Proof-of-Authority (PoA) and IBFT, with the ability to add custom consensus mechanisms via its plugin architecture. The consensus/ module encapsulates these algorithms, including its ETH 2.0 upgrade support for proof-of-stake operations.

Nimbus relies on Proof-of-Stake consensus via the beacon_chain/spec, processing validator duties and block attestations. Its lightweight nature makes it particularly effective in managing large-scale validator operations without consuming excessive computing resources.

Erigon supports Ethereum’s Proof-of-Stake consensus with modules like turbo/stages. It manages state transitions and integrates with ETH 2.0’s merge features, enabling smooth execution of block validation and attestation under Ethereum’s beacon chain protocol.

Reth supports Proof-of-Stake consensus mechanisms and integrates Ethereum’s consensus engine via crates/consensus. It implements fork choice rules, processing validator responsibilities while ensuring network consensus is achieved efficiently.

Lodestar focuses on implementing Ethereum 2.0’s beacon chain consensus, utilizing the SSZ (Simple Serialize) encoding for block and validator data structures. Its consensus rules are tightly coupled with Ethereum 2.0’s Proof-of-Stake mode.

Prysm’s networking stack (beacon-chain/p2p, beacon-chain/rpc) implements Ethereum’s DevP2P protocol and gossip-based networks to propagate blocks and attestations. The peer-to-peer networking layer ensures efficient communication between Ethereum nodes, supporting large-scale participation in ETH 2.0 networks. Prysm integrates a variety of network protocols for peer discovery, sync, and message propagation.

Geth’s networking (p2p/, eth/protocols/) uses the Ethereum DevP2P protocol to manage node discovery, block propagation, and transaction exchange. Geth’s networking layer is designed for robust scalability and ensures efficient block synchronization between nodes. It includes a rich RPC interface (rpc/) that provides external APIs for interacting with the network, enabling developers to build on top of Ethereum​.

Lighthouse’s networking stack (beacon_node/lighthouse_network, beacon_node/network) implements peer-to-peer communication via gossip protocols, ensuring that blocks, attestations, and validator data are efficiently propagated across the network. Lighthouse also integrates HTTP and JSON-RPC APIs for developers and external services to interact with the Ethereum network.

Nethermind’s networking stack (Nethermind.Network.Discovery and Nethermind.JsonRpc) integrates robust peer-to-peer communication protocols for Ethereum nodes. This module uses custom RPC implementations and a fast discovery mechanism to facilitate smooth network interactions, enabling quick synchronization and seamless block validation

Teku’s networking stack includes networking services (networking/, data/), which handle peer-to-peer messaging and gossipsub for block propagation and attestation duties. Teku is highly optimized for Ethereum 2.0’s multi-client environment, ensuring compatibility with other Ethereum clients for seamless peer discovery and data exchange

Besu’s networking layer (modules like ethereum/p2p, ethereum/api) ensures robust peer-to-peer connections, efficient message passing, and block syncing through Ethereum’s DevP2P protocol. Besu integrates JSON-RPC services for external communications, providing a flexible interface for Ethereum clients and developers.

Nimbus’ networking modules (e.g., beacon_chain/networking) provide peer-to-peer communication using gossipsub for beacon blocks and attestation gossiping. Its RPC mechanism is designed to integrate efficiently with other clients, ensuring data consistency across the Ethereum 2.0 network​.

Erigon’s networking layer integrates the erigon-lib/downloader and custom RPC interfaces to handle peer-to-peer interactions. It implements high-throughput protocols like turbo-sync to optimize the speed at which nodes share and validate block data across the Ethereum network.

Reth uses a Rust-based peer-to-peer networking module (crates/net) to handle communication across Ethereum nodes. It leverages custom RPC modules and networking protocols for efficient block propagation and node discovery within the Ethereum ecosystem.

Lodestar’s networking (beacon-node/network, reqresp/) is designed to be lightweight and compatible with various networking protocols such as gossipsub for peer discovery and data sharing, ensuring efficient communication across Ethereum’s decentralized network.

The Prysm storage layer is implemented in the beacon-chain/db package. It uses a BoltDB-based key-value store (kv) to persist Ethereum Beacon Node data. Additionally, a separate cache layer is employed for frequent access data.

In Geth, state management revolves around Merkle Patricia Trie stored within the core/state package. The trie structure efficiently maps Ethereum accounts and contract storage, enabling efficient state proofs.

Lighthouse's storage backend leverages consensus/state_processing and a store system for chain data using RocksDB, optimized for performance in reading/writing validator states and chain blocks.

Nethermind utilizes a modular storage architecture, leveraging RocksDB for high-performance data storage. The design allows optimized access patterns, especially during block processing and state synchronization, with features such as trie caching and efficient RLP (Recursive Length Prefix) encoding optimizations.

Teku relies on a file-based storage system optimized for long-term blockchain data retention. It has efficient checkpointing mechanisms that support rapid synchronization with the Ethereum 2.0 chain, ensuring minimal disk usage.

Besu supports both flat file and RocksDB-based storage to handle Ethereum’s account and state data. Its pluggable architecture allows developers to choose the best storage backends based on their use case.

Nimbus uses a highly optimized file-based storage system tailored for resource-constrained environments, such as mobile devices. It focuses on compact data storage while maintaining Ethereum 2.0’s storage requirements.

Erigon is well known for its efficient storage techniques, heavily leveraging RocksDB and optimizing for high-throughput read and write operations. It employs stateful snapshot syncing and minimizes data redundancy during block processing.

Reth utilizes Rust’s efficient storage management techniques, leveraging RocksDB for persistent storage. Its design focuses on fast access patterns to improve block processing and synchronization times.

Lodestar uses LevelDB to handle the beacon chain’s persistent data, designed for Ethereum 2.0. It employs lightweight storage strategies that align with the needs of Ethereum’s beacon chain and validator operations.

Prysm's cryptographic implementation relies on BLS (Boneh–Lynn–Shacham) signatures for securing validator attestations and other consensus-critical operations​.

Geth uses its crypto package for ECDSA-based signature verification, as well as Keccak hashing for transaction signing and block validation

Lighthouse uses its crypto package for BLS signature schemes, which is critical for validator attestations and other cryptographic operations within the Ethereum consensus process

The crypto module of Nethermind includes key management and encryption schemes based on industry-standard algorithms like AES. The cryptography code ensures secure key derivation through KDF (Key Derivation Function) and integration with Ethereum's account storage standards.

Teku’s cryptography uses standard elliptic curve signatures (BLS12-381) for validator operations. It adheres to Ethereum 2.0’s cryptographic standards to secure validator actions and network messages.

Besu employs standard Ethereum cryptographic schemes, including the use of the secp256k1 curve for transaction signatures. Its cryptography module is integrated with its privacy features, ensuring secure transaction processing.

Nimbus supports BLS12-381 signatures for validator operations, following the cryptographic standards of Ethereum 2.0. It prioritizes lightweight cryptography to suit its goal of running on low-resource devices.

Erigon uses standard Ethereum cryptographic algorithms and optimizes cryptographic operations for performance, making it suitable for high-throughput nodes.

Reth employs standard cryptographic operations, including secp256k1 and BLS12-381 signatures for consensus operations. It is designed with Rust’s memory safety features to prevent cryptographic vulnerabilities.

Lodestar integrates the BLS12-381 signature scheme for signing validator messages, adhering to Ethereum 2.0’s cryptographic standards. It emphasizes cross-platform cryptography compatibility by using JavaScript-based libraries like blst.

Prysm uses SSZ (Simple Serialize) for encoding data structures such as blocks and validator states. This is critical for efficient data storage and retrieval, and is heavily referenced in the consensus-types module

Common utilities in Geth for handling chain data include parameters defined in common and params, which hold fundamental constants like gas limits and consensus rules​.

Data structures such as blocks and validator state are serialized using SSZ (Simple Serialize) to meet Ethereum 2.0’s consensus requirements. This serialization is implemented across various consensus-related modules.

Nethermind implements advanced serialization techniques, using JSON and RLP for efficient data encoding. It supports various Ethereum consensus mechanisms, allowing flexible transaction encoding while ensuring compatibility across different Ethereum networks.

Teku has a highly abstracted and modular data structure design. It uses event-driven architectures to manage complex state transitions during Ethereum 2.0 beacon chain operations, ensuring clear separation between the various blockchain layers.

Besu uses an efficient Patricia Merkle Trie structure for managing Ethereum’s state data, ensuring that accounts and smart contracts are efficiently stored and accessed during block execution.

Nimbus is designed with simplicity in mind, favoring minimalistic data structures that reduce overhead while ensuring compatibility with Ethereum 2.0’s consensus and networking layers.

Erigon’s dabugta structures are designed to handle high-scale Ethereum operations, employing an efficient trie structure and RLP encoding for its state and transaction data. It focuses on modularity, allowing rapid customization for various Ethereum network layers.

Reth implements modular, high-performance data structures optimized for Ethereum’s state management, including trie-based storage for managing accounts and smart contracts, and efficient block data processing mechanisms.

Lodestar uses TypeScript-based libraries to handle Ethereum’s complex data structures. It includes efficient representations for blocks, validators, and state transitions, focusing on ease of use for developers and compatibility with the Ethereum 2.0 protocol.