Lesson 0 — Welcome to Inside Reth

Question

Inside Reth is one of three Intermediate courses (Revm / Reth / Alloy). Reth is the canonical Rust Ethereum full node; this course walks Staged Sync + ExEx + SDK — the three load-bearing internals.

Principle (minimum model)

• 3 Intermediate courses. Inside Revm / Inside Reth (this) / Inside Alloy. Take in any order; Reth depends on Revm + Alloy types.
• Three topic chains. Staged Sync (10 pipelined stages) / ExEx (Execution Extension API for indexers and observers) / SDK (NodeBuilder + 6 components for custom L1s).
• Each topic = buildup → walkthrough → quiz → drill. Plus a Rust lifetimes/Arc/dyn lesson + a Testing lesson + Bridge to Advanced + final quiz.
• Reading approach. Open paradigmxyz/reth in another tab; verify every claim against source.
• Prerequisites. Inside Revm or Inside Alloy completed; intermediate Rust; light Ethereum primitives.

Worked example + steps

Welcome to Inside Reth — how this course works

This course is one of three independent Intermediate-tier courses on RethLab:

• Inside Revm — Inside the EVM engine (recommended first if you haven't done it)
• Inside Reth (you are here) — Inside Reth: Staged Sync, ExEx, the Reth SDK
• Inside Alloy — Inside Alloy: Provider, Network, Signer

These three are independent, but several lessons here assume comfort with the Database trait and Revm execution model from Inside Revm. If those concepts feel shaky, do Inside Revm first.

📋 First time at the Intermediate tier? Read "How Intermediate courses work" at the end of Bridge to Intermediate before starting. It explains the editorial style (Predict prompts, Quiz gates, the build-up → walkthrough → quiz → drill chain shape) and pacing — applies to all three Intermediate courses, so you only read it once.

What this course teaches

You'll read the paradigmxyz/reth source line by line: the Stage trait and the 10-stage sync pipeline, ExEx (Execution Extensions) for in-process indexers / MEV / risk engines, and the Reth SDK for composing your own App-chain. Three topic chains, each with build-up + walkthrough + quiz + drill.

By the end, you'll have read enough Reth internals to ship a node-speed indexer or a custom App-chain.

Prerequisites

Revm internals (if you haven't done Inside Revm):

• The Database trait surface and how Revm reads state through it
• How Stage and Database interact during ExecutionStage

Block-level Ethereum (covered in Bridge to Intermediate):

• Block structure (header / body / receipts), reorgs as a normal phenomenon
• What sender recovery, transaction body decoding, and receipts contain

Intermediate Rust (also Bridge to Intermediate; there's a Rust: lifetimes, Box, Arc, dyn Trait lesson inside this course for self-checking):

• Generics with trait bounds, ?Sized, dyn Trait vs impl Trait
• Arc<T>, Mutex<T>, RwLock<T> — when to use each
• async / Future / Stream basics
• auto_impl macros and procedural attributes

Shaky on Revm? Do Inside Revm first. The Stage trait and the SDK both reference Revm types directly.

Setup — do this once

Before lesson 1, have these ready in another window:

1. paradigmxyz/reth cloned — git clone https://github.com/paradigmxyz/reth
2. bluealloy/revm cloned — git clone https://github.com/bluealloy/revm (cross-referenced during ExEx and SDK lessons)
3. A working cargo toolchain — rustc --version should print something modern
4. cargo-expand — cargo install cargo-expand (procedural macros across both repos)
5. A second monitor or split terminal — you'll be cross-referencing source while you read

The "Find in repo" prompts only work if you actually have the repos open. Close that loop before starting.

You're ready

Scroll back to the course detail and start with Building the Stage trait step by step.

After Inside Reth: head to Inside Alloy if you haven't yet — or move on to Expert for the procedural-macro and zkVM-integration deep dives.

Summary (3 lines)

• Inside Reth = one of three Intermediate courses. Three topic chains: Staged Sync + ExEx + SDK.
• Each = buildup → walkthrough → quiz → drill. Plus Rust + Testing + Bridge lessons. Verify against paradigmxyz/reth source.
• Prerequisites: Inside Revm or Inside Alloy + intermediate Rust.