Talk Recordings

Opening remarks

Sina + Marius — EF

Besu plugin system

Gary Schulte — Besu

This talk will discuss a strategy for reactively scaling ethereum RPC nodes with fast and lightweight storage requirements, and and implementation of this strategy in Besu. Cost to scale, tradeoffs in capabilities, and introspective rpc request routing necessary to utilize this feature will be covered.

Ethrex: A Modular Ethereum Execution Client for L1 and L2

Leandro Ferrigno — LambdaClass

Ethrex is a modular execution client written in Rust, designed to bring diversity, performance, and verifiability to Ethereum's execution layer. By unifying the codebase between L1 and ZK rollups, Ethrex reduces duplication, simplifies proving, and enables developers to run and prove Ethereum blocks across different zkVMs. This talk will introduce Ethrex's architecture, explain how it supports both traditional and zk-based execution, and demonstrate how its modular design allows it to power anything from local devnets to fully verified rollups. We'll also discuss how client diversity at the proving layer contributes to Ethereum's long-term security and resilience.

What Devs Need From Clients: Insights From the Field

Bastien Moyroud — Alchemy

Bastien shares insights gathered from Alchemy's developer ecosystem on what builders most need from Ethereum clients.

Modular Ethereum Block Building with rblib

Jules Doumeche — Flashbots

We introduce rblib: a high-performance, modular rust SDK for constructing Ethereum-compatible block builders. It provides robust, platform-agnostic primitives and declarative workflows designed for both L1 and L2 applications.

Geth roadmap

Felix Lange — Geth

Felix will walk through the upcoming roadmap for Geth, outlining key improvements planned across performance, networking, execution, and developer experience.

Node-reth: Flashblocks-aware Ethereum Client

Cody Wang — Base

The Base team built base/node-reth (https://github.com/base/node-reth), a Reth-based Ethereum execution client enhanced with Flashblocks and compatible with any OP-stack L2s. By leveraging Reth Extension and the Flashblocks websocket stream, it introduces a a new flashblocks-rpc layer that exposes Flashblocks state through familiar Ethereum RPC calls. In this talk I'll walk through - A brief intro to Flashblocks on Base - The architecture of the Flashblocks-aware pipeline (from ingesting data to managing state) - The design and usage of the Flashblocks-aware RPCs - The challenges and takeaways we encountered when building this software

Ethereum needs Standards Punk

Sebastian Bürgel — Gnosis & HOPR

Ethereum's decentralization is increasingly undermined at the RPC layer, where inconsistent and underspecified APIs like `eth_getLogs` silently fail across clients and push developers toward centralized providers. This talk exposes how missing standards and weak conformance testing break auditability and reliability, using concrete examples from client behavior and RPC test coverage. It calls for a community effort to standardize and verify RPC behavior - through open test suites, dashboards, and a dedicated working group - to restore Ethereum's resilience and independence from centralized infrastructure.

erpc: Solving Ethereum RPC Reliability Challenges

Kasra Khosravi — eRPC

Ethereum RPC infrastructure fails developers with node outages, rate limits, and inconsistent responses. This talk demonstrates how erpc, an open-source RPC proxy, solves these challenges through intelligent routing, automatic failover, request hedging, log splitting, consensus mechanisms, and data integrity checks. I'll share real production problems and how erpc's features create resilient dApps that handle node complexity gracefully.

Nethermind roadmap

Marek Moraczyński & Kamil Chodoła — Nethermind

Marek will present Nethermind's upcoming roadmap, covering the team's current priorities, ongoing improvements, and long-term architectural direction. Kamil will follow with an overview of the advanced benchmarking tooling Nethermind has built

Observability standards for nodes

James Prestwich — Signet

What should a node trace? Can we build semantic conventions on how nodes expose tracing data? Can tracing identity bottlenecks and perf discrepancies between implementations?

Instrumentation of clients to extract all observable blockchain data

Matthieu Vachon — StreamingFast/The Graph

We will briefly shows StreamingFast Firehose/Substreams system from the tracing perspective across different Ethereum client and its implementation as chain's agnostic protocol for ingesting any blockchain's data and offering them over a Protobuf first API.

Client performance

Pari, Julian, Tobi, Ben, CPerezz — Panel

Erigon 3+?

Mark Holt — Erigon AG

Erigon 3 has been our development focus for about 18 months. It was a major change for the way Erigon works. This has meant we've been mainly focussed on stabilization of the codebase and the associated Erigon 3 snapshot delivery process. This talk will present some lessons learnt from that process, and talk about what is next in our non EIP development pipeline. * Parallelization - E3 has streamlined out DB usage and made our internal processing model more flexible. This has allowed us to introduce parallel processing to improve the performance of key components. We are now extending and refining this to improve both execution performance and RPC throughput. * Modularization - We are gradually making Erigon more modular, which will allow it to be composed and extended more easily. * Virtualization - The next evolutionary step for out snapshot based storage model. This enables a trade off between reduced disk footprint and data retrieval times. We expect these developments to make Erigon more scalable, stable and composable as we look to extend its usage beyond its primary use as an archive node..

What to expect from ZkClients

Guillaume Ballet — Stateless Consensus

Guillaume will explore the emerging class of ZkClients: Ethereum clients that use zero-knowledge proofs to verify state and execution with minimal trust.

Optimizing for noise. The final disk space efficiency frontier for archive nodes?

Willian Mitsuda — Erigon/Otterscan

One challenge of archive nodes is to keep disk space under control while blockchain history data keeps growing. This is a reflective talk where research data will demonstrate how increasing scalability leads to much more noise stored onchain and how specialized techniques can be applied to solve this kind of problem.

Lighthouse update

Lion Dapplion — Sigma Prime

Lion will present the latest developments in the Lighthouse consensus client, covering recent performance improvements, protocol upgrades, and new features.

When Clients Disagree: Picking a Side Safely

Luca Winter — Serenita

Client diversity makes Ethereum more resilient. But it also means that, from time to time, different clients disagree on which chain is valid, leading to a fork. When that happens, how can validators make sure they're voting for the correct side? This talk explores how multi-node validator clients (like Vero and Vouch) help validators navigate such situations safely by combining the views of multiple client implementations.