paradigmxyz/reth
Reth
Reth is a modular, high-performance Ethereum execution layer client written in Rust. It serves as a full Ethereum node that syncs, validates, and serves blockchain data, functioning as an archive node implementation, a high-throughput RPC node server, and a snapshot sync tool. The project is built around a modular component architecture that allows assembling custom node behavior by swapping independent Rust crates for consensus, execution, mempool, and networking.
The client distinguishes itself through a staged sync pipeline that downloads headers and bodies online before processing the rest offline, combined with snapshot-based bootstrapping that uses pre-built compressed database snapshots to skip initial sync. It employs static file segmentation to partition blockchain data into immutable files by block range for efficient storage and pruning, and uses sub-pool transaction ordering that separates pending transactions into readiness-based sub-pools sorted by effective tip per gas. The architecture includes an execution extension framework for running persistent futures alongside the node that receive notifications about chain commits, reverts, and reorgs, along with a JWT-authenticated Engine API for secure communication between execution and consensus clients.
The project covers the full scope of Ethereum execution client operations, including blockchain synchronization, transaction execution and validation, block production, peer-to-peer networking, and transaction tracing. It provides comprehensive JSON-RPC API capabilities over HTTP, WebSocket, and IPC with configurable rate limiting, and supports custom RPC method extensions. Storage management includes configurable pruning profiles, static file segmentation, and snapshot downloads for archive, full, or minimal node configurations.
Reth can be installed as a precompiled binary, via Homebrew, or through the Arch User Repository, and supports running nodes on mainnet, testnets, or private test networks with Kurtosis-based deployment.
Features
- Blockchain Archivers - Retains all historical blockchain data from genesis for complete access to past states and transactions.
- Ethereum Execution Clients - Downloads, validates, and applies blocks to maintain an up-to-date copy of the Ethereum state.
- Archive Node Implementations - Serves as a full-history Ethereum archive node that retains all blockchain state from genesis for deep historical queries and analysis.
- Ethereum Execution Client Launchers - Starts and manages an Ethereum execution-layer client that syncs, validates, and serves the chain.
- Blockchain Node Component Architectures - Assembles custom Ethereum node behavior by swapping independent Rust crates for consensus, execution, mempool, and networking.
- Modular Node Assembly - Combines modular Rust components to build a tailored Ethereum-compatible node with custom transaction handling and storage.
- Ethereum Full Node Launchers - Starts the Ethereum execution client and begins syncing and validating the blockchain until interrupted by the user.
- Blockchain State Snapshots - Bootstraps a node's state by downloading pre-built database snapshots to reduce initial sync time.
- Blockchain Historical Data Pruning - Removes sender recovery, transaction lookup, and historical data beyond a configurable retention window.
- Blockchain Block Storages - Persists blocks, state, and receipts in a database and provides query access to them.
- Blockchain Sync Pipelines - Downloads and validates the entire Ethereum blockchain, storing both current and historical state.
- Blockchain State Dump Loaders - Bootstraps a node from a pre-serialized state dump, skipping historical block replay.
- Blockchain Full Snapshot Downloads - Downloads a compressed full snapshot with post-merge transactions and recent state history.
- Blockchain Snapshot Bootstrapping - Starts a node from a pre-built snapshot to skip initial sync and reach the latest block faster.
- Blockchain Node Storage Profiles - Shrinks storage footprint by 30-50% depending on node type using efficient data layouts.
- Blockchain Snapshot Bootstrappers - Downloads pre-built compressed database snapshots to skip initial sync and reach the latest block faster.
- Configurable Full or Archive Node Launches - Launches a node in either full or archive mode, controlling how much historical state is retained during synchronization.
- Ethereum Full Node Launches - Launches the Ethereum execution client to sync, validate, and execute transactions on an EVM-compatible chain.
- Staged Pipeline Full Node Syncs - Syncs and validates the full Ethereum blockchain state using a staged pipeline that downloads headers and bodies online then processes the rest offline.
- Blockchain Data Segment Pruning - Removes specified categories of historical blockchain data like receipts or transaction lookups.
- On-Chain Data Analysis - Exposes a JSON-RPC interface for reading balances, logs, traces, and smart contract state from the local node.
- Remote Snapshot Downloads - Bootstraps nodes by fetching compressed snapshot files from remote sources instead of syncing from genesis.
- State Pruning - Removes old block and state data to reduce storage usage while preserving recent history.
- Ethereum JSON-RPC Methods - Accesses standard Ethereum API methods for querying blockchain state, transactions, and logs.
- Data Pruning - Removes historical blockchain data according to predefined configuration to free storage.
- Segment-Specific Pruning - Removes old transaction, receipt, and state data by configurable block-age or segment rules.
- Ethereum Archive Node Implementations - Stores the complete historical state of the blockchain from genesis for deep historical queries and analysis.
- Node Performance Monitoring - Exposes logs, metrics, and observability endpoints for tracking node health and performance.
- Blockchain Sync Pipelines - Downloads headers and bodies online, then processes the rest offline in sequential stages to minimize bandwidth and sync time.
- Fee-Based Transaction Prioritization - Sorts pending transactions by effective tip per gas to maximize block rewards for miners.
- Mainnet and Testnet Nodes - Starts an Ethereum execution-layer node connected to the public mainnet or any supported test network.
- Custom Ethereum Node Assembly - Assembles and configures a full Ethereum execution node from modular components for custom behavior.
- Modular Node Frameworks - A composable Rust framework for assembling custom Ethereum-compatible nodes with interchangeable consensus, execution, and storage components.
- Mempool Transaction Pools - Pre-computes sender addresses and costs, caches validation data, and structures transactions for efficient ordering.
- Sub-Pool Ordering Strategies - Separates transactions into readiness-based sub-pools sorted by effective tip per gas for block construction.
- High-Throughput RPC Scaling - Handles large volumes of JSON-RPC requests with low latency for staking, MEV, and indexing workloads.
- HTTP Transports - Accepts standard Ethereum JSON-RPC requests over HTTP with configurable port and API namespace selection.
- Self-Hosted JSON-RPC Endpoints - Serves standard Ethereum JSON-RPC methods over HTTP, WebSocket, and IPC for external node interaction.
- Peer Connection Management - Controls inbound and outbound connection limits, scores peer reputation, and handles connection lifecycle.
- Peer-to-Peer Networking Libraries - Manages peer discovery, connections, and gossip for propagating transactions and blocks across the Ethereum network.
- Multi-Protocol Peer Discovery - Discovers Ethereum peers using discv4, discv5, and DNS-based discovery to build network connections.
- EIP-4844 Blob Transaction Support - Implements storage and validation of EIP-4844 blob transactions with dedicated fee and data rules.
- Blockchain Event Streams - Streams real-time blockchain data to clients via WebSocket subscriptions for live updates.
- High-Throughput - A production-grade JSON-RPC server for Ethereum that handles high request volumes with low latency for staking, MEV, and indexing workloads.
- EVM Chain Synchronizations - Synchronizes and validates transactions on any EVM-compatible blockchain.
- Crate-Based Modularization - Assembles custom node behavior by mixing and matching well-tested, documented library components from the project's crate ecosystem.
- Block Production Validations - Constructs new blocks by selecting and ordering transactions from the mempool and sealing with a valid header.
- Blockchain Transaction Execution - Processes and validates Ethereum transactions against the current state to update the ledger.
- Mempool - Validates incoming transactions against sender balance, nonce, gas, size, and signature before pool acceptance.
- Protocol Rule Validations - Validates both transactions and blocks against protocol rules before incorporating them into the chain.
- Transaction and Block Propagation - Broadcasts new transactions and blocks to peers using pooling, deduplication, and bandwidth management.
- Blockchain Execution Extensions - Reth hooks into block processing to run user-defined logic after each block is executed.
- JWT-Authenticated Engine APIs - Secures the Engine API between execution and consensus clients with JWT authentication.
- Execution Payload Generation - Constructs valid block payloads from the transaction pool for proposers to include in the chain.
- Full Block Validations - Verifies complete blocks by executing transactions, applying rewards, and checking post-state roots against protocol rules.
- Blockchain Execution Extensions - Runs persistent futures alongside the node that receive chain commit, revert, and reorg notifications.
- Fork Choice Rules - Applies fork choice rules to select the canonical chain and handles reorganizations when a better chain appears.
- Blockchain Minimal Node Profiles - Applies the most aggressive built-in pruning profile to minimize disk storage requirements.
- State-Transition Execution - Runs transactions and verifies resulting state roots and receipts to confirm correct state changes.
- Transaction Tracing & Debugging - Returns all execution traces for a given block or specific transaction hash.
- Smart Contract Callers - Sends transactions and reads contract state through the node's RPC endpoints for all standard Ethereum interactions.
- RPC Over WebSocket - Maintains persistent bidirectional connections for real-time event subscriptions and push notifications.
- Configurable Retention Profiles - Selects archive, full, minimal, or custom-pruned storage profiles to balance historical data retention against disk usage.
- Direct Database Reads - Reads raw blockchain data directly from the database for high-performance indexing and analysis.
- Blockchain Genesis Initializations - Bootstraps a new chain database by loading the genesis configuration and writing the initial state.
- Raw RLP Data Retrievals - Provides direct access to raw RLP-encoded blockchain data for debugging and low-level inspection.
- Custom Consensus Engine Implementations - Allows replacing the default block validation logic with a custom consensus engine while reusing other node components.
- Downloads from Snapshots - Downloads a compressed state and headers snapshot for validators and constrained environments.
- Archive Snapshots - Downloads a complete compressed archive snapshot with all transactions and indices for RPC providers and researchers.
- Optimized Blockchain Storage Formats - Automatically applies an optimized storage format on fresh syncs to reduce disk consumption.
- Blockchain Static File Segmentation - Controls how blockchain data is split into static files by block range for efficient storage management.
- Per-Segment Retention Policies - Sets per-segment retention policies via configuration files or command-line flags to control historical data retention.
- Block Trait Abstractions - Defines blocks through a trait interface for type-safe, interchangeable implementations.
- Raw Query Interfaces - Provides direct key-based access to raw database values for debugging and inspection.
- Segmented Storage Architectures - Partitions blockchain data into immutable files by block range for efficient storage and pruning.
- Institutional Staking Infrastructures - Powers institutional-grade staking environments trusted by major exchanges and RPC providers for mainnet operation.
- EVM Component Swaps - Provides the ability to swap the EVM component to customize transaction execution and state transitions.
- RPC Method Extensions - Adds new JSON-RPC methods to a running node to expose custom functionality or blockchain data.
- Offline Completion Syncs - Downloads only headers and bodies during the first hours of syncing, then completes the rest offline without requiring a constant internet connection.
- Local Testnet Deployers - Launches an isolated Ethereum network with configurable EL/CL client pairs using Kurtosis.
- Storage Configurations - Configures pruning, static files, and snapshot downloads to balance historical data retention against disk usage.
- IPC Transports - Provides a local-only transport via Unix sockets or Windows named pipes with access to all namespaces.
- Blockchain Event Streams - Streams blockchain notifications to external processes via gRPC for off-chain processing.
- Batch Request Handlers - Groups multiple JSON-RPC calls into a single request to reduce network overhead.
- Custom State Derivers - Derives new state from block execution and reorg events, enabling rollups, bridges, and indexers to react to chain changes.
- Blob Transaction Validations - Verifies EIP-4844 blob transactions during block validation.
- Local Ethereum Network Bootstrappers - Bootstraps a custom isolated Ethereum network for local development and testing.
- Compact Transaction Encodings - Encodes transactions in a compact, type-safe enum format for block construction and propagation.
- Bytecode Retrievals by Hash - Retrieves deployed contract bytecode by its code hash for verification and analysis.
- Historical Transaction Executions - Re-executes historical blocks to reconstruct past state changes for verification and analysis.
- Transaction Replays - Re-executes a past transaction and returns its execution traces for debugging and analysis.
- Request Throttling - Limits request frequency per client to protect node resources and enforce access policies.
- JWT Authentications - Secures Engine API communication between execution and consensus clients using shared JWT secrets.
- Sender Recoveries from Signatures - Derives transaction sender addresses from cryptographic signatures during synchronization.
- Block Header Validations - Checks header fields such as timestamp, gas limit, and extra data against protocol rules before execution.
- Block Body Root Validations - Verifies that transaction, withdrawal, and blob roots in the block body match the header.
- State Root Computations - Computes the cryptographic state root of the latest block for verification and chain integrity.
- Layer-2 Sequencer Builders - Delivers high throughput and fast block times for layer-2 sequencers and MEV block builders.
- Node Runtime Configuration - Reads a TOML configuration file to set networking, storage, and runtime parameters before launch.
- Hypothetical Call Tracers - Executes hypothetical calls against historical or pending block state for trace analysis.
- Safe Block Identification - Records which blocks are finalized and safe according to the consensus protocol.
- Blockchain Block Abstractions - Defines blocks through a trait interface so different implementations remain type-safe and interchangeable.
- OpenTelemetry - Sends logs and trace spans to an OTLP-compatible backend such as Jaeger or Grafana Tempo for distributed tracing analysis.
- Blockchain Trace Generators - Re-executes a block to produce a map of hashed trie nodes and their preimages needed during execution.
- Prometheus Metrics Exporters - Exposes node metrics on an HTTP endpoint for Prometheus to scrape, enabling time-series monitoring of the execution client.
- Historical Account State Retrievals - Retrieves historical account state at a specific transaction point for debugging and analysis.
- Raw Transaction Simulators - Simulates signed transactions and returns execution traces without network broadcast.
- Blockchain Infrastructure - Modular and fast Ethereum protocol implementation.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
