paradigmxyz/reth

This system is a Rust-based Ethereum execution client that manages the full lifecycle of blockchain synchronization, from peer discovery and network data fetching to block execution and state persistence. It provides comprehensive tooling for node operation, including modular CLI commands for database maintenance, ERA file import/export, and snapshot downloads, alongside a robust framework for testing and debugging consensus engine interactions. The architecture supports advanced features like parallel transaction execution, sparse trie state management, and configurable pruning, enabling efficient handling of high-gas workloads and complex hardfork logic.

73 changes.

This period focused on establishing the foundational components of the Reth node, including the implementation of the P2P networking stack, database storage with MDBX and RocksDB, and the transaction pool. It also introduced the RPC server architecture, payload building services, and comprehensive test suites to validate these core systems.

125 changes.

This period focused on restructuring the node into a modular, type-safe builder system with comprehensive extension points for RPC, payload building, and execution extensions. Simultaneously, the storage layer was migrated to a v2 layout utilizing static files and RocksDB, introducing new primitives for parallel state-root computation and efficient data access. The work also established robust tooling for debugging, testing, and CLI management to support this new architectural foundation.

67 changes.

This period focused on implementing snap/2 state synchronization via EIP-8189 and introducing comprehensive support for ERA file formats for long-term history storage and export. Significant work also went into parallelizing block access list processing, restructuring the EVM and trie proof systems, and establishing a robust end-to-end testing framework for these new components.

The BSC P2P example now includes a complete block import pipeline for the Parlia consensus engine. This adds a new \block\_import\ module containing a service that receives new blocks from the network, validates them via the engine API, and updates the fork choice state using Parlia-specific canonical head logic. It also introduces a chain specification for BSC mainnet, defining the full list of BSC-specific hardforks (from Ramanujan to Prague) and bootnodes, along with the genesis configuration required to initialize the node.

examples/bsc-p2p · high confidence

The \reth test-vectors\ CLI command is now available with two subcommands: \compact\ and \tables\. The \compact\ subcommand generates random test vectors for types implementing the \Compact\ trait (such as \TransactionSigned\, \Header\, and various EIP types) and validates them by round-tripping serialization; it supports \--write\ to save vectors to \testdata/micro/compact\ and \--read\ to verify them. The \tables\ subcommand generates test vectors for database tables (including \CanonicalHeaders\, \Headers\, \Transactions\, and \DUPSORT\ tables like \PlainStorageState\), saving them as JSON files in \testdata/micro/db\ to ensure correct serialization and sorting behavior for database storage.

_crates/cli/commands/src/test\vectors · high confidence

Users can now export node block history to on-disk ERA files in two formats: \.era1\ and \.ere\. The new \era-utils\ export module provides a generic driver that chunks blocks and delegates to format-specific writers. The \.era1\ writer produces files with block-by-block streaming, accumulators, and block indices. The \.ere\ writer supports pre-merge and post-merge blocks, omitting total difficulty and accumulator for post-merge-only exports, and uses a sectioned layout with slim receipts. Configuration is controlled via \ExportConfig\, allowing specification of output directory, block range, network name, and maximum blocks per file.

crates/era-utils/src/export · high confidence

This change introduces the core type definitions and serialization logic for the \.era1\ file format, enabling the export and import of Ethereum execution layer data. It adds \CompressedHeader\, \CompressedBody\, and \CompressedReceipts\ structs that use Snappy compression and RLP encoding to store block headers, bodies, and receipts, along with \TotalDifficulty\ and \Accumulator\ types. The \Era1Group\ struct manages the file content structure, including a \BlockIndex\ for efficient block lookup, while \Era1Id\ handles file naming conventions with optional block counts. These types are implemented in \crates/era/src/era1/types/\ to align with the e2store format specification.

crates/era/src/era1/types · high confidence

Introduces a new \ethstats\ crate that enables the node to connect to an EthStats monitoring server via WebSocket. The implementation handles authentication, periodic reporting of node statistics (such as block headers, pending transactions, and gas prices), and automatic reconnection logic, allowing external monitoring services to track node health and performance.

crates/node/ethstats · high confidence

A new example application at \examples/exex-test\ has been added to demonstrate and validate Execution Extension (ExEx) behavior. This example sets up a test environment that produces blocks and runs an ExEx to verify that it correctly receives committed chain notifications, observes trie updates, and processes finalization events, providing a concrete sanity check for ExEx integration.

examples/exex-test · high confidence

The chainspec crate now includes a genesis file for the Hoodi testnet (chain ID 560048). This new configuration enables the client to sync and validate blocks on the Hoodi network, which activates the Prague hardfork at timestamp 1742999832 and includes specific blob schedule parameters for both Cancun and Prague.

crates/chainspec · high confidence

Users can now choose LZ4 compression for NippyJar snapshot files in addition to the existing Zstandard support. This change introduces a new \Lz4\ implementation in \crates/storage/nippy-jar/src/compression/lz4.rs\ and updates the \Compressors\ enum in \mod.rs\ to include \Lz4\ as a selectable variant, allowing the snapshot system to leverage LZ4's speed for data compression and decompression.

crates/storage/nippy-jar/src/compression · high confidence

The examples/node-builder-api now includes a new example demonstrating how to configure a node with a NoopNetworkBuilder. This allows users to run an Ethereum node instance without launching a real network, useful for testing or development environments where network connectivity is not required.

examples/node-builder-api · high confidence

Introduces a new \RocksDBBalStore\ implementation for persisting Block Access Lists. This store uses an in-memory buffer for recent entries and persists canonical BALs to RocksDB tables (\BlockAccessLists\ and \BlockAccessListBlockNumbers\) via a flush mechanism. It supports reading legacy databases in read-only mode, pruning old entries based on retention periods, and querying by block hash.

crates/storage/provider/src/bal · high confidence

Users can now verify database integrity using the new \reth db checksum\ CLI command, which supports calculating checksums for MDBX tables, static file segments, and RocksDB tables. This addition includes a dedicated RocksDB implementation that iterates over specific tables (TransactionHashNumbers, AccountsHistory, StoragesHistory) to compute hashes, providing a unified interface for validating both the primary MDBX database and legacy RocksDB storage.

crates/cli/commands/src/db/checksum · high confidence

The \crates/net/downloaders/src/snap\ module now provides dedicated downloaders that fetch and cryptographically verify snap/2 protocol responses. This includes \AccountRangeDownloader\ to verify account data against state roots, \StorageRangeDownloader\ to authenticate storage slots against account storage roots, \BytecodeDownloader\ to verify contract code by hash, and \BlockAccessListDownloader\ to validate block access lists against header commitments defined in EIP-8189. A shared \VerifyingRequest\ infrastructure handles retries, peer attribution, and offloads proof verification to a blocking pool to keep the async runtime responsive.

crates/net/downloaders/src/snap · high confidence

This change introduces a new example application that launches a reth node and subscribes to canonical state notifications to fetch and process EIP-4844 blob sidecars. The example checks the local transaction pool for blob data first, and if unavailable, retrieves it from a configured consensus layer (CL) beacon node HTTP API. It handles both mined and reorged blob transactions, providing a concrete demonstration of integrating with the beacon API for blob sidecar retrieval.

examples/beacon-api-sidecar-fetcher · high confidence

The \examples/beacon-api-sse\ directory now contains a new example application that demonstrates how to subscribe to beacon chain payload attributes events via Server-Sent Events (SSE). This tool connects to a local Consensus Layer client (defaulting to \localhost:5052\), parses the SSE stream to extract \PayloadAttributesEvent\ data, and logs the received events. It includes built-in retry logic for connection errors and stream interruptions, along with unit tests for the SSE parsing logic.

examples/beacon-api-sse · high confidence

The \examples/custom-rlpx-subprotocol\ directory now contains a complete example demonstrating how to extend the network layer with a custom RLPx subprotocol. The code defines a \custom\_rlpx\ capability (version 1, protocol ID 4) with message types for ping, pong, and custom string messages, and implements the necessary \ConnectionHandler\ and \ProtocolHandler\ traits to manage connections and encode/decode traffic. The example launches two node instances, registers the custom protocol on both, establishes a connection between them, and verifies bidirectional message exchange.

examples/custom-auth-http-middleware, examples/custom-beacon-withdrawals, examples/custom-rlpx-subprotocol · high confidence

The \examples/custom-engine-types\ directory now contains a new example demonstrating how to implement the \EngineTypes\ trait with custom payload attributes. This example defines a \CustomPayloadAttributes\ struct that extends standard Ethereum payload attributes with a custom field, implements the \PayloadAttributes\ trait to expose this field, and configures a \CustomEngineValidator\ to handle validation logic for these custom attributes within the engine API.

examples/custom-engine-types · high confidence

The \examples/custom-payload-builder\ directory now contains a complete example demonstrating how to implement and integrate a custom payload builder. It includes a \CustomPayloadBuilder\ component that implements \PayloadServiceBuilder\ to replace the default payload generation logic, an \EmptyBlockPayloadJobGenerator\ that creates jobs for building empty blocks, and an \EmptyBlockPayloadJob\ that resolves immediately. The example shows how to configure the payload job generator with custom intervals and deadlines, and how to register this custom builder within the node's component system via the CLI.

examples/custom-payload-builder · high confidence

The \examples/custom-state-root\ directory now contains a runnable example that demonstrates how to install a custom state-root strategy into a reth node. The example implements a \ZeroStateRootStrategy\ that returns \B256::ZERO\ as the state root for blocks at or above a specified activation timestamp, while delegating to the default strategy for earlier blocks. It shows how to wrap \BasicEngineValidatorBuilder\ to inject this custom strategy via \with\_state\_root\_strategy\ on the engine validator.

examples/custom-state-root · high confidence

A new example application is added that demonstrates how to launch a node and inspect pending transactions using a custom EVM inspector. The example subscribes to the pending transaction pool, filters transactions by recipient address via a CLI argument, and executes them against a dummy inspector that logs opcodes and program counters, providing a reference for building custom transaction tracing tools.

examples/custom-inspector · high confidence

The \crates/era/src/era/types\ module now provides the core data structures for \.era\ files, including \EraGroup\ (which organizes compressed beacon blocks and state), \SlotIndex\ (for slot-based data lookup), and \EraId\ (for file identification). It introduces \CompressedSignedBeaconBlock\ and \CompressedBeaconState\ types that handle Snappy compression with strict size bounds to prevent decompression bombs. Crucially, \CompressedSignedBeaconBlock\ now includes a \decode\_execution\_block\ method that extracts the execution payload from post-merge consensus blocks (Bellatrix through Electra) using \alloy\_rpc\_types\_beacon\, allowing users to access execution data directly from era files without external consensus clients.

crates/era/src/era/types · high confidence

The \eth-wire-types\ crate now includes support for the \GetBlockAccessLists\ and \BlockAccessLists\ message types defined in EIP-7685. This introduces new RLP-encodable structs for requesting and receiving block access lists, including handling for unavailable entries (encoded as empty strings) and raw BAL RLP payloads. The implementation includes custom encoding/decoding logic to ensure interoperability with the devp2p specification.

crates/net/eth-wire-types · high confidence

An example has been added to demonstrate how to launch a node with custom RPC middleware. The example shows how to create a custom middleware layer that intercepts RPC responses and modifies error messages, specifically replacing standard errors with a custom error code and message.

examples/custom-rpc-middleware · high confidence

Introduces \FileClient\ and \ReceiptFileClient\ in the downloaders crate, enabling the import of blockchain data from local files (including gzip-compressed formats) without network connectivity. \FileClient\ buffers headers and bodies from RLP-encoded files, while \ReceiptFileClient\ handles sequential receipt decoding. These components are gated behind the \file-client\ feature flag and include specific metrics for tracking buffered data and download progress.

crates/net/downloaders/src · high confidence

The \reth-payload-validator\ crate now includes dedicated validation modules for the Shanghai, Amsterdam, Cancun, and Prague hardforks. These modules enforce that specific payload fields (such as withdrawals, block access list hashes, blob gas used, and EIP-4844/7702 transactions) are present only when their respective hardforks are active, and absent otherwise, ensuring well-formedness of execution payloads across different network upgrades.

crates/payload/validator · high confidence

The \etc\ directory now provides a complete set of configuration files for running Reth alongside essential observability and testing tools. This includes a \docker-compose.yml\ that orchestrates Reth, Prometheus, Grafana, Loki, and Promtail, along with specific dashboards for metrics (overview, mempool, persistence, state growth, discovery) and an \ethereum-metrics-exporter\ configuration. Additionally, an \assertoor-template.yaml\ is added to support integration testing with the Assertoor framework, and a \generate-jwt.sh\ script simplifies JWT token creation for local setups.

etc · high confidence

A new manual P2P example has been added to demonstrate how to manually connect to Ethereum peers and snoop on network traffic. The example uses Discv4 for peer discovery, performs P2P and ETH wire handshakes, and listens for broadcast messages such as new blocks and transaction hashes (versions 66, 68, and 72). It serves as a reference for implementing custom peer-to-peer interactions without relying on higher-level network abstractions.

examples/manual-p2p · high confidence

The new \examples/network-proxy\ example demonstrates how to configure a network node to handle incoming Ethereum requests (such as block headers) and process transaction events (including pooled transaction hashes) using memory-bounded channels. It illustrates a two-peer setup where one node proxies eth requests and the other sends headers and transaction hashes, showcasing the integration of \NetworkManager\ with custom request handlers and transaction event listeners.

examples/network-proxy · high confidence

A new example has been added to demonstrate how to hook into the node lifecycle via the CLI extension mechanism without registering additional arguments. The example launches a standard reth node and prints status messages for key events: 'All components initialized' when components are ready, 'RPC started' when the RPC server is available, and 'Node started' when the node begins operation.

examples/node-event-hooks · high confidence

The \crates/metrics\ library now exposes a new \thread\ module that allows users to measure resource consumption on a per-thread basis. This includes tracking user and system CPU time, page faults, context switches, and block I/O operations via the \ThreadResourceUsage\ API. The implementation uses platform-specific calls (such as \getrusage\ on Linux) to capture these metrics, enabling more granular performance monitoring for thread-bound operations.

crates/metrics/src · high confidence

The \ethereum/hardforks\ crate now includes a new \DisplayHardforks\ type that formats Ethereum hardforks into a structured, human-readable list. This output categorizes forks into pre-merge (block-based), merge (TTD-based), and post-merge (timestamp-based) sections, allowing users to easily view activation conditions and optional metadata for each hardfork.

crates/ethereum/hardforks/src · high confidence

The \EthBuiltPayload\ type in \crates/ethereum/engine-primitives\ now implements conversion methods for the new \ExecutionPayloadEnvelopeV5\ and \ExecutionPayloadEnvelopeV6\ engine API versions. V5 support enables the inclusion of EIP-7594 blob sidecars and execution requests, while V6 adds support for block access lists. To handle these new requirements, a new \BuiltPayloadConversionError\ enum has been introduced to report specific errors such as unexpected sidecar types or missing access lists during conversion.

crates/ethereum/engine-primitives · high confidence

The \testing/testing-utils\ crate now exposes two new modules: \generators\, which provides functions for creating random blockchain data structures such as headers, blocks, transactions, and keypairs (including seeded RNG support for deterministic tests), and \genesis\_allocator\, which simplifies the creation of custom genesis allocations by allowing users to easily add funded accounts with known signers, code, or storage. These utilities are re-exported from the crate's root for convenient access in test suites.

testing/testing-utils · high confidence

An example demonstrating how to define and integrate custom hardforks into a Reth chain specification has been added. It shows how to use the \hardfork!\ macro to create custom variants, configure their activation conditions via genesis extra fields, and implement the necessary traits (\Hardforks\, \EthChainSpec\, \EthereumHardforks\) to ensure compatibility with Reth's chain management system.

examples/custom-hardforks · high confidence

A new systemd service file (reth.service) has been added to the Debian packaging directory. This allows users to easily install and manage the Reth Ethereum node as a system service, configuring it to start after network availability, run with dynamic user privileges, and store state in a dedicated directory.

pkg · high confidence

The \crates/storage/db-api/src/tables\ module now centralizes the definition of all database tables and provides new abstractions for raw data access. The \mod.rs\ file introduces a macro-based system to declare table types, keys, values, and \DupSort\ subkeys, automatically generating a \Tables\ enum and associated marker structs. Additionally, \raw.rs\ adds \RawTable\, \RawDupSort\, \RawKey\, and \RawValue\ types, enabling delayed encoding and decoding of data for scenarios where raw byte access is required.

crates/storage/db-api/src/tables · high confidence

The custom-evm example has been updated to demonstrate how to implement a node with a custom EVM configuration that supports the Prague hardfork. The example now includes a custom EVM factory (\MyEvmFactory\) and executor builder (\MyExecutorBuilder\) that integrate with the \EthEvmConfig\. A key feature is the ability to register custom precompiles specifically for the Prague spec via the \prague\_custom()\ function, which adds a custom precompile to the standard Prague precompiles. The example also configures a test chain spec with Prague activated and launches a node using these custom components.

examples/custom-evm · high confidence

The debug client now includes a new EtherscanBlockProvider that fetches block data via the Etherscan API, supporting chain-id queries and configurable polling intervals. The existing RpcBlockProvider has been updated to support fetching block access list payloads (with an option to disable this), allows larger WebSocket frames (up to 128MB) to handle big blocks, and implements robust reconnection logic for block subscriptions.

crates/consensus/debug-client/src/providers · high confidence

The \reth-rpc-api\ crate now exposes the formal JSON-RPC trait definitions for the \admin\, \anvil\, \debug\, \engine\, \hardhat\, \mev\, \miner\, \net\, \otterscan\, \reth\, \reth\_engine\, \rpc\, \testing\, \trace\, \txpool\, \validation\, and \web3\ namespaces. This change introduces the server and client trait bindings (e.g., \AdminApi\, \EngineApi\, \DebugApi\) that define the method signatures, namespaces, and subscription endpoints for the node's RPC layer, serving as the contract for RPC implementations and clients.

crates/rpc/rpc-api · high confidence

Execution extensions (ExExs) can now catch up to the node's current canonical head if they fall behind, rather than only receiving notifications from the point they were initialized. The \ExExContext\ now exposes a \catch\_up\_notifications\_with\_head\ method that triggers a backfill process to replay historical blocks up to the live head. This ensures ExExs like indexers or bridges can recover state consistency after being paused or restarted without missing recent chain activity.

crates/exex/exex/src · high confidence

The \custom-node-components\ example now shows how to replace the default transaction pool with a custom implementation. Users can see how to implement the \PoolBuilder\ trait to define a custom pool configuration, including setting up validation tasks and spawning maintenance tasks for local transaction backups.

examples/custom-node-components · high confidence

The network layer now features a dedicated \ActiveSession\ struct and \SessionManager\ to handle established peer connections. This change introduces configurable session limits (inbound/outbound pending and active counts) via \SessionCounter\, enforces request timeouts with adaptive scaling, and implements backpressure mechanisms for outgoing messages and broadcast items to prevent resource exhaustion. It also adds support for the \eth/69\ \BlockRangeUpdate\ protocol to track peer block availability ranges, and strengthens security by validating ECIES identities during the handshake to reject spoofed peer IDs.

crates/net/network/src/session · high confidence

The basic payload builder now includes a \BetterPayloadEmitter\ wrapper that emits events for both \Better\ and \Freeze\ payload outcomes, ensuring subscribers receive valid payloads for engine service insertion. Additionally, a \PayloadBuilderStack\ is introduced to allow chaining multiple payload builders in a hierarchical fallback system, supporting nested configurations and unified attribute handling via an \Either\ enum.

crates/payload/basic · high confidence

Adds a new DNS discovery service that implements EIP-1459, allowing the node to discover peers via DNS TXT records. The implementation includes configuration for DNS lookups (timeouts, rate limits, cache size), a resolver layer using hickory-resolver, a query pool for managing concurrent DNS requests, and a tree synchronization engine that walks the DNS tree structure (root, links, branches, nodes) to collect NodeRecords. This enables automatic peer discovery from configured DNS bootstrap links without manual node input.

crates/net/dns · high confidence

The \era\ crate now includes a new \e2s\ module that implements reading and writing of E2Store (\.e2s\) files. This adds specific error handling for file operations, SSZ encoding/decoding, and compression, along with types for version and slot-index records. Users can now utilize the \E2StoreReader\ and \E2StoreWriter\ to interact with this specific file format, enabling the storage and retrieval of era data using the E2Store structure.

crates/era/src/e2s · high confidence

The \era-downloader\ crate now provides an asynchronous stream interface for downloading ERA1 and ERA files. It supports HTTP fetching with SHA-256 checksum verification (using \checksums.txt\ for ERA1) and local directory scanning. The \EraStream\ component manages concurrent downloads, enforces a maximum file count in the target folder, and allows resuming from a specific block index.

crates/era-downloader/src · high confidence

Added the \ere\ module with types and I/O handling for the new ERE file format (based on the e2store specification). This includes \EreFile\, \EreReader\, and \EreBlockTupleIterator\ for reading compressed block headers, bodies, slim receipts, proofs, and total difficulties, along with a \DynamicBlockIndex\ for efficient block lookup. The implementation supports Snappy-compressed RLP encoding for execution layer data structures.

crates/era/src/ere · high confidence

The \reth-exex-types\ crate now provides core types for External Executables (ExEx), including \ExExNotification\ to represent chain state changes (committed, reorged, reverted) with support for bincode serialization, \ExExHead\ to track the highest processed block, and \FinishedExExHeight\ to manage the lowest common finished height across all ExExs for safe block pruning.

crates/exex/types · high confidence

Users can now control the format of execution witnesses via a new \ExecutionWitnessMode\ enum with \Legacy\ (default) and \Canonical\ variants. The \Canonical\ mode aligns with the \ethereum/execution-specs\ draft, producing smaller, lexicographically sorted bytecodes and state nodes by excluding empty nodes and optimizing sibling inclusion for post-state root calculation.

crates/trie/common/src · high confidence

The \reth-trie-common\ crate now exposes a \HashBuilderState\ struct that captures the internal state of the MPT hash builder (including keys, values, stack, and various masks) and implements \Compact\ serialization. This allows the hash builder's progress to be persisted to and restored from the database, enabling stateful construction of Merkle Patricia Tries across restarts or checkpoints.

_crates/trie/common/src/hash\builder · high confidence

This change introduces the \NodeTypes\ trait and associated builder types (\AnyNodeTypes\, \AnyNodeTypesWithEngine\) in the \crates/node/types\ crate, providing a standardized way to configure the essential types of an Ethereum-like node, including primitives, chain specification, storage, and payload types. It also adds \NodeTypesWithDB\ and \NodeTypesWithDBAdapter\ to extend node types with database capabilities, along with helper type aliases (\BlockTy\, \HeaderTy\, \BodyTy\, \TxTy\) for accessing specific primitive types from node configurations.

crates/node/types · high confidence

Added the \tracing-otlp\ crate to enable exporting spans and logs to OpenTelemetry-compatible backends via OTLP. This change introduces configurable tracing layers that support both HTTP and gRPC protocols, allow customizing the service version and trace sampling ratio, and automatically derive authentication headers from the endpoint URL. For span export, the layer is configured to disable location tracking, inactivity tracking, and target attributes to reduce overhead, while log export bridges tracing spans to OTLP logs with full span attribute inclusion.

crates/tracing-otlp · high confidence

A new proof calculation implementation (Proof V2) is added to the trie crate, replacing the legacy approach with a leaf-only proof generator that returns nodes sorted lexicographically by path. This new calculator supports generic value encoding with deferred (including asynchronous) evaluation, allowing storage root computations to be parallelized during account proof generation. It also introduces optimizations such as reusing cursors across calculations, caching branch node hashes to skip sub-tries, and grouping proof targets by sub-trie prefixes to reduce redundant traversal.

_crates/trie/trie/src/proof\v2 · high confidence

Added a \ProviderFactoryBuilder\ helper to simplify the creation of \ProviderFactory\ instances, including a new \open\_read\_only\ method that supports opening the database in read-only mode. This includes a \ReadOnlyConfig\ struct to manage database, static file, and RocksDB paths, with options to disable long-lived read transaction safety or disable directory watching for unmonitored instances.

crates/storage/provider/src/providers/database · high confidence

Added a new \RpcBlockchainProvider\ crate that implements the \StateProviderFactory\ and related traits to fetch blockchain data via remote RPC calls instead of a local database. This enables testing without a full local database, allows access to blockchain state from remote nodes, and supports building light clients or tools that do not require full node storage. The implementation includes a unified \RpcResponseConverter\ trait to handle conversion of RPC responses (blocks, transactions, receipts) into primitive types, with a default \EthRpcConverter\ for Ethereum.

crates/storage/rpc-provider/src · high confidence

Adds a new RocksDB-based storage provider implementation to the node, including core provider logic, operation metrics, and startup consistency checks. The provider now validates RocksDB tables against MDBX checkpoints and static files, automatically healing stale data or triggering an unwind if inconsistencies are detected. It also exposes detailed per-table statistics (SST size, memtable size, WAL size) and operation metrics (get, put, delete, batch-write) for observability.

crates/storage/provider/src/providers/rocksdb · high confidence

The Ethereum node crate now includes a new SSZ transport proxy layer (\engine\_ssz\_proxy.rs\) that intercepts Engine API routes under \/engine/v1\ to handle SSZ-encoded payloads, alongside a witness generation service (\engine\_ssz\_witness.rs\) that re-executes validated payloads to produce execution witnesses for the \/payloads/witness\ endpoint. These components are wired into the node's add-ons via \EthereumAddOns\ and \EthereumNode\, enabling SSZ-based communication and debugging capabilities for Ethereum-specific engine interactions.

crates/ethereum/node/src · high confidence

Added the \StaticFileProducer\ component in the \reth-static-file\ crate, which orchestrates the parallel copying of blockchain data (such as receipts) from the database to static files. This new routine manages segment execution, handles pruning mode constraints to avoid moving prunable data, and updates static file indices upon completion, providing the core mechanism for populating static file segments.

crates/static-file/static-file/src · high confidence

A new \StorageWriter\ standalone type has been added to the provider layer to centralize and unify the logic for writing blockchain data. This change consolidates previously scattered operations for inserting blocks, removing blocks, and writing headers, transactions, and receipts into a single, coherent writer interface. Users benefit from a more consistent and maintainable storage backend that handles the persistence of state changes, including hashed state and trie updates, through a dedicated API rather than disparate provider methods.

crates/storage/provider/src/writer · high confidence

A new Write-Ahead Log (WAL) system has been added to the ExEx subsystem to persist notifications sent to external executors. This feature ensures that notifications are written to disk (using MessagePack serialization) before being sent, providing durability against crashes. The implementation includes a block cache to efficiently track committed and reverted blocks, atomic file writes to prevent corruption, and a finalization mechanism to clean up old WAL files once all ExExes have processed the corresponding blocks. Metrics are also exposed to monitor WAL size and block heights.

crates/exex/exex/src/wal · high confidence

This change introduces the \crates/storage/db-api\ crate, which defines the foundational traits and types for the storage layer. It provides the \Database\ trait for managing read-only and read-write transactions, along with \DbTx\ and \DbTxMut\ for transaction operations. The crate includes comprehensive cursor abstractions (\DbCursorRO\, \DbCursorRW\, \DbDupCursorRO\, \DbDupCursorRW\) and walker iterators (\Walker\, \ReverseWalker\, \RangeWalker\) for efficient table traversal. It also defines table metadata traits (\Table\, \DupSort\, \TableInfo\) and serialization traits (\Encode\, \Decode\, \Compress\, \Decompress\). A \DatabaseMock\ implementation is provided for testing, and a \DbTxUnwindExt\ trait adds functionality for unwinding database state. This crate serves as the interface that concrete database backends must implement.

crates/storage/db-api/src · high confidence

The new \crates/era\ crate provides support for Era and Era1 files, which are specialized \.e2s\ formats optimized for reading and long-term storage of execution layer block history. This change adds the core module structure (\common\, \e2s\, \era\, \era1\, \ere\) and includes test utilities to generate sample data structures like headers, receipts, and block tuples for verifying decoding and compression logic.

crates/era/src · high confidence

The \reth-rpc-convert\ crate has been introduced to centralize and standardize the conversion logic between Reth's internal primitive types and RPC response types. This new module provides the \RpcConvert\ trait and associated converters (such as \ReceiptConverter\ and \HeaderConverter\) that handle the mapping of transactions, receipts, logs, and headers for the JSON-RPC API. By consolidating these conversion utilities, the crate ensures consistent RPC output formatting and simplifies the implementation of RPC methods across different network types.

crates/rpc/rpc-convert · high confidence

The \crates/trie/db\ location now contains the \reth-trie-db\ crate, which provides the concrete database implementations for the trie subsystem. This includes database-backed cursor factories for hashed accounts and storage (\DatabaseHashedCursorFactory\), trie nodes (\DatabaseTrieCursorFactory\), and state root computation (\DatabaseStateRoot\). It also introduces support for two storage key encodings—legacy (65-byte) and packed (33-byte)—via \LegacyKeyAdapter\ and \PackedKeyAdapter\, allowing the trie to operate on either format based on storage settings. Additionally, the crate exposes utilities for computing trie changesets from database state, loading prefix sets from changesets, and generating state and storage proofs (including multiproofs) against the database.

crates/trie/db/src · high confidence

The sparse trie implementation has been refactored to use an arena-based memory model with parallel processing support. This change introduces \ArenaParallelSparseTrie\ and \ArenaSparseSubtrie\, which manage node storage via a slotmap arena to improve memory locality and enable parallel mutations across subtries. The new architecture includes a depth-first \ArenaCursor\ for efficient trie traversal, dense child indexing for branch nodes, and optimized pruning and compaction logic that collapses nodes by epoch and compacts the arena via BFS. This replaces the previous parallel sparse trie implementation, simplifying the codebase while adding features like retained changed paths and accurate memory accounting during pruning.

crates/trie/sparse/src/arena · high confidence

The \reth-errors\ crate now provides a unified \RethError\ enum that aggregates blockchain-specific error types (execution, consensus, database, and provider errors) into a single, structured error type for easier handling. This new error type is designed to be \no\_std\ compatible and includes size assertions to ensure memory efficiency on 64-bit x86 architectures.

crates/errors · high confidence

The \crates/tasks\ module now provides a unified \Runtime\ (aliased as \TaskExecutor\) that manages Tokio runtimes, dedicated Rayon thread pools, and graceful shutdown signaling. This change introduces \CancelOnDrop\ and \ManualCancel\ for cooperative task cancellation, allowing spawned jobs to stop when their owner is dropped or when an external signal is received. It also adds \LazyHandle\ for efficiently resolving values computed on background threads with caching, and \ForEachOrdered\ to stream parallel iterator results sequentially in index order. The runtime includes metrics for spawned/finished tasks and worker durations, and supports named single-thread workers via \WorkerMap\ for predictable thread reuse.

crates/tasks · high confidence

The \crates/consensus/common\ crate has been added to provide a shared library of consensus validation methods. This includes functions for validating header gas limits and base fees, verifying Shanghai withdrawals and Cancun blob gas usage, and ensuring block body hashes match the header. It also introduces pre-execution block validation logic that checks transaction roots and applies fork-specific field validations, centralizing these checks for reuse across the consensus layer.

crates/consensus/common · high confidence

The \reth-net-nat\ crate now provides a \NatResolver\ enum that allows users to explicitly choose how the external IP address is determined, supporting methods such as UPnP, public HTTP APIs, fixed IP addresses, domain names (with DNS resolution), and direct network interface inspection. A new \net\_if\ module enables resolving the external IP via a specific OS network interface (defaulting to \eth0\), which is particularly useful for Docker bridge networks where containers are queried by DNS rather than direct IP addresses. The crate also includes a \ResolveNatInterval\ helper for periodic IP resolution and exposes serialization support via the \serde\ feature.

crates/net/nat · high confidence

The \reth-execution-cache\ crate now provides the core caching infrastructure for block processing, introducing \PayloadExecutionCache\ to manage shared, thread-safe state across payload tasks and \CachedStateProvider\ to accelerate lookups for accounts, storage, and bytecode. A new immutable \TxPoolPrewarmCacheSnapshot\ tier allows speculative execution data to be served before the main cache, improving hit rates during sequential payload processing. The implementation uses a fixed-size concurrent cache with epoch-based invalidation and detailed metrics for monitoring cache performance.

crates/engine/execution-cache · high confidence

The new \crates/storage/db-common\ crate consolidates common database operations, primarily exposing the \init\ module for genesis block initialization and state root computation. This module provides functions like \init\_genesis\ and \init\_genesis\_with\_settings\ to write the genesis block to storage, validate genesis hashes against the chainspec, and handle storage settings. It also includes utilities for state dump imports, managing trie updates, and computing state roots during initialization. Additionally, the crate re-exports the \DbTool\ type for database interaction utilities.

crates/storage/db-common/src · high confidence

A new debug consensus client has been added to the \consensus/debug-client\ crate, providing a worker that sends Fork Choice Updated (FCU) and new payload events to an execution client using data from external providers like Etherscan or RPC endpoints. This allows developers to test the execution client's consensus engine integration without needing to run a full consensus node, by simulating block production and finality signals through the \PayloadProvider\ trait.

crates/consensus/debug-client/src · high confidence

The payload processing pipeline now uses a dedicated \BalPrewarmPool\ of 128 blocking threads to parallelize BAL (Block Access List) read-set prewarming, dispatching account and storage slot warm requests via round-robin channels to saturate NVMe I/O. This pool is integrated into the new \PayloadProcessor\ entry point, which manages the lifecycle of prewarming, transaction execution, and receipt root computation. Receipt root calculation is offloaded to a background \ReceiptRootTask\ that incrementally builds the trie from indexed receipts, and the prewarming logic is split into a dedicated \prewarm\ module supporting both transaction-based and BAL-based modes, allowing small blocks to skip prewarming entirely.

_crates/engine/tree/src/tree/payload\processor · high confidence

The transaction pool now maintains a dedicated Blob sub-pool (\BlobTransactions\) to track EIP-4844 blob transactions that are not yet pending, handling their specific priority and eviction logic separately from the standard Pending, Basefee, and Queued pools. This change introduces a new \TxState\ bitflag system to precisely determine sub-pool membership based on nonce gaps, balance, and fee requirements. Additionally, the pool's event system has been expanded with \FullTransactionEvent\ and \AllTransactionsEvents\ to provide subscribers with richer context, including specific reasons for queuing and full transaction bodies where applicable.

crates/transaction-pool/src/pool · high confidence

This change adds the \discv4\ crate, providing a Rust implementation of the Ethereum Discovery v4 protocol. It includes the core service and frontend for managing a Kademlia-like routing table, configuration options for tuning discovery behavior (such as ping intervals, timeouts, and EIP-868 support), and protocol-specific message encoding/decoding. The release also includes benchmarking tools for the wire codec and mock discovery utilities to facilitate testing.

crates/net/discv4 · high confidence

Adds a new \crates/net/discv5\ crate that wraps the \sigp/discv5\ library to handle peer discovery. This includes configuration builders for boot nodes and fork IDs, ENR conversion utilities between discv4 and discv5 identifiers, peer filtering logic to enforce network stack requirements, and metrics tracking for discovered peers and kbucket population.

crates/net/discv5 · high confidence

This change adds support for the EIP-7928 \eth\_blockAccessList\ RPC method, allowing users to retrieve the access list for a specific block. It also implements the EIP-7910 \eth\_config\ endpoint, which provides data about recent and upcoming fork configurations, including system contracts and precompiles. The implementation includes helper traits for block access list retrieval, caching, and forking configuration, along with updates to the blocking task spawning mechanism to handle these new IO-heavy operations.

crates/rpc/rpc-eth-api/src/helpers · high confidence

The RPC layer now exposes an \eth\_capabilities\ response, allowing clients to query the availability and retention policies for chain resources such as state, transactions, logs, and receipts. Internally, block and receipt handling has been refactored: the \PendingBlockAndReceipts\ tuple is replaced by a dedicated \BlockAndReceipts\ struct, and a new \SharedReceipts\ enum unifies receipt storage from both persistent storage and in-memory execution outputs. Additionally, a \CachedTransaction\ type is introduced to efficiently cache and retrieve transaction data alongside its block context and receipts.

crates/rpc/rpc-eth-types/src · high confidence

This change adds the \crates/net/ecies\ library, providing a complete ECIES implementation for the Ethereum RLPx protocol. It introduces a Tokio-based codec (\ECIESCodec\) that manages the full handshake lifecycle (AUTH, ACK, and subsequent message framing) and exposes an \ECIESStream\ for encrypted peer-to-peer communication. The implementation includes optimized cryptographic operations using \alloy\_primitives\ (Keccak256, B256), a custom MAC construction using AES-256 and Keccak-256, and configurable backpressure boundaries (defaulting to 64KiB) to improve write performance for batched messages.

crates/net/ecies · high confidence

The new \crates/fs-util\ library provides a wrapper around standard \std::fs\ operations, introducing a dedicated \FsPathError\ enum that enriches standard I/O errors with specific file path context. This change improves error reporting for filesystem operations such as reading, writing, linking, and managing directories by clearly identifying which path failed, rather than returning generic I/O errors.

crates/fs-util · high confidence

The hashed cursor module now includes built-in observability and testing utilities. A new metrics module adds Prometheus histograms and counters to track the duration and frequency of \seek\, \next\, and \is\_storage\_empty\ operations, exposing them via an \InstrumentedHashedCursor\ wrapper. For testing, a \MockHashedCursorFactory\ and \MockHashedCursor\ are provided to simulate hashed state iteration and track visited keys, while a \NoopHashedCursorFactory\ and \NoopHashedCursor\ serve as empty placeholders for scenarios where no data is expected.

_crates/trie/trie/src/hashed\cursor · high confidence

Adds a new \InvalidBlockWitnessHook\ component that captures execution state and generates witness data when invalid blocks are detected, enabling debugging and analysis of block execution failures by comparing against a healthy node.

crates/engine/invalid-block-hooks · high confidence

A new \reth-engine-local\ crate has been added to provide a local engine service designed to drive a development chain. This includes a \LocalMiner\ that supports three mining modes—Instant (mining on transaction arrival or after a threshold), Interval (mining at fixed time intervals), and Trigger (mining on demand via a stream)—along with a configurable finality depth (defaulting to 64 confirmations) and an optional payload wait time to allow for multiple rebuild attempts. The crate also exposes a \LocalPayloadAttributesBuilder\ to construct payload attributes for the local engine, handling timestamp enforcement and fork-specific fields based on the chain specification.

crates/engine/local · high confidence

The \reth-consensus\ crate now exposes a three-tier trait hierarchy (\HeaderValidator\, \Consensus\, and \FullConsensus\) that splits block validation into isolated stages: header checks, pre-execution body checks, and post-execution state checks. This structure allows the engine to apply specific validation layers at the appropriate points in the payload processing pipeline. The crate also includes a \NoopConsensus\ implementation for scenarios where validation is not required and a \TestConsensus\ helper for testing.

crates/consensus/consensus · high confidence

The \reth download\ command now supports a new modular snapshot mode that downloads and extracts individual data components (state, transactions, receipts, etc.) based on a JSON manifest, rather than relying on a single monolithic archive. Users can select specific components or use presets (minimal, full, archive) via CLI flags or an interactive TUI, and the tool automatically plans, downloads, and extracts the required chunks in parallel. The command also generates a \reth.toml\ configuration and database checkpoints tailored to the selected components, and supports features like resumable downloads, retry logic, and local file reuse.

crates/cli/commands/src/download · high confidence

The eth-wire module now supports multiplexing multiple subprotocols over a single RLPx connection. A new \RlpxProtocolMultiplexer\ handles message-ID-based demultiplexing, allowing the installation of dependent satellite protocols. This enables the new \EthSnapStream\, which carries \eth\ as the primary protocol and \snap/2\ (EIP-8189) as a typed side-channel on the same connection, exposing both via a unified \Stream\/\Sink\ interface. The handshake logic has been updated to support configurable \Hello\ messages with protocol details and validates shared capabilities to determine the correct stream type.

crates/net/eth-wire/src · high confidence

The engine tree module now includes dedicated error handling for block insertion and persistence state management. A new \InsertBlockError\ type wraps block details and error kinds to provide clearer diagnostics when block insertion fails, while \AdvancePersistenceError\ handles specific issues during persistence advancement, such as closed channels or unavailable state/trie catch-up inputs. Additionally, an \InvalidHeaderCache\ has been added to track invalid headers with a hit-eviction threshold, improving performance by avoiding repeated processing of known bad headers. A \PersistenceState\ struct now manages background persistence tasks, tracking the highest persisted block and state trie outputs to coordinate asynchronous database writes. Finally, a \PrecompileCacheMap\ using \moka\ and \DashMap\ provides thread-safe caching for precompile results, enhancing execution performance by storing and retrieving precompile outputs efficiently.

crates/engine/tree/src/tree · high confidence

The \reth-trie-parallel\ crate now provides the core infrastructure for parallel state-root computation and proof generation. This includes a \StateRootHandle\ that manages the sparse-trie pipeline for both the engine tree and payload builder, a \ProofWorkerHandle\ that dispatches account and storage proofs to dedicated worker pools with per-thread database transactions, and an \AsyncAccountValueEncoder\ that supports asynchronous storage root computation. The module also defines the \StateRootTaskError\ enum for handling proof and provider errors, and exposes detailed metrics for tracking worker idle times, cursor operations, and deferred encoder statistics.

crates/trie/parallel · high confidence

Added a new \reth\_payload\_util\ crate providing traits and implementations for composing transactions during block building. This includes the \PayloadTransactions\ trait for iterating transactions, \BestPayloadTransactions\ to bridge the transaction pool's best transactions, \PayloadTransactionsFixed\ for injecting specific transactions (e.g., sequencer transactions), and \PayloadTransactionsChain\ to combine multiple sources with independent gas limits and invalidation propagation.

crates/payload/util · high confidence

The \crates/net/banlist\ library now provides a \BanList\ struct that allows the node to ban specific peer IDs and IP addresses, either indefinitely or until a specified timestamp. Users can add entries via \ban\_peer\/\ban\_ip\ or with timeouts via \ban\_peer\_until\/\ban\_ip\_until\, and the system automatically evicts expired bans through \evict\ methods. The implementation ensures that non-global IPs (such as private or loopback addresses) are not banned, and re-banning an already banned IP or peer updates the timeout to the new value.

crates/net/banlist · high confidence

Adds the \reth-bb\ binary, a modified reth node designed for benchmarking high-gas workloads by merging transactions from multiple consecutive blocks into a single synthetic block. This tool disables standard consensus validations (such as gas-limit and blob gas checks) to allow artificially large blocks and implements multi-segment execution, where the block is processed in distinct segments with separate EVM environments to correctly handle segment boundaries, gas counters, and inter-segment state.

bin/reth-bb · high confidence

The \reth-chain-state\ crate has been introduced to centralize the management of in-memory canonical chain state. It provides \CanonicalInMemoryState\ to track blocks not yet persisted to disk, \ChainInfoTracker\ to monitor the canonical head, safe, and finalized blocks, and a notification system (\CanonStateNotification\) to alert subscribers of chain extensions or reorgs. Additionally, it includes \ExecutionTimingStats\ for detailed block execution logging and \PreservedSparseTrie\ to optimize payload validation by reusing sparse trie state across blocks.

crates/chain-state · high confidence

A new \reth-db-models\ crate has been added to centralize database model definitions, providing \no\_std\ support and serialization via \serde\ and \reth-codec\. This location introduces specific data structures for accounts (\AccountBeforeTx\), storage (\StorageBeforeTx\), and client versioning (\ClientVersion\), alongside block-related models including \StoredBlockBodyIndices\, \StoredBlockWithdrawals\, and a new \StaticFileBlockWithdrawals\ type designed for static file compatibility. These models define the on-disk representation and compact encoding for these entities, serving as the foundational storage layer for the rest of the system.

crates/storage/db-models · high confidence

The \crates/payload/primitives\ crate has been introduced to provide foundational abstractions for execution payloads. It defines the \PayloadTypes\ trait to associate execution data, built payloads, and attributes, alongside the \ExecutionPayload\ and \BuiltPayload\ traits that standardize access to block data, fees, and execution results. The crate also introduces \PayloadOrAttributes\ for unified validation logic and implements version-specific timestamp and fork validation (supporting V1 through V6 engine API methods) via \validate\_payload\_timestamp\. Additionally, it defines error types such as \PayloadBuilderError\ and \EngineObjectValidationError\ to handle payload building failures and validation issues like unsupported forks or missing fields.

crates/payload/primitives · high confidence

The \reth-network-api\ crate now exposes a \CellCustody\ type that tracks the latest \custodyColumns\ bitmap received via \engine\_forkchoiceUpdatedV4\, allowing network components to align blob cell sampling with the consensus client's custody set (EIP-8070). This state is exposed through the \NetworkInfo\ trait and integrated into the \NoopNetwork\ test implementation. The crate also defines core network traits (\NetworkInfo\, \Peers\, \PeersInfo\, \NetworkEventListenerProvider\, \BlockDownloaderProvider\) and event types (\PeerEvent\, \NetworkEvent\, \DiscoveryEvent\) that standardize how the node exposes peer lifecycle, session info, and block download capabilities.

crates/net/network-api · high confidence

A new \reth-snap-sync\ crate implements snap/2 state synchronization as specified by EIP-8189, allowing nodes to download the state of a recent block from peers and verify it against that block's state root instead of executing every block from genesis. The implementation uses EIP-7928 block access lists (BALs) to keep the downloaded state current with recent blocks, replacing the older snap/1 trie-node healing approach. The crate provides a \SnapBootstrap\ driver that manages the sync lifecycle—including pivot selection, account range downloads, storage and bytecode persistence, and BAL catch-up—while relying on \reth-downloaders\ for network requests and proof checks.

crates/snap-sync · high confidence

The \reth-trie-sparse\ crate is introduced, providing a sparse Merkle Patricia Trie implementation that loads nodes on-demand rather than materializing the entire state. This allows the node to handle large state roots with significantly lower memory overhead by keeping unrevealed nodes in a 'blind' state. The crate exposes \SparseStateTrie\ for managing account and storage tries, \RevealableSparseTrie\ for handling the blind/revealed lifecycle, and metrics for tracking multiproof node counts, enabling more efficient state root calculations and witness generation.

crates/trie/sparse/src · high confidence

Engine block validation now uses a new \StateRootStrategy\ that computes state roots via an in-memory sparse trie instead of the previous method. This strategy streams execution updates into the trie, dispatches proof requests to background workers, and manages storage trie ownership to parallelize work, resulting in more efficient state root computation during block validation.

_crates/engine/tree/src/tree/state\_root\strategy · high confidence

A new \reth-ethereum-primitives\ crate has been created to host Ethereum-specific primitive types, replacing previous in-crate definitions. This change introduces type aliases for \Transaction\, \TransactionSigned\, \Block\, and \BlockBody\ that are directly backed by \alloy\_consensus\ types (e.g., \EthereumTypedTransaction\, \EthereumTxEnvelope\). It also defines a generic \Receipt\ type aliasing \EthereumReceipt\ and implements the \NodePrimitives\ trait via the new \EthPrimitives\ struct, establishing the foundational data structures for Ethereum block processing and serialization within the Reth architecture.

crates/ethereum/primitives · high confidence

The \crates/config\ crate is introduced as a new standalone module for managing Reth node configuration. It defines the \Config\ struct, which aggregates settings for P2P discovery (\PeersConfig\, \SessionsConfig\), pipeline stages (\StageConfig\ including headers, bodies, execution, and pruning), static files, and ERA import. The crate provides TOML-based serialization and deserialization via \from\_path\ and \save\ methods, allowing users to load, modify, and persist node settings. It also exposes specific configuration types like \PruneConfig\, \EraConfig\, and \EtlConfig\, enabling granular control over pruning intervals, ERA file sources, and ETL directories.

crates/config · high confidence

The new \crates/storage/storage-overlay\ crate provides the core infrastructure for managing in-memory state overlays during block validation and execution. It introduces \OverlayManager\ to track in-memory blocks and build reusable state trie and execution overlays, \ExecutionOverlay\ to hold in-memory account, storage, and bytecode changes, and \OverlayStateProvider\ to expose this layered state to the rest of the node. The crate also includes a \ChangesetCache\ for efficient trie changeset computation and eviction, along with metrics for overlay computation and caching performance.

crates/storage/storage-overlay · high confidence

The \reth-tracing\ crate now supports configurable log output formats—JSON, logfmt, and terminal—and allows log verbosity to be changed at runtime via a global handle. Users can select the format via the \--log.format\ CLI argument (defaulting to terminal), and the new \LogFormat\ enum drives the creation of the appropriate tracing layer. Additionally, the \RethTracer\ can be configured with \with\_reload(true)\ to enable runtime updates of log levels and module-specific filters (vmodule) without restarting the node, exposing \set\_log\_verbosity\ and \set\_log\_vmodule\ for dynamic control.

crates/tracing · high confidence

Adds a new \reth-exex-test-utils\ crate providing helper types and builders to simplify testing Execution Extensions. This includes \TestPoolBuilder\, \TestExecutorBuilder\, and \TestConsensusBuilder\ to inject mock components, a \TestNode\ implementation for bootstrapping the test environment, and a \TestExExHandle\ struct that manages the ephemeral database, runtime, and notification channels required to simulate ExEx lifecycle events.

crates/exex/test-utils · high confidence

The \crates/stages/api\ location now contains the core API for the staged sync pipeline, providing the foundational types and execution logic for stage-based synchronization. This includes the \Pipeline\ struct and its \PipelineBuilder\ for configuring and running the sync loop, along with \StageSet\ and \StageSetBuilder\ for grouping and ordering stages. The crate defines the \Stage\ trait with \execute\ and \unwind\ methods, \ExecInput\/\UnwindInput\ for stage context, and \ControlFlow\ to manage execution states like \Continue\, \NoProgress\, and \Unwind\. It also introduces a comprehensive error hierarchy (\StageError\, \PipelineError\, \BlockErrorKind\) to distinguish between recoverable and fatal errors, and a metrics system (\MetricsListener\, \SyncMetrics\) to track stage checkpoints, entity counts, and execution duration.

crates/stages/api · high confidence

A new \BatchTxProcessor\ has been added to the transaction pool to reduce lock contention when processing many concurrent transaction insertions. The processor accepts batch requests, optimizes for same-origin transactions by calling the batched \add\_transactions\ method, and falls back to \add\_transactions\_with\_origins\ for mixed origins, significantly improving insertion performance under high load.

crates/transaction-pool/src · high confidence

The \reth-provider\ crate now includes an in-memory Basic Access List (BAL) store (\InMemoryBalStore\) with configurable retention policies and a RocksDB-backed implementation, alongside a \changeset\_walker\ module that provides iterators for walking account and storage changesets from static files. These additions support the new storage v2 architecture by enabling efficient access to block access lists and historical state changes without loading entire datasets into memory.

crates/storage/provider/src · high confidence

The \crates/cli/runner\ crate now provides the \CliRunner\ struct, which serves as the entry point for executing CLI commands on a Tokio runtime. This component manages the runtime lifecycle, allowing commands to run until completion or until interrupted by SIGINT/SIGTERM signals. It supports both standard async execution and blocking command execution, ensuring that spawned tasks are gracefully shut down with a configurable timeout when the main command finishes or an exit signal is received.

crates/cli/runner · high confidence

The provider traits module now exposes a \FullProvider\ trait that unifies all provider capabilities (block, state, history, and chain state subscriptions) into a single interface for simplified usage. Additionally, a new \RocksDBProviderFactory\ trait is introduced to manage RocksDB-specific operations, including point-in-time snapshots and batch commits, with logic to skip RocksDB overhead for legacy MDBX-only nodes.

crates/storage/provider/src/traits · high confidence

The network crate now exposes a \NetworkBuilder\ that allows users to configure the \NetworkManager\, \TransactionsManager\, and \EthRequestHandler\ in a single fluent chain, including the ability to set custom transaction propagation and announcement filtering policies. To improve performance and prevent thread starvation, the system introduces configurable polling budgets (e.g., for draining streams, downloaders, and the swarm) via a new \budget\ module and associated macros, replacing previous hardcoded limits with explicit, metered iteration counts.

crates/net/network/src · high confidence

Adds a new \RethCli\ trait and \ChainSpecParser\ trait to \crates/cli/cli\, providing a generic framework for parsing chain specifications and executing CLI commands. The \ChainSpecParser\ trait allows implementations to define supported chains and parsing logic, while the \RethCli\ trait standardizes argument parsing and command execution via a \CliRunner\. This change enables consistent CLI behavior across different node implementations by abstracting common functionality like version reporting and runtime initialization.

crates/cli/cli · high confidence

The \crates/net/p2p/src/bodies\ module now provides a new set of traits and types for downloading block bodies, making the system generic over the block and header types. The \BodiesClient\ trait defines how to fetch block bodies with optional priority and range hints, while the \BodyDownloader\ trait defines the strategy for yielding these downloads as a stream. A new \BlockResponse\ enum distinguishes between full blocks (with transactions) and empty blocks (headers only), allowing consumers to handle both cases uniformly.

crates/net/p2p/src/bodies · high confidence

The \storage-api\ crate now exposes a comprehensive set of new traits that define the interface for reading and writing blockchain state. This includes \AccountReader\ and \ChangeSetReader\ for querying account balances and historical changesets, \BlockNumReader\ and \BlockIdReader\ for resolving block identifiers, and \BlockWriter\ for persisting blocks and execution outcomes. A significant addition is the \BalStore\ trait, which provides an abstraction for storing and retrieving Block Access Lists (BALs) with support for soft limits and pruning. Additionally, \EvmStateProvider\ is introduced to standardize state access for EVM execution, and \FullRpcProvider\ unifies the traits required to support the \eth\ RPC server.

crates/storage/storage-api · high confidence

The execution stage now maintains a separate MDBX database to store \keccak256(slot) → slot\ preimages, enabling the recovery of plain storage keys from hashed representations during pre-Cancun \SELFDESTRUCT\ operations. This change allows the stage to rewrite wipe reverts for self-destructed accounts using plain slot keys, eliminating the need to walk the hashed-storage database during changeset writing. Additionally, this preimage store is exposed for use by downstream state-dump importers, such as \op-reth init-state\, to seed the database when state is imported from snapshots rather than executed block-by-block.

crates/stages/stages/src/stages/execution · high confidence

The \crates/storage/db/src/static\_file\ module now exposes a \StaticFileCursor\ for iterating and retrieving data from static file segments, along with a generic column mask system (\ColumnSelectorOne/Two/Three\ and the \add\_static\_file\_mask!\ macro) to efficiently select specific columns from segment rows. This change provides the foundational API for reading structured data from static files, including predefined masks for headers, receipts, transactions, senders, and account/storage changesets.

_crates/storage/db/src/static\file · high confidence

A new \reth-ethereum\ meta crate has been added to provide a single entry point for commonly used Ethereum-specific reth dependencies. This crate re-exports core primitives, CLI utilities, transaction pool types, consensus logic, EVM components, network and provider interfaces, storage APIs, node builder/core logic, engine types, trie structures, and RPC types (including Ethereum-specific RPC types) behind optional features. Users can now depend on this single crate to access a broad set of Ethereum-related functionality without managing multiple individual reth crate dependencies.

crates/ethereum/reth · high confidence

The \crates/etl\ crate has been added to provide an Extract-Transform-Load (ETL) data collector. This component allows unsorted data to be pushed into a collector, which internally flushes the data in a sorted manner to temporary files once a specified memory capacity is reached. This enables efficient iteration over sorted key-value pairs, optimizing database inserts (particularly for B-tree based databases like MDBX) and managing memory by moving buffers to disk instead of keeping them in RAM.

crates/etl · high confidence

The \crates/node/core\ module has been introduced as a dedicated library for core node functionality, consolidating previously scattered utilities. This new crate provides \NodeConfig\, a generic configuration struct that aggregates all CLI argument groups (network, RPC, database, storage, etc.) and allows customization before node launch. It also includes \dirs.rs\ for standardized, cross-platform data directory resolution (data, config, cache, logs) using XDG conventions, and \exit.rs\ for managing node lifecycle via a \NodeExitFuture\. Additionally, \version.rs\ centralizes client version metadata and P2P version strings, while \utils.rs\ offers helpers for path parsing, JWT secret management, and network header/body retrieval.

crates/node/core/src · high confidence

The \crates/payload/builder\ crate now provides the core infrastructure for building payloads, introducing the \PayloadBuilderService\ to manage payload jobs and the \PayloadStore\ for retrieving built payloads. This change establishes the \PayloadJob\ and \PayloadJobGenerator\ traits, allowing implementers to define custom payload building logic, and includes a \NoopPayloadBuilderService\ for scenarios where payload building is disabled. Additionally, comprehensive metrics are now exposed under the \payloads\ scope to monitor job lifecycle, revenue, and latency.

crates/payload/builder · high confidence

The \crates/storage/db/src/implementation\ directory now contains the concrete MDBX-backed implementation for the database layer. This includes the \DatabaseEnv\ and \DatabaseArguments\ for configuring environment settings (such as geometry, sync mode, and max readers), the \Tx\ wrapper for managing transactions with integrated metrics and long-read transaction logging, and the \Cursor\ implementation providing read/write navigation over tables. This code serves as the backend for the \reth-db\ crate, replacing or implementing the abstractions defined in the storage API.

crates/storage/db/src/implementation · high confidence

This change introduces several new CLI commands in the \reth-cli-commands\ crate. Users can now import blockchain data from ERA files (\.era\, \.era1\, \.ere\) using the \import-era\ command, which supports local directories or remote URLs, and optionally backfill receipts. Conversely, the \export-era\ command allows exporting block history from the database into ERA files, with support for \era1\ and \ere\ formats (consensus-layer \.era\ is explicitly rejected). The \import\ command has been updated to support importing from multiple RLP files sequentially and includes a new \--fail-on-invalid-block\ flag to control error handling during import. Additionally, a new \config\ command allows users to dump configuration settings to stdout, and a \dump-genesis\ command outputs the genesis block JSON configuration for a specified chain.

crates/cli/commands/src · high confidence

The CLI module now exposes dedicated configuration traits (\PayloadBuilderConfig\, \RethNetworkConfig\, \RethTransactionPoolConfig\) that standardize how node components expose their settings. \PayloadBuilderConfig\ introduces a \gas\_limit\_for\ method that returns a chain-specific default (60M for Mainnet, Sepolia, Holesky, and Hoodi; 36M for others) when no explicit limit is set, and adds support for EIP-7872 blob limits via \max\_blobs\_per\_block\. \RethNetworkConfig\ provides access to the network's secret key and allows registering additional RLPx sub-protocols, while \RethTransactionPoolConfig\ exposes the pool configuration and a new \max\_batch\_size\ setting for transaction batch insertions.

crates/node/core/src/cli · high confidence

A new \DbTool\ struct has been introduced in \crates/storage/db-common\ to provide common database operations for CLI tools. This utility allows users to inspect database contents using a \ListFilter\ for searching, filtering, and paginating through table entries, as well as retrieving specific keys or duplicate sort entries. It also includes management capabilities, such as dropping specific tables or completely removing the database, static files, and the ExEx WAL directory (only if it exists).

_crates/storage/db-common/src/db\tool · high confidence

The \e2e-test-utils\ crate now provides a comprehensive builder API (\E2ETestSetupBuilder\) for configuring and launching test node setups, including support for custom chain specs, payload attribute generation, and storage v2 layouts. It introduces \NodeTestContext\ to simplify node interactions such as advancing blocks, injecting transactions, and managing payload builds, alongside dedicated helpers for network events, RPC operations, transaction signing (including EIP-7702 and blob transactions), and trie consistency verification. The framework also supports importing pre-existing chain data from RLP files to initialize test nodes with pre-populated state.

crates/e2e-test-utils/src · high confidence

Adds a new example (\examples/exex-subscription\) that implements an Execution Extension (ExEx) installing a custom \watcher\ RPC namespace. This allows clients to subscribe to real-time storage diffs for specific Ethereum addresses, with the ExEx listening for chain commits and streaming \StorageDiff\ updates (address, key, old value, new value) to connected subscribers.

examples/exex-subscription · high confidence

The \crates/net/network/src/fetch\ module introduces a new \FetchClient\ that implements \HeadersClient\, \BodiesClient\, \ReceiptsClient\, \BlockAccessListsClient\, and \SnapClient\, providing a unified front-end for downloading blockchain data. This client delegates requests to the \StateFetcher\, which manages peer availability, tracks inflight requests for headers, bodies, receipts, access lists, and snap protocol messages, and selects peers based on latency and response quality. The implementation supports priority-based requests, block range hints for bodies, and BAL requirements for access lists, enabling the sync pipeline to efficiently fetch data from the network.

crates/net/network/src/fetch · high confidence

The \crates/rpc/ipc\ crate now provides a complete IPC server and client implementation built on \jsonrpsee\ and \interprocess\. This introduces a new \IpcServer\ with configurable socket permissions and connection limits, an \IpcClientBuilder\ with adjustable request timeouts, and a custom \StreamCodec\ for efficient JSON message framing. Users can now communicate with the node via Unix domain sockets using the standard JSON-RPC protocol, including support for subscriptions and batch requests.

crates/rpc/ipc · high confidence

The \reth-net-p2p\ crate now provides the foundational traits and client implementations for downloading Block Access Lists (BALs) alongside standard block data. This includes the \BlockAccessListsClient\ trait, which allows callers to specify whether BAL retrieval is mandatory or optional via the new \BalRequirement\ enum, and the \FullBlockClient\ which can now fetch full blocks with optional BALs attached. The crate also establishes the \ReceiptsClient\ for receipt downloading, a generic \DownloadClient\ trait for peer management, and \SyncStateProvider\/\NetworkSyncUpdater\ traits for managing network synchronization status and runtime fork filter updates.

crates/net/p2p/src · high confidence

The \reth p2p\ CLI subcommand now includes three new utilities for network diagnostics and node operation. The \bootnode\ command allows running a standalone discovery node supporting both discv4 and discv5 (optionally sharing a UDP port), with configurable NAT resolution and persistent secret keys. The \enode\ command prints the enode URL for a given secret key and optional IP address. The \rlpx ping\ command performs an RLPx handshake with a specified node to verify connectivity and retrieve peer hello messages.

crates/cli/commands/src/p2p · high confidence

The \crates/rpc/rpc\ crate now includes concrete implementations for the \admin\, \miner\, \net\, and \rpc\ namespaces. The \AdminApi\ provides methods for managing peers (\addPeer\, \removePeer\, \banPeer\, \unbanPeer\), retrieving peer information (\peers\), and exposing node configuration (\nodeInfo\). The \MinerApi\ exposes placeholder methods for mining control (\setExtra\, \setGasPrice\, \setGasLimit\). The \NetApi\ implements \net\_version\, \net\_peerCount\, and \net\_listening\. Additionally, the \RPCApi\ exposes the currently registered RPC modules. These changes expand the RPC surface area to support node administration and network status queries.

crates/rpc/rpc/src · high confidence

The \rpc-eth-api\ crate now exposes dedicated traits for specific RPC capabilities: \EthBundleApi\ and \EthCallBundleApi\ for Flashbots-style bundle simulation and submission, \L2EthApiExt\ for L2-specific transaction conditional sending, and \EthFilterApi\ for standard log and filter operations. These traits define the server and client interfaces for these endpoints, making them available for implementation by node builders.

crates/rpc/rpc-eth-api/src · high confidence

The \reth-rpc-builder\ crate has been introduced to centralize RPC server configuration and startup logic. It provides a new \AuthServerConfig\ that supports configurable JWT secrets, IPC endpoints, and pluggable Tower middleware layers for both RPC and HTTP transports, allowing custom logic to run after authentication. The crate also includes a \RethRpcServerConfig\ trait that maps CLI arguments to server settings, enabling fine-grained control over module selection, CORS domains, and request limits. Additionally, it ships with built-in middleware for RPC request metrics and rate limiting for expensive \trace\\ and \debug\\ methods.

crates/rpc/rpc-builder/src · high confidence

The \crates/rpc/rpc-layer\ module has been extracted and implemented to provide reusable HTTP middleware for the RPC service. It introduces \AuthLayer\ and \JwtAuthValidator\ to enforce JWT-based authentication on incoming requests, and \CompressionLayer\ and \DecompressionLayer\ to handle request decompression and response compression (supporting gzip, brotli, deflate, and zstd) with configurable body size limits and concurrency controls.

crates/rpc/rpc-layer · high confidence

Added a new \rpc-db\ example that runs the ETH JSON-RPC API as a standalone service backed by a local database file. The example demonstrates how to configure a read-only database provider, set up the RPC server with standard namespaces, and integrate a custom RPC namespace (\myrpcExt\) exposing a \customMethod\ that retrieves block data via the provider.

examples/rpc-db · high confidence

The \reth db\ CLI now includes several new subcommands to help manage and inspect the database. You can now migrate your storage layout from the v1 (MDBX-only) format to v2 (static files + RocksDB) using \reth db migrate-v2\. For storage inspection, \reth db account-storage\ shows the storage slots and size for a specific account address, while \reth db state\ allows querying account state and storage at a specific block. Maintenance tasks are now easier with \reth db clear\ to delete all entries in a table or static file segment, \reth db copy\ to create a compacted copy of the MDBX database, and \reth db diff\ to compare two databases. Additionally, \reth db prune-checkpoints\ and \reth db stage-checkpoints\ allow you to view and set prune and stage checkpoints, and \reth db repair-trie\ has been enhanced with metrics support.

crates/cli/commands/src/db · high confidence

A new \reth dump-stage\ command has been added to the CLI, allowing users to isolate and dump the state of specific blockchain stages (Execution, AccountHashing, StorageHashing, and Merkle) for a given block range. This tool creates a separate output database, imports relevant tables, and optionally performs a dry-run of the stage execution to help diagnose issues. The implementation supports unwinding and copying state data for each stage, enabling targeted debugging without affecting the main node's data directory.

crates/cli/commands/src/stage/dump · high confidence

Users can now manage individual synchronization stages directly via the new \reth stage\ command, which exposes four subcommands: \run\ to execute a specific stage (with options for block ranges, batch sizes, and committing changes), \drop\ to clear stage-specific database tables and static files (headers, bodies, execution, senders, hashing, merkle, and history stages) while resetting checkpoints, \dump\ to export stage data to a new database, and \unwind\ to revert blocks either to a specific target block or by a number of blocks, supporting both online and offline modes. This replaces the previous separate CLI commands for these operations, consolidating stage-level debugging and maintenance into a single interface.

crates/cli/commands/src/stage · high confidence

The transaction pool's blob storage has been replaced with a new modular implementation in \crates/transaction-pool/src/blobstore\. This introduces an in-memory store (\InMemoryBlobStore\) and a disk-backed store (\DiskFileBlobStore\) that persists blob data to disk with deferred deletion. The system now supports EIP-7594 blob cells via a \BlobSidecarConverter\ that handles conversion from the standard sidecar format, and includes a \BlobStoreCanonTracker\ to monitor canonical blob transactions for cleanup upon finalization. The \BlobStore\ trait has been expanded to include methods for retrieving blobs by versioned hashes (v1, v2, v3, v4) and cell masks, enabling efficient lookups for both EIP-4844 and EIP-7594 blob data.

crates/transaction-pool/src/blobstore · high confidence

The \crates/revm\ crate now exposes \CachedReads\ and \CachedReadsDbMut\ to cache database reads during payload building, allowing repeated access to the same data without hitting the underlying database. It also introduces \StateProviderDatabase\ and \DatabaseStateProvider\ to adapt Reth's storage providers into revm's \Database\ and \DatabaseRef\ interfaces. Additionally, a new \witness\ module provides \ExecutionWitnessRecord\ to generate execution witnesses, including state proofs and ancestor block headers, for debugging and inspection.

crates/revm · high confidence

A new \EthConfig\ struct has been introduced in the RPC builder module to centralize and expose configuration options for the \eth\ namespace APIs. This change allows users to explicitly control various RPC behaviors, including the maximum gas cap for calls and estimates, limits for tracing and blocking I/O requests, block ranges for filters and simulations, and specific behaviors for pending blocks and raw transaction forwarding. This provides a unified entry point for tuning RPC performance and feature flags without modifying internal defaults directly.

crates/rpc/rpc-eth-types/src/builder · high confidence

The RPC layer now includes a new \EthStateCache\ implementation in \crates/rpc/rpc-eth-types/src/cache\ that manages cached blocks, receipts, and EVM BALs. This cache is governed by \EthStateCacheConfig\, allowing users to configure entry counts (e.g., \max\_blocks\, \max\_receipts\, \max\_bals\) and memory budgets (e.g., \max\_blocks\_bytes\, \max\_receipts\_bytes\, \max\_bals\_bytes\) for each cache type. It also supports idle timeout-based eviction (\idle\_timeout\) and limits concurrent database requests (\max\_concurrent\_db\_requests\). The cache tracks metrics such as hit/miss counts and memory usage, and supports prewarming BALs and caching computed BALs for transaction tracing.

crates/rpc/rpc-eth-types/src/cache · high confidence

The ExEx backfill subsystem now uses a \BackfillJobFactory\ to construct backfill jobs, allowing users to configure execution thresholds (such as a 30-second max duration limit), prune modes, and stream parallelism (defaulting to 4 concurrent tasks). The backfill logic has been refactored to support both batched execution (yielding \Chain\ objects) and single-block execution, with the ability to run these jobs asynchronously via a \StreamBackfillJob\ that processes blocks in parallel while maintaining order. This change introduces the core infrastructure for efficient, configurable historical block replay in external exex components.

crates/exex/exex/src/backfill · high confidence

The \examples/node-custom-rpc\ example now demonstrates how to extend the node's RPC interface with a custom \txpoolExt\ namespace. Users can enable this extension via the \--enable-ext\ CLI flag to access new methods: \txpoolExt\_transactionCount\ to query the pool size, \txpoolExt\_clearTxpool\ to clear pending transactions, and a new \txpoolExt\_subscribeTransactionCount\ subscription that periodically pushes pool size updates. The example also migrates to \jsonrpsee\ 0.25 and uses the generic \ChainSpecParser\ for CLI configuration.

examples/node-custom-rpc · high confidence

Added a new example at \examples/custom-dev-node\ that shows how to programmatically launch a custom development Ethereum node and submit a transaction via RPC. The example configures a custom chain spec with specific genesis parameters, initializes the node using the \EthereumNode\ and \NodeBuilder\ APIs, and demonstrates sending a raw transaction and verifying its inclusion in the canonical state stream.

examples/custom-dev-node · high confidence

The db-access example has been introduced to show how to interact with the blockchain database using read-only providers. It demonstrates querying headers, blocks, transactions, and receipts via traits like HeaderProvider, BlockReader, TransactionsProvider, and ReceiptProvider, and shows how to construct address/topic filters for log queries.

examples/db-access · high confidence

The \crates/e2e-test-utils/src/testsuite\ module introduces a new framework for writing end-to-end tests, providing a \TestBuilder\ for configuring test environments and a comprehensive set of pre-built actions (such as \AssertMineBlock\, \ProduceBlocks\, \CreateFork\, and \BroadcastLatestForkchoice\) to perform blockchain operations. The framework supports multi-node coordination, explicit storage mode configuration (including v2 storage), and integrates with CI workflows via dedicated nextest filters. It also adds a \beacon\_engine\_handle\ to \NodeClient\ for direct consensus engine interaction and allows awaiting payload builds instead of using sleep-based waits.

crates/e2e-test-utils/src/testsuite · high confidence

The \crates/engine/util\ crate now provides stream wrappers to manipulate engine API message flows for debugging and testing purposes. Users can now skip a specified number of \ForkchoiceUpdated\ or \NewPayload\ messages, store incoming engine API messages to disk for later inspection and replay, and simulate chain reorganizations at a configurable frequency and depth.

crates/engine/util · high confidence

The \reth-engine-tree\ crate introduces a new architecture for advancing the blockchain, separating live sync (following the tip) from backfill sync (catching up over large ranges). It introduces a \ChainOrchestrator\ that coordinates an \EngineHandler\ for processing consensus API requests, a \BasicBlockDownloader\ for on-demand block retrieval, and a \PipelineSync\ for staged backfill. A new \PersistenceService\ runs on a background thread to handle block writes and pruning asynchronously, ensuring database operations do not block the critical consensus path. The crate also includes a builder (\EngineOrchestratorBuilder\) to wire these components together and provides metrics for download and persistence activities.

crates/engine/tree/src · high confidence

A new \era-utils\ crate has been introduced to manage the movement of block history between ERA files and node storage. It provides a unified pipeline via the \EraBlockReader\ trait, which supports reading from \.era1\, \.ere\/\.erae\, and consensus \.era\ files. The module exposes functions for importing (\import\, \process\_iter\) and exporting (\export\) blocks, handling receipt decoding for \.ere\ formats and skipping receipts for \.era\ files, while also managing stage checkpoints and index building.

crates/era-utils/src · high confidence

The \eth-wire\ crate now exposes dedicated error enums (\EthStreamError\ and \P2PStreamError\) to handle protocol-level failures. \EthStreamError\ covers issues specific to the Ethereum sub-protocol, including handshake mismatches (genesis, chain, version), message validation (size limits, unknown IDs, malformed transaction hashes), and stream timeouts. \P2PStreamError\ manages the underlying P2P connection, capturing I/O errors, RLP/Snappy decoding failures, handshake issues (timeout, no shared capabilities), and peer disconnects. These types provide structured error information, such as specific disconnect reasons and field-level validation details, enabling more precise error handling and logging for network connectivity and protocol compliance.

crates/net/eth-wire/src/errors · high confidence

The \tokio-util\ crate now exposes \EventSender\ and \EventStream\ types, providing a bounded multi-producer, multi-consumer broadcast channel for event listeners that automatically skips lag errors. Additionally, a \RateLimit\ type has been added to enforce specific request rates over time periods, allowing callers to wait or poll for readiness before proceeding.

crates/tokio-util · high confidence

The \examples/full-contract-state\ directory now contains a Rust application that demonstrates how to retrieve the complete state of a specific smart contract from a reth database. The example connects to the database in read-only mode and retrieves the account's balance, nonce, code hash, and bytecode. It also iterates through all storage slots, automatically handling both plain-keyed and hashed-keyed storage modes depending on the node's configuration, and prints the results to the console.

examples/full-contract-state · high confidence

The \reth-evm-execution-types\ crate has been introduced to centralize types related to EVM block execution. It provides \Chain\ to represent a sequence of blocks with their final state, trie data, and EIP-7928 block access lists; \ExecutionOutcome\ to aggregate post-execution state changes, receipts, and EIP-7685 requests across multiple blocks; and \BlockExecutionOutput\ to pair a block's execution result with its resulting state. The crate also includes \RecoveredBlockAndExecutionOutput\ for shared ownership of blocks and their outputs, and supports \no\_std\ environments with optional bincode-compatible serialization.

crates/evm/execution-types · high confidence

The node builder now uses a new, generic component architecture defined in \crates/node/builder/src/components\. This introduces a \ComponentsBuilder\ that manages the lifecycle of standalone components (transaction pool) and service components (network, payload builder, executor, consensus) through dedicated builder traits (\PoolBuilder\, \NetworkBuilder\, \PayloadServiceBuilder\, \ExecutorBuilder\, \ConsensusBuilder\). Users can now customize these components via a fluent API (e.g., \map\_pool\, \map\_network\) and override specific behaviors, such as using a \NoopPayloadServiceBuilder\ for non-validating nodes or configuring pool limits via \PoolBuilderConfigOverrides\.

crates/node/builder/src/components · high confidence

The \trie\_cursor\ module has been restructured to introduce a new in-memory trie cursor (\InMemoryTrieCursor\) that overlays trie updates on top of database cursors, giving precedence to in-memory data. A new \DepthFirstTrieIterator\ provides post-order traversal of trie nodes, and \InstrumentedTrieCursor\ adds Prometheus metrics for cursor operations like \seek\, \seek\_exact\, and \next\. The module also includes \NoopTrieCursorFactory\ for empty cursors, \MockTrieCursorFactory\ for testing, and \CursorSubNode\ for subtrie iteration.

_crates/trie/trie/src/trie\cursor · high confidence

Users can now initialize the node's state from a JSONL dump using the new \init-state\ CLI command. This command supports a \--without-evm\ flag, which allows importing state without relying on EVM historical data by creating a dummy chain up to the last EVM block and appending the first provided block. It also accepts optional \--header\ and \--header-hash\ arguments to specify the header in RLP format, enabling initialization at non-genesis blocks.

_crates/cli/commands/src/init\state · high confidence

A new \mdbx-sys\ crate has been added to provide Rust bindings for the libmdbx database library. This crate includes configuration for the Reth logo and favicon in generated documentation, enables the \doc\_cfg\ feature for documentation builds, and applies a set of lint allowances (including clippy) to handle the generated code. It also includes a warning for unused crate dependencies outside of test builds.

crates/storage/libmdbx-rs/mdbx-sys/src · high confidence

The \crates/metrics/src/common\ module now exposes \mpsc\ wrappers (\MeteredSender\, \UnboundedMeteredSender\, etc.) that instrument Tokio's multi-producer single-consumer channels. These wrappers automatically increment counters for messages sent, received, and errors encountered, providing users with built-in metrics for debugging channel behavior and monitoring throughput without manual instrumentation.

crates/metrics/src/common · high confidence

The \crates/node/metrics\ crate now provides a dedicated module for exposing node state as Prometheus metrics. It registers gauges for chain specification details (via \chain\_spec\), storage configuration including pruning mode and layout version (via \storage\_settings\), and build/version metadata (via \info\). It also exposes process CLI arguments (with values stripped for security) and provides a configurable hooks system that supports both synchronous collection and asynchronous background collection to prevent scraping stalls. The metrics server integrates these components, supports pushing metrics to a gateway, and handles the Prometheus recorder lifecycle.

crates/node/metrics · high confidence

The CLI argument definitions in \crates/node/core/src/args\ have been reorganized into dedicated modules for specific configuration domains. New argument structs have been introduced to handle \DatadirArgs\ (data directory paths), \DevArgs\ (dev testnet settings like block time and finality depth), \JitArgs\ (JIT compilation options), \EraArgs\ (ERA1 block import), \GasPriceOracleArgs\ (GPO configuration), \MetricArgs\ (Prometheus metrics), and \TraceArgs\ (OTLP tracing). This modularization groups related flags (e.g., \--datadir.\\, \--dev.\\, \--jit.\*\) and provides global default mechanisms for each domain, improving CLI structure and configurability.

crates/node/core/src/args · high confidence

The pruner now uses a new modular segment architecture in \crates/prune/prune/src/segments/user\ to handle user-facing pruning tasks. This change introduces dedicated segments for Account History, Storage History, Bodies (transactions), Receipts, Receipts by Logs, Sender Recovery, and Transaction Lookup. These segments coordinate pruning across both the database and static files, with specific logic for handling storage v2 (RocksDB) versus legacy storage, ensuring that dependent segments like Bodies wait for Transaction Lookup progress before deleting transaction data.

crates/prune/prune/src/segments/user · high confidence

The \crates/net/network/src/test\_utils\ module now provides a consolidated set of helpers for network integration testing. It introduces a \Testnet\ struct to manage multiple concurrent peers, utility functions to automatically find unused TCP/UDP ports, and specific helpers to instantiate \TransactionsManager\ instances and mock network sessions. These tools allow developers to spin up isolated test environments with configurable transaction pools and peer metadata without manual port management or session setup.

_crates/net/network/src/test\utils · high confidence

The \crates/net/peers\ crate has been introduced to centralize network peer types and bootnode configuration. It defines core types including \NodeRecord\ (IP, ports, and peer ID), \TrustedPeer\ (supporting domain names with blocking or async resolution), and \AnyNode\ (a unified enum for deserializing various peer formats). The crate also provides static lists and parsing functions for Ethereum Foundation bootnodes across Mainnet, Sepolia, Holesky, and Hoodi networks, replacing previous scattered definitions.

crates/net/peers · high confidence

Added a new example (\examples/network-txpool\) that shows how to run the network as a standalone component alongside a transaction pool and a custom validator. The example configures a \NetworkManager\ with \EthNetworkPrimitives\, initializes a \Pool\ using \OkValidator\ and \CoinbaseTipOrdering\, and spawns tasks for both the network and the pool to listen for and print incoming transactions.

examples/network-txpool · high confidence

The \crates/node/builder\ module introduces a new standalone crate for configuring and launching Reth nodes. It provides a structured builder pattern including \NodeHooks\ for lifecycle events (component initialization, node start), \RpcHooks\ for RPC server configuration, and \EngineApiExt\ to allow callbacks on the built Engine API. The crate also adds support for Execution Extensions (ExEx) via \LaunchExEx\ and \BoxedLaunchExEx\ traits, a \NodeHandle\ for managing the launched node's exit future, and helper utilities like \BlockReaderFor\ aliases and \txpool\_prewarm\ sources. This refactors the node construction logic into a more composable and extensible architecture.

crates/node/builder/src · high confidence

The \crates/node/events\ crate has been introduced to centralize node event handling. It adds a \ConsensusLayerHealthEvents\ stream that monitors the Consensus Layer client, emitting warnings if forkchoice updates are not received for over 120 seconds or if none are ever seen. Additionally, it provides a \NodeState\ handler that processes pipeline events to log stage progress, checkpoints, and estimated time of arrival (ETA), while also tracking the latest block and head/safe/finalized block hashes.

crates/node/events · high confidence

The \reth-payload-primitives\ crate now exposes a new \events\ module that provides \PayloadEvents\ and dedicated streams (\BuiltPayloadStream\, \PayloadAttributeStream\) for observing payload lifecycle events. Users can now subscribe to a broadcast channel to receive either the payload attributes received from the consensus layer or the built payloads, allowing for more granular event-driven handling of payload building processes.

crates/payload/builder-primitives · high confidence

A new \Receipts\ segment has been added to the static-file module, enabling the export of transaction receipts to static files. This implementation iterates through a specified block range, retrieves receipt data via database cursors, and writes it to static file segments using a dedicated writer, thereby offloading receipt storage from the main database.

crates/static-file/static-file/src/segments · high confidence

The \reth-cli-util\ crate has been introduced to centralize common CLI utilities. It provides a custom allocator module that supports jemalloc and snmalloc on Unix systems, with optional Tracy profiler integration via the \tracy-allocator\ feature. A new \CancellationToken\ and \CancellationGuard\ enable thread-safe, cooperative task cancellation. CLI parsing helpers have been added, including \parse\_duration\_from\_secs\_or\_ms\ (supporting \ms\ suffixes), \parse\_socket\_address\, \parse\_ether\_value\, and \hash\_or\_num\_value\_parser\. Secret key management is handled via \get\_secret\_key\ (loading or generating keys from files) and \parse\_secret\_key\_from\_hex\. Additionally, a SIGSEGV signal handler is included for Unix systems to print stack traces on crashes.

crates/cli/util · high confidence

Added \scripts/compare-witness-recent.sh\ to fetch and compare \debug\_executionWitness\ outputs between a local node and a remote RPC, normalizing JSON to detect differences in state, codes, keys, and headers. Also added \scripts/patch-alloy.sh\ to automatically append \\[patch.crates-io\]\ entries to \Cargo.toml\, allowing developers to test against specific branches of the \alloy-rs/alloy\ and \alloy-rs/evm\ repositories.

scripts · high confidence

The \reth-stages-types\ crate now exposes core types for the staged sync pipeline, including \StageId\ with a defined set of stages (such as Era, Execution, Prune, and MerkleExecute) and helper methods to identify downloading or finish stages. It introduces \MerkleCheckpoint\ and \StorageRootMerkleCheckpoint\ to persist Merkle trie progress, supporting optional \reth-codec\ serialization and an \account-ext\ feature for account extensions. Additionally, \ExecutionStageThresholds\ allows configuring commit triggers based on blocks, changes, gas, or duration, while \PipelineTarget\ standardizes sync and unwind targets.

crates/stages/types · high confidence

The \crates/rpc/rpc-server-types\ crate has been introduced to centralize RPC server configuration. It defines default constants for server ports (HTTP, WS, Auth), IPC endpoints, and resource limits such as maximum blocks per filter, concurrent blocking I/O requests, and cache sizes for blocks, receipts, and transaction hashes. The crate also provides the \RpcModuleSelection\ type, which manages the selection of enabled RPC modules (e.g., \eth\, \net\, \web3\) and enforces that the \testing\ namespace requires explicit selection, along with helper traits and functions for converting internal errors into standardized JSON-RPC responses.

crates/rpc/rpc-server-types · high confidence

Added a new example in \examples/network\ that demonstrates how to initialize and run the \NetworkManager\ as a standalone component. The example shows how to configure the network with a test runtime and mainnet boot nodes, spawn the network task, and listen for network events.

examples/network · high confidence

The storage provider layer has been restructured to introduce a new \BlockchainProvider\ and \ConsistentProvider\ that manage both database and in-memory state, ensuring consistent snapshots for lookups. This change adds native support for RocksDB as a storage backend alongside existing options, exposing specific RocksDB types and batch handling. Additionally, a new \StorageRevertsIter\ utility has been added to correctly merge and sort storage reverts and wiped entries during state transitions.

crates/storage/provider/src/providers · high confidence

The e2e testing framework now exposes a set of composable action types in \crates/e2e-test-utils/src/testsuite/actions\ to simplify complex engine API tests. Users can now use \SendForkchoiceUpdate\ and \FinalizeBlock\ to send custom forkchoice updates with specific finalized, safe, and head block references (including tags and 'latest') and verify expected payload statuses. \SendNewPayload\ and \SendNewPayloads\ allow sending new payload requests to specific nodes with retry logic and expected status validation. \CreateFork\ and \ReorgTo\ enable creating forks from specific block numbers or tags and performing reorganizations by targeting tagged blocks. \MakeCanonical\ provides a convenient way to make the latest block canonical, optionally broadcasting to all nodes or just the active one. \SelectActiveNode\, \CompareNodeChainTips\, and \CaptureBlockOnNode\ support multi-node testing by allowing tests to switch context between nodes, compare chain states, and tag blocks for later reference. These actions are orchestrated via the \Sequence\ type and the \Action\ trait, providing a more robust and readable way to write end-to-end tests for consensus engine behavior.

crates/e2e-test-utils/src/testsuite/actions · high confidence

Added a new \test\_utils\ module to the transaction pool crate, providing \MockTransaction\ types that support all EIP transaction variants (Legacy, EIP-2930, EIP-1559, EIP-4844, and EIP-7702) along with a \TestPool\ builder for configuring mock validators, ordering, and blob stores. The module also includes an \OkValidator\ that accepts all transactions and a \TransactionGenerator\ for creating signed test transactions with configurable signers, base fees, and gas limits.

_crates/transaction-pool/src/test\utils · high confidence

The trie module now includes a new \changesets\ module that computes trie changesets (the old node values before a block was applied) from trie updates, enabling chain reorganizations by preserving the state prior to block execution. Additionally, a new \ForwardInMemoryCursor\ has been added, which provides a forward-only cursor over pre-sorted in-memory collections, utilizing binary search for large slices (\>=128 entries) and linear scan for smaller ones to optimize performance. These changes are part of the broader trie update and reorg support infrastructure.

crates/trie/trie/src · high confidence

The \examples/txpool-tracing\ directory now contains a new example application that demonstrates how to trace pending transactions and submit new ones to the transaction pool. The main entry point (\main.rs\) launches a node and subscribes to the pending pool, allowing users to specify recipient addresses via CLI arguments to filter which transactions are traced using the \trace\_call\ API. Additionally, \submit.rs\ provides helper functions to create, sign, and submit transactions (including ETH transfers) to the pool, utilizing the new \add\_consensus\_transaction\ and \add\_consensus\_transaction\_and\_subscribe\ methods on the \TransactionPool\ interface.

examples/txpool-tracing · high confidence

The node builder in \crates/node/builder\ has been restructured to use a state-machine pattern, introducing new types like \NodeBuilderWithTypes\, \NodeBuilderWithComponents\, and \NodeAdapter\ to track configuration progress. This change adds a dedicated \AddOns\ container that groups hooks, execution extensions (ExExs), and custom node addons, allowing users to extend the node's RPC and lifecycle behavior more cleanly after components are initialized.

crates/node/builder/src/builder · high confidence

The engine now executes blocks containing an EIP-7928 Block-Level Access List (BAL) using a parallel worker pool. Transactions are processed concurrently against the BAL state, and results are reassembled in strict transaction order to ensure correct block-gas admission and error adjudication. This path validates the rebuilt BAL hash post-execution and provides specific error handling for decoding failures and speculative worker errors.

_crates/engine/tree/src/tree/payload\processor/bal · high confidence

The repository has been updated with new configuration files to standardize development and build processes. A new AGENTS.md file provides guidance for AI coding agents, while .editorconfig enforces consistent coding styles across editors. The .dockerignore file has been rewritten to explicitly include necessary source files and exclude unnecessary ones for Docker builds. New Dockerfiles (Dockerfile, Dockerfile.depot, Dockerfile.reproducible) define build and runtime environments, including support for reproducible builds and platform-specific optimizations. The Makefile has been expanded with new targets for building, testing, and creating release artifacts, including support for cross-compilation and Debian package generation. Additionally, Cross.toml has been added to configure cross-compilation settings, and HARDFORK-CHECKLIST.md provides a guide for integrating changes for upcoming hard forks.

(repo-wide) · high confidence

The \crates/evm/evm\ crate has been reorganized to provide a cleaner, more modular EVM execution interface. This change introduces a new \Executor\ trait for block execution, a \ConfigureEvm\ trait for unified EVM configuration, and a \ConfigureEngineEvm\ extension for payload building. It adds support for parallel transaction recovery and execution via the \ExecutableTxTuple\ and \EitherIter\ types, allowing for more efficient block processing. Additionally, a shared \SenderRecoveryCache\ is introduced to optimize transaction sender recovery across different execution paths, and new metrics are added to track execution performance.

crates/evm/evm · high confidence

The snap sync module now exposes a \SnapClient\ trait that defines the API for requesting account ranges, storage ranges, byte codes, and block access lists (snap/2) from peers, along with a \SnapResponse\ enum to handle the corresponding data. This change introduces the client-side contract for snap sync operations, including a noop implementation that returns unsupported errors, enabling other components to request snap sync data through a standardized interface.

crates/net/p2p/src/snap · high confidence

The \crates/static-file/types\ crate now defines the core types for the static file system, including the \StaticFileSegment\ enum with \AccountChangeSets\ and \StorageChangeSets\ variants alongside existing segments like \Headers\ and \Transactions\. It introduces \ChangesetOffsetWriter\ and \ChangesetOffsetReader\ to manage append-only, fixed-width sidecar files for O(1) random access to changeset offsets, featuring crash-safe healing logic. The crate also adds a \Compression\ enum supporting LZ4, Zstandard, and Zstd-with-dictionary, and provides utilities for calculating static file block ranges based on prune distances.

crates/static-file/types · high confidence

The src/lib.rs file has been deleted, removing the library source code that was previously located at this path.

src · high confidence

The placeholder main entry point for the reth binary (bin/reth.rs) has been removed. This file previously contained a simple 'Hello, world!' stub, indicating it was not yet a functional component of the product.

bin · high confidence

The peer management types—such as PeerAddr, Peer, PeersConfig, and reputation logic—have been moved from the network API and implementation crates into the new reth-network-types crate. This refactoring centralizes the data structures and configuration used for peer discovery, connection state, and reputation tracking, reducing coupling between the network API and the underlying p2p implementation.

crates/net/network-types/src/peers · high confidence

The state provider logic is now split into dedicated modules: \latest.rs\ implements \LatestStateProviderRef\ for accessing the current chain state (including account, storage root, and proof capabilities), while \historical.rs\ provides the \HistoryInfo\ enum and lookup utilities for resolving historical account and storage values across pruned history shards. The \mod.rs\ file exposes these two modules, structuring the provider crate to clearly separate latest and historical state access patterns.

crates/storage/provider/src/providers/state · high confidence

A new \reth-node-api\ crate has been created to centralize the configuration traits and builder types for the node. This change extracts and re-exports key primitives from \reth-engine-primitives\, \reth-payload-primitives\, and \reth-payload-builder-primitives\, while defining the \FullNodeTypes\, \FullNodeComponents\, and \NodeAddOns\ traits. These traits establish the standardized interface for node components (such as the transaction pool, EVM configuration, consensus, and network) and provide the extension point for launching add-ons like RPC servers during node startup.

crates/node/api · high confidence

The implementation of the \EthApi\ trait in \crates/rpc/rpc/src/eth/helpers\ has been reorganized into separate modules (\bal\, \block\, \call\, \fees\, \pending\_block\, \receipt\, \signer\, \spec\, \state\, \subscriptions\, \sync\_listener\, \trace\, \transaction\, \types\). This change splits the previously large, monolithic implementation into focused files corresponding to specific RPC capabilities (e.g., block access lists, transaction sending, fee history, state access). The \signer\ module now includes a \DevSigner\ implementation for generating deterministic developer accounts from mnemonics, and the \transaction\ module implements \EthTransactions\ with logic for forwarding raw transactions and handling blob sidecar upcasting. This modularization improves code maintainability and separation of concerns within the RPC layer.

crates/rpc/rpc/src/eth/helpers · high confidence

The \reth-stages\ crate has been restructured to improve code organization. The previous single-file implementation has been split into distinct modules: \lib.rs\ for the main crate documentation and re-exports, \prelude.rs\ for convenient access to stage sets, \sets.rs\ for the definitions of built-in stage collections like \DefaultStages\, \OnlineStages\, and \OfflineStages\, and a \stages/\ subdirectory for individual stage implementations. This change is purely structural and does not alter the syncing behavior or API surface for users.

crates/stages/stages/src · high confidence

The \eth\ namespace RPC implementation has been reorganized into distinct modules (\builder\, \core\, \filter\, \pubsub\, \bundle\, \sim\_bundle\) to improve modularity and configuration. A new \EthApiBuilder\ provides a fluent interface for constructing the \EthApi\ handler, allowing explicit configuration of components like the EVM config, transaction pool, network, and state cache. The core \EthApi\ struct now delegates to specialized handlers: \EthFilter\ for \eth\_getLogs\ and filter management, \EthPubSub\ for subscriptions (\eth\_subscribe\), \EthBundle\ for legacy call bundles, and \EthSimBundle\ for the newer \mev\_simBundle\ API. This change centralizes the construction logic and separates concerns, making the RPC layer easier to extend and maintain.

crates/rpc/rpc/src/eth · high confidence

The transaction validation logic has been reorganized into a new \crates/transaction-pool/src/validate\ module, introducing a clear separation between validation abstractions and execution. This change introduces \constants.rs\ to define validation limits like \TX\_SLOT\_BYTE\_SIZE\ and \DEFAULT\_MAX\_TX\_INPUT\_BYTES\, and \mod.rs\ to expose the core \TransactionValidator\ trait and \TransactionValidationOutcome\ types. The \eth.rs\ file now houses the \EthTransactionValidator\ implementation, while \task.rs\ provides the \ValidationTask\ and \TransactionValidationTaskExecutor\ to handle asynchronous, non-blocking validation jobs. This restructuring centralizes validation rules and improves the maintainability of the transaction pool's validation layer.

crates/transaction-pool/src/validate · high confidence

A change to existing behaviour in crates/exex/exex/test-data — 3 commits (1 fix), 2 files.

crates/exex/exex/test-data · medium confidence · unverified

The build process now generates comprehensive version information for the node core, including short and long version strings, commit SHA, build timestamp, build features, and build profile. It also sets environment variables for the P2P client version string and determines a development suffix based on whether the build is dirty or not on a tag.

crates/node/core · high confidence

The CLI module now re-exports command-line types from the newly separated \reth\_node\_core\ and \reth\_ethereum\_cli\ crates. This change maintains backward compatibility for existing users by keeping the public API surface in the same location, even though the underlying implementations have been moved to their own dedicated crates.

bin/reth/src/cli · high confidence

The \crates/storage/libmdbx-rs/src\ module has been entirely replaced with a new implementation of the MDBX database bindings. This rewrite introduces a \TableObject\ trait for decoding values, a new \Database\ handle type, and a \ReadTxnPool\ that caches reset read-only transaction handles to avoid reader table mutex contention. It also adds a dedicated \TxnManager\ thread for handling transaction lifecycle messages and supports configurable sync modes and read transaction timeouts.

crates/storage/libmdbx-rs/src · high confidence

The Ethereum payload builder now exposes \EthereumBuilderConfig\, allowing users to configure the desired gas limit, set extra data for built blocks, enable skipping state-root computation, and define a maximum number of blobs per block (EIP-7872). The builder's behavior when a payload is missing is now controlled by the \await\_payload\_on\_missing\ setting, which determines whether to wait for an in-progress build or race an empty payload. Additionally, the \EthereumExecutionPayloadValidator\ has been introduced to enforce consensus rules across multiple hardforks (Shanghai, Cancun, Prague, and Amsterdam) when validating incoming execution payloads.

crates/ethereum/payload · high confidence

The Engine API now includes a dedicated capabilities module that tracks supported methods and performs mismatch detection during the \engine\_exchangeCapabilities\ handshake. It distinguishes between critical methods (such as \engine\_forkchoiceUpdated\, \engine\_getPayload\, and \engine\_newPayload\) and unstable methods for upcoming hardforks, ensuring that warnings are only emitted for critical mismatches while suppressing noise for unstable or non-essential endpoints. This change improves operator visibility into version mismatches between the consensus and execution layers without triggering false alarms for methods that are not yet fully standardized or universally supported.

crates/rpc/rpc-engine-api/src · high confidence

The \crates/engine/primitives\ module has been reorganized to centralize engine tree configuration, error handling, and event definitions. A new \config.rs\ introduces \TreeConfig\ with explicit constants for persistence thresholds, backpressure limits, and sparse trie pruning, allowing users to tune memory usage and block buffering behavior. Error handling is refined in \error.rs\ with distinct \BeaconOnNewPayloadError\ and \BeaconForkChoiceUpdateError\ types that properly separate malformed input (invalid params) from internal failures, ensuring correct API responses. Event tracking in \event.rs\ now includes \InvalidBlock\ and \SlowBlock\ events for better observability, while \forkchoice.rs\ provides a dedicated \ForkchoiceStateTracker\ and \ForkchoiceStatus\ enum to manage forkchoice state transitions. The module also exports \EngineTypes\ and \EngineApiValidator\ traits, standardizing how engine API requests are validated before processing.

crates/engine/primitives · high confidence

The \reth-network-types\ crate now exposes core networking configuration structs, including \SessionsConfig\ and \SessionLimits\ for managing peer session buffers and connection caps, as well as \BackoffKind\ to define severity levels for peer backoff strategies. This change centralizes these common types, making them available for configuration and reuse across the network stack.

crates/net/network-types/src · high confidence

The proof generation module now supports a new V2 multiproof algorithm (\multiproof\_v2\) that combines extension and branch nodes in the output and optionally collects branch node hash masks. Users can enable mask collection via the \with\_branch\_node\_masks\ configuration flag, which is required for accurate state root calculation when keys are added or removed from the trie. This change replaces the previous proof logic with a more efficient V2 calculator that handles account and storage proofs using synchronized account value encoding.

crates/trie/trie/src/proof · high confidence

The \reth-evm-ethereum\ crate has been restructured to use a new composable execution strategy. It now exposes \EthEvmConfig\ as the primary configuration type, which wires together \EthBlockExecutorFactory\ for transaction execution and a new \EthBlockAssembler\ for constructing final blocks. The \EthBlockAssembler\ handles the assembly of block headers and bodies, including logic for hardfork-specific fields like withdrawals (Shanghai), blob gas (Cancun/Osaka), and requests (Prague). Additionally, the crate integrates \revmc\ JIT compilation support via \RethEvmFactory\ (behind the \jit\ feature flag) and provides a \RethReceiptBuilder\ for generating receipts using \alloy\_evm\ primitives.

crates/ethereum/evm/src · high confidence

The database layer now enforces schema versioning by writing a \database.version\ file (currently v2) during initialization and rejecting startup if the existing database version mismatches, preventing corruption from incompatible schema changes. Additionally, the system now detects if the database directory resides on a ZFS filesystem and logs a warning, as ZFS's copy-on-write semantics are known to cause significant performance degradation with the MDBX storage engine.

crates/storage/db/src · high confidence

The \reth-execution-errors\ crate now provides a centralized set of error types for block execution and state trie operations. This includes \StateRootError\, \StorageRootError\, \StateProofError\, and specific sparse trie errors (\SparseStateTrieError\, \SparseTrieError\, \TrieWitnessError\), which replace previous ad-hoc error handling. These types implement \thiserror\ for user-friendly display and provide conversions to \ProviderError\ and \DatabaseError\, allowing execution logic to report trie inconsistencies, database issues, and RLP decoding failures with structured context.

crates/evm/execution-errors · high confidence

The Ethereum CLI is now structured around a generic \CliApp\ wrapper and a \ChainSpecParser\ trait, allowing the command-line interface to be extended with custom subcommands and external arguments. This change introduces configurable tracing layers, including support for exporting logs and traces via OTLP, and allows users to tune the runtime environment by specifying dedicated thread counts for proof workers and prewarming tasks. The CLI also now supports the Hoodi testnet and validates RPC module selections before node startup.

crates/ethereum/cli · high confidence

The bodies downloader module has been restructured to support generic block types and run asynchronously on a dedicated task. The new \BodiesDownloader\ is generic over the \Block\ type and uses a \HeaderProvider\ to fetch headers for validation, ensuring downloaded bodies match the expected chain state. A \TaskDownloader\ wrapper spawns the download logic on a background runtime, decoupling the network I/O from the main stream. The implementation includes strict body validation via the \Consensus\ trait, metrics tracking for buffered blocks and in-flight requests, and a \NoopBodiesDownloader\ for unwind-only pipelines.

crates/net/downloaders/src/bodies · high confidence

The \EthBeaconConsensus\ engine in the Ethereum consensus crate now exposes builder methods to toggle specific validation checks, allowing users to skip the gas limit ramp check, blob gas used check, requests hash check, and pre-Amsterdam BAL hash validation. This change also adds post-execution validation logic that verifies the block access list hash against the header when the Amsterdam hardfork is active, ensuring stricter consistency for blocks containing access lists.

crates/ethereum/consensus · high confidence

The \reth-prune-types\ crate now enforces a minimum retention of 64 blocks for receipts and bodies (via the new \MINIMUM\_DISTANCE\ constant) and a higher safety margin for account and storage history (via \MINIMUM\_UNWIND\_SAFE\_DISTANCE\). The \PruneModes\ struct includes a \migrate\ method that automatically upgrades invalid or overly aggressive receipt pruning configurations (such as \Full\ or \Distance\ values below 64) to the safe \Distance(64)\ default. Additionally, \ensure\_unwind\_target\_unpruned\ now validates that chain unwinding targets do not exceed the pruned history limits for account and storage segments, preventing unsafe state transitions.

crates/prune/types · high confidence

The storage layer now supports a new v2 layout that moves receipts, transaction senders, and account/storage changesets to static files while shifting history indices (accounts, storages, transaction hashes) to RocksDB. This is controlled by the new \StorageSettings\ struct (defaulting to v2), which exposes flags such as \storage\_v2\, \receipts\_in\_static\_files\, and \use\_hashed\_state\. The diff also adds concrete database models for these changes, including \BlockNumberAddress\ and \AddressStorageKey\ for history indexing, \StoredBlockAccessList\ for block access lists, \StoredBlockOmmers\ (generic over header), \IntegerList\ (Roaring bitmap-backed) for efficient integer storage, and stack-allocated \ShardedKey\/\StorageShardedKey\ types to reduce heap allocations in hot paths. Snap sync state is tracked via \SnapAttempt\ to manage download attempts and prevent premature completion, and partial trie unwinds are supported via \PartialStateTrieUnwindMarker\.

crates/storage/db-api/src/models · high confidence

The build script for the MDBX storage library has been updated to improve compatibility and performance. It now disables posix\_fallocate to prevent spurious ENOSPC errors on filesystems like ZFS, disables Linux mincore residency probes, and propagates the Rust target-cpu flag to the C compiler for native optimization. Debug logging is enabled in debug builds and disabled in release builds. Additionally, the bindgen configuration blocks the deprecated MDBX\_NOTLS symbol and correctly maps specific MDBX integer macros to signed or unsigned Rust types.

crates/storage/libmdbx-rs/mdbx-sys · high confidence

The header download logic has been reorganized into a new \crates/net/downloaders/src/headers\ module, exposing four distinct implementations: \ReverseHeadersDownloader\ for concurrent, reverse-order chain synchronization; \TaskDownloader\ to run downloaders in background Tokio tasks; \NoopHeaderDownloader\ for unwind-only pipelines; and \test\_utils\ for testing. This change provides a structured, modular entry point for header downloading capabilities previously scattered across the codebase.

crates/net/downloaders/src/headers · high confidence

The node builder's launch logic has been restructured around a new type-state pattern centered on \LaunchContext\ and \LaunchContextWith\<T\>\. This change enforces correct initialization order at compile time, ensuring that components like configs, database providers, and node components are attached in the required sequence. The \EngineNodeLauncher\ now utilizes this context to orchestrate the startup sequence, including loading TOML configurations, resolving peers, initializing the provider factory with an overlay manager, and launching execution extensions via the new \ExExLauncher\. Additionally, a \DebugNodeLauncher\ is introduced to support debugging utilities such as RPC consensus clients and Etherscan integration, while \InvalidBlockHook\ creation is moved into the launch context's add-ons.

crates/node/builder/src/launch · high confidence

The NippyJar storage format now includes a dedicated consistency checker that automatically detects and repairs file corruption when a writer opens an existing jar. If the offsets file or data file size does not match the expected configuration (for example, due to an interrupted append or prune operation), the writer will truncate or adjust the files to restore a valid state before proceeding. This ensures that static file segments remain usable even after unexpected shutdowns or crashes, preventing read errors and data loss.

crates/storage/nippy-jar/src · high confidence

The Polygon P2P example has been updated to construct its chain configuration using the standard \reth\ \ChainSpec\ type instead of a custom or legacy format. This change aligns the example with the core node's chain specification handling, ensuring that fork configurations and genesis data are managed consistently with the rest of the client.

examples/polygon-p2p · high confidence

The pruning logic has been restructured into a modular architecture, introducing a \PrunerBuilder\ for configuration, a \PruneLimiter\ to enforce per-run deletion and time limits, and a \Segment\ trait to define individual pruning tasks. The pruner is now generic over \NodePrimitives\, allowing it to work with different primitive types, and integrates with \StaticFileProvider\ to handle static file segments. This change improves configurability, allowing users to set block intervals, delete limits, and timeouts, while also enhancing performance through bulk table clears and optimized iterator usage.

crates/prune/prune/src · high confidence

The \reth-storage-errors\ crate has been refactored to support \no\_std\ environments and introduces several new error types and variants. A new \AnyError\ type provides a thread-safe, cloneable wrapper for arbitrary errors, while \DatabaseError\ now includes a \Custom\ variant to wrap generic errors and a \LogLevelUnavailable\ variant for logging issues. \ProviderError\ has been expanded with new variants to handle specific scenarios, including \BlockExpired\ (when history has expired), \BlockNotExecuted\ (when requesting state for a block that hasn't been executed yet), \ConsistentView\ errors, and \MustUnwind\ errors to signal database inconsistencies detected during startup. Additionally, \StorageLockError\ has been simplified to remove the \Other\ variant in favor of a dedicated \Other(String)\ variant, and the crate now exports \ProviderResult\ for convenience.

crates/storage/errors · high confidence

The era file handling logic has been reorganized into a new \common\ module, introducing shared traits and utilities for reading, writing, and compressing era-format files (\.era\, \.era1\, and \.ere\). This change makes the era count optional in generated filenames, allowing for more flexible file naming conventions while maintaining compatibility with existing file structures. The refactoring consolidates compression helpers, decoding utilities, and file I/O operations into reusable components that support all three era file types.

crates/era/src/common · high confidence

The header synchronization module in the P2P network layer has been refactored to decouple from specific primitive implementations. The \HeadersClient\ and \HeaderDownloader\ traits are now generic over the \BlockHeader\ trait, allowing them to work with different block types. The internal \SyncTarget\ enum has been updated to use \BlockWithParent\ from \alloy\_eips\ instead of raw hashes or numbers, providing more context for sync gaps. Additionally, header validation logic now explicitly leverages the \HeaderValidator\ trait from the consensus module, ensuring that downloaded headers are validated against their parents and standalone rules before being processed.

crates/net/p2p/src/headers · high confidence

The \crates/era\ module now includes a complete implementation for reading and parsing Era files according to the e2store format specification. This change introduces the \EraFile\, \EraReader\, and \BeaconBlockIterator\ types, enabling users to stream and assemble Era data (including beacon blocks, states, and slot indices) from underlying readers. The implementation handles version validation, state assembly, and error reporting for missing or malformed entries, effectively restoring Era file functionality that was previously removed or refactored.

crates/era/src/era · high confidence

The RPC error module has been refactored to improve type safety and error mapping. New helper traits (\FromEthApiError\, \IntoEthApiError\, \AsEthApiError\, \FromEvmError\, \FromEvmHalt\, \FromRevert\) were added to \api.rs\ to standardize how generic L1 errors are wrapped into the network-specific \EthApiError\ and how EVM execution results (success, revert, halt) are converted into user-facing RPC errors. The \EthApiError\ enum in \mod.rs\ was expanded with new variants including \PrunedHistoryUnavailable\ (for EIP-4444 compliance), \HeaderRangeNotFound\, \ExceedsMaxProofWindow\, \InvalidRewardPercentiles\, and \ExecutionTimedOut\, while removing the \ResourceNotFound\ variant in favor of the more specific \PrunedHistoryUnavailable\. This change ensures that users receive more precise error codes and messages for historical data unavailability, transaction simulation failures, and execution timeouts.

crates/rpc/rpc-eth-types/src/error · high confidence

The pruning implementation has been reorganized into a modular structure under \crates/prune/prune/src/segments\, introducing distinct modules for receipts, user data, and segment sets. This change centralizes the \Segment\ trait and \PruneInput\ handling, while explicitly defining the execution order for pruning operations—ensuring transaction lookup runs before bodies to prevent data inconsistency when reading from static files. Users benefit from a more robust and maintainable pruning process that correctly handles static file deletions and checkpointing across different data types.

crates/prune/prune/src/segments · high confidence

The \reth\ binary now automatically enables Rust backtraces when a panic occurs, unless the \RUST\_BACKTRACE\ environment variable is already explicitly set. This change improves the debugging experience for users encountering unexpected crashes by providing detailed stack traces out of the box.

bin/reth/src · high confidence

The transaction management subsystem in \crates/net/network/src/transactions\ has been rewritten to introduce a new \TransactionFetcher\ and \TransactionsManager\ that support configurable transaction propagation modes (Sqrt, All, or Max peer count) and ingress policies (accepting transactions only from trusted peers). The fetcher now uses a state-based model with candidate peer tracking, eager fallback sources, and memory-bounded channels between the network and transaction managers. New configuration options allow tuning of inflight request limits, pending pool import caps, and seen-transaction history sizes, while constants enforce spec-compliant soft limits for broadcast messages and pooled transaction responses.

crates/net/network/src/transactions · high confidence

The static file provider implementation has been rewritten to use the NippyJar library for storing headers, transactions, receipts, and changesets. This change introduces a new \StaticFileJarProvider\ and \StaticFileWriters\ architecture that manages read/write access to these segments. A key behavioral improvement is the addition of crash-recovery logic for changeset offsets, which heals inconsistencies between the segment header, the NippyJar row count, and the sidecar \.csoff\ file to prevent data corruption. Additionally, the provider now exposes detailed metrics for segment operations (such as cursor initialization, append, and prune) to aid in monitoring performance and stability.

_crates/storage/provider/src/providers/static\file · high confidence

The \ChainHardforks\ structure now supports dynamic modification of hardfork schedules via new \insert\, \extend\, and \remove\ methods, allowing existing fork conditions to be updated or new ones added while maintaining correct ordering. Additionally, a new \DEV\_HARDFORKS\ configuration is introduced, activating all Ethereum hardforks from Frontier through Osaka at block 0 or timestamp 0, which facilitates testing and development environments by enabling immediate access to the latest protocol features.

crates/ethereum/hardforks/src/hardforks · high confidence

The sync stages (Header, Body, Era, Account/Storage Hashing, and History Indexing) now default to the v2 storage backend, which writes headers, transactions, and history indices to static files and uses RocksDB for database tables. This change introduces RocksDB-specific batch auto-commit and flush logic to prevent out-of-memory errors, adds consistency checks between static files and the database, and makes the stages generic over the node primitives to support the new storage architecture.

crates/stages/stages/src/stages · high confidence

The man pages for the MDBX environment utilities (mdbx\_chk, mdbx\_copy, mdbx\_drop, mdbx\_dump, mdbx\_load, and mdbx\_stat) have been updated to reflect the MDBX 0.13 release. This includes refreshed documentation for options such as the verbose flags in mdbx\_chk, the compact copy mode in mdbx\_copy, and the rescure modes in mdbx\_dump and mdbx\_load, ensuring the documentation matches the current library behavior.

crates/storage/libmdbx-rs/mdbx-sys/libmdbx/man1 · high confidence

Add BSC P2P example and update documentation; Added E2E tests for RocksDB provider functionality; Added Ethereum Foundation test suite runner and fixtures; Added Holesky sync test data; Added benchmark for saturated transaction pool eviction; Added benchmarks comparing legacy and V2 storage proof implementations; Added benchmarks for the TransactionFetcher; Added blob transaction test data; Added comprehensive test suite for libmdbx-rs bindings; Added comprehensive tests for trie database operations; Added e2e test suite examples for chain import and block production; Added e2e tests for forkchoice updates with finalized blocks; Added end-to-end tests for the snap/2 protocol; Added execution tests for EIP-4788 beacon root contract behavior; Added fuzzing and network decoding tests for eth-wire protocol messages; Added fuzzing infrastructure for table codecs; Added generic test suite for SparseTrie implementations; Added integration tests for ERA export and import functionality; Added integration tests for Ethereum node builder and testing RPC endpoints; Added integration tests for era and era1 file roundtrips and genesis decoding; Added integration tests for the ERA downloader; Added integration tests for transaction pool behavior; Added pipeline sync and selfdestruct behavior tests; Added roundtrip tests for .erae files; Added test utilities for block body downloading; Added tests for Engine API payload conversion and validation; Added tests for customizable dev CLI defaults; Expanded E2E test coverage for Ethereum node capabilities; Expanded network integration test coverage; Integration tests for ERA file formats; Integration tests for RPC builder server configuration and transport behavior; Integration tests for the \reth download\ CLI command; Introduce dedicated ef-tests crate for Ethereum Foundation test suite execution; New P2P test utilities for block bodies, headers, receipts, and full blocks; New RPC end-to-end compatibility tests for eth\_getLogs and eth\_syncing; New test utilities for provider testing; New test utilities for stage implementations.

A dependency / build maintenance change in (dependencies) — 3450 commits (271 fixs), 149 files.

(dependencies) · high confidence · unverified

The embedded libmdbx library used for local storage has been upgraded to version 0.13.12. This update brings the latest improvements and bug fixes from the libmdbx project to the database layer, ensuring better performance, reliability, and compatibility with modern build environments.

crates/storage/libmdbx-rs/mdbx-sys/libmdbx · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 65 → 64 (-0.5)
• Rubric changed (rubric-2026.09.10 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 86 → 87 (+0.3)
• Architecture 97 → 89 (-8.0)
• Maturity 77 → 77 (+0.1)
• Readiness 55 → 47 (-8.0)
• Security 60 → 75 (+14.9)
• Event Sourcing 100 → 100 (+0.0)
• Performance 87 (new)

• AdminApi::node_info (cognitive 50) (crates/rpc/rpc/src/admin.rs)
• AdminApi::node_info (cyclomatic 69) (crates/rpc/rpc/src/admin.rs)
• Change coupling: common.rs ↔ setup.rs (crates/node/builder/src/launch/common.rs)
• Change coupling: execution.rs ↔ common.rs (crates/cli/commands/src/stage/dump/execution.rs)
• Change coupling: historical.rs ↔ trie.rs (crates/storage/provider/src/providers/state/historical.rs)
• Change coupling: mem.rs ↔ noop.rs (crates/transaction-pool/src/blobstore/mem.rs)
• Change coupling: mem.rs ↔ noop.rs (crates/transaction-pool/src/blobstore/mem.rs)
• Change coupling: mock.rs ↔ tx_gen.rs (crates/transaction-pool/src/test_utils/mock.rs)
• Change coupling: noop.rs ↔ lib.rs (crates/consensus/consensus/src/noop.rs)
• Change coupling: noop.rs ↔ trie.rs (crates/storage/provider/src/test_utils/noop.rs)
• Change-coupling hub: db.rs → in_memory.rs, memory_overlay.rs, test_utils.rs, historical.rs, mock.rs, noop.rs, macros.rs, trie.rs (crates/rpc/rpc-eth-types/src/cache/db.rs)
• Change-coupling hub: test_utils.rs → memory_overlay.rs, historical.rs, mock.rs (crates/revm/src/test_utils.rs)
• Change-coupling hub: test_utils.rs → noop.rs, lib.rs, validation.rs (crates/consensus/consensus/src/test_utils.rs)
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Duplicated block (10 lines × 2) (crates/net/eth-wire-types/src/broadcast.rs)
• Duplicated block (11 lines × 2) (crates/trie/db/src/proof.rs)
• Duplicated block (14 lines × 3) (crates/storage/storage-overlay/src/provider.rs)
• Duplicated block (17 lines × 2) (crates/storage/db-common/src/init.rs)
• Duplicated block (20 lines × 2) (crates/trie/common/src/proofs.rs)
• Duplicated block (33 lines × 2) (crates/rpc/rpc/src/eth/builder.rs)
• …and 82 more

• Change coupling clique: noop.rs, test_utils.rs, lib.rs (crates/consensus/consensus/src/noop.rs)
• Change coupling: common.rs ↔ metrics.rs (crates/cli/commands/src/common.rs)
• Change coupling: engine_store.rs ↔ reorg.rs (crates/engine/util/src/engine_store.rs)
• Change coupling: in_memory.rs ↔ input.rs (crates/chain-state/src/in_memory.rs)
• Change coupling: mem.rs ↔ noop.rs (crates/transaction-pool/src/blobstore/mem.rs)
• Change coupling: mem.rs ↔ noop.rs (crates/transaction-pool/src/blobstore/mem.rs)
• Change coupling: rocksdb.rs ↔ metrics.rs (crates/storage/provider/src/bal/rocksdb.rs)
• Change coupling: rpc_state_cache.rs ↔ config.rs (crates/node/core/src/args/rpc_state_cache.rs)
• Change-coupling hub: common.rs → execution.rs, setup.rs, metrics.rs (crates/node/builder/src/launch/common.rs)
• Change-coupling hub: db.rs → in_memory.rs, test_utils.rs, historical.rs, mock.rs, noop.rs, macros.rs, trie.rs (crates/rpc/rpc-eth-types/src/cache/db.rs)
• Change-coupling hub: test_utils.rs → historical.rs, mock.rs, noop.rs (crates/revm/src/test_utils.rs)
• Change-coupling hub: trie.rs → in_memory.rs, historical.rs, noop.rs (crates/storage/storage-api/src/trie.rs)
• ClassTooLong: TreeConfig (crates/engine/primitives/src/config.rs)
• DecodedMultiProofV2::from_witness (cyclomatic 20) (crates/trie/common/src/proofs.rs)
• Discovery::new (cyclomatic 20) (crates/net/network/src/discovery.rs)
• Documentation: contradicts the code (docs/crates/network.md)
• Documentation: contradicts the code (docs/release.md)
• Duplicate intent across types with different access patterns. Both types expose a method named chain_info returning the same ChainInfo type, but one is a tracker (stateful observer) and the other is an in-memory state container. While technically distinct domains, the naming collision suggests a potential abstraction leak or confusing API surface where consumers might expect ChainInfo to be a property of the state rather than a separate query.
• Duplicate method name get_persisted_num_hash on both types. While consistent with each other, it highlights the broader issue of duplicated accessor patterns across different state management layers.
• Duplicated block (10 lines × 2) (crates/net/eth-wire-types/src/broadcast.rs)
• …and 114 more

• 229 commits — 150 feature/other, 79 fixes

• crates/rpc — 42 commits
• crates/engine — 28 commits
• crates/net — 22 commits
• crates/storage — 18 commits
• (root) — 15 commits
• .github/workflows — 14 commits
• crates/snap-sync — 12 commits
• crates/transaction-pool — 11 commits
• crates/trie — 10 commits
• crates/e2e-test-utils — 9 commits
• crates/ethereum — 7 commits
• crates/node — 6 commits
• .github/scripts — 4 commits
• crates/cli — 3 commits
• crates/prune — 3 commits
• testing/ef-tests — 3 commits
• crates/chainspec — 2 commits
• crates/era-utils — 2 commits
• crates/evm — 2 commits
• crates/tasks — 2 commits

• fix: fix(bench): report measured elapsed time and throughput (#27291)
• fix: fix(chain-state): preserve account reverts after empty test blocks (#27317)
• fix: fix(ci): enable benchmark frame pointers (#27393)
• fix: fix(ci): migrate deny check to gh-actions (#27309)
• fix: fix(ci): remove TTY setup from release signing (#27497)
• fix: fix(ci): repin deny workflow for paradigmxyz STS support (#27312)
• fix: fix(ci): restore pull-requests write for Cyclops audit comments (#27327)
• fix: fix(cli): exit download right after completion (#27498)
• fix: fix(db): apply --db.rocksdb-block-cache-size on node startup (#27211)
• fix: fix(download): restore custom static files directory handling (#27065)
• fix: fix(e2e): send ReorgTo fcu to its target (#27438)
• fix: fix(e2e): skip stale notifications in assert_new_block (#27583)
• fix: fix(engine): adjudicate speculative BAL worker failures in transaction order (#26721)
• fix: fix(engine): avoid cache handoff misses and locked drops (#27230)
• fix: fix(engine): avoid panic on payload stream termination (#27218)
• fix: fix(engine): backpressure on state trie frontier (#27269)
• fix: fix(engine): consume saved cache during handoff (#27234)
• fix: fix(engine): dedupe block range requests (#27426)
• fix: fix(engine): don't treat stale persisted fcu head as canonical (#27429)
• fix: fix(engine): lower minimum backpressure threshold (#27295)
• …and 209 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

paradigmxyz/reth was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.