Read bytecode, mempool traffic, and rollup batches directly, so the platform under your contracts stops being a black box.
You can ship a Solidity contract, but you still cannot say why one call costs 45,000 gas and a near-identical one costs 300,000, why your transaction sat in the mempool for four blocks, or why the same code behaves differently on a rollup. This course closes that gap by taking Ethereum apart. You will read raw bytecode for the Ethereum Virtual Machine (EVM) opcode by opcode, trace where gas is actually charged, follow a transaction from your node’s memory pool through peer propagation into a proposed block, and study the maximal extractable value (MEV) supply chain defensively, so you can protect users from sandwich attacks rather than run them. From there: ERC-4337 smart accounts that pay fees in tokens, the Beacon Chain’s attestation and finality rules, and how layer-two (L2) rollups split sequencing, data availability, and proving. The last two modules go inside the clients themselves — patching reth or geth, adding a precompile, and drafting a real Ethereum Improvement Proposal (EIP). You finish by picking one of five capstones.
Built by Lakshya Kumar
Paste this into any AI chat. Fill in the bracketed parts with your context — you'll get back a straight answer on whether this belongs on your plate.
I am learning Ethereum at the protocol layer — EVM internals, gas mechanics, mempool, MEV (defensively), ERC-4337 account abstraction, beacon chain consensus, L2 stacks, custom precompiles, and reth/geth internals. Help me understand the actual mechanics with reference to real EIPs, real contracts, and real client source code.
We grant free access case-by-case — students, career-switchers, builders on a tight budget. Sign in to send us a note.
Sign in to applyFinished the tasks? Take the prompt to your AI and get tested on it. We copy the prompt and open the app — just paste it in.
Storage writes, cold slots, and calldata bytes dominate your bill — profile them honestly instead of trusting optimizer folklore.
Nonce gaps, fee bumps, and private orderflow decide whether your transaction lands next block or never — learn the rules.
Sandwiches, back-runs, and liquidation races are mechanical, not mysterious — see the patterns before they hit your product.
Build the searcher stack end to end — simulate, bundle, submit to a relay — so you can monitor and defend against it.
When the account is a contract, you can sponsor fees, scope session keys, and recover a lost wallet without a seed phrase.
Validators, committees, and attestations decide finality — and slashing decides what it costs to get that wrong.
Sequencers order, data availability layers publish, and proofs settle — trace which part of a rollup you are actually trusting.
Add a native operation to a client fork, price its gas, and write the improvement proposal that would get it shipped.
Run your own node, add a custom RPC method, and answer questions about mainnet state that no public API will answer for you.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Pick a cryptographic operation that's expensive in pure EVM (Poseidon, BLS12-381 G2 pairing, Verkle proof primitive). Write a complete EIP-1-format draft: title, motivation, specification (precompile address, input format, output format, gas pricing), rationale, security considerations. Implement it as a working Solidity reference contract (slow path) AND fork reth to add it as a native precompile (fast path). Benchmark side-by-side. Submit the EIP draft to Ethereum Magicians for community feedback.
Fork reth, add a custom JSON-RPC namespace and an ExEx (Execution Extension) that answers one specific contract-behavior question across historical state — e.g. 'every storage slot a contract reads in the last 100 blocks' or 'every DELEGATECALL chain depth >2 in the last 24h'. Run it against mainnet for 100 blocks, verify accuracy against ≥3 ground-truth examples, and expose the result as a new JSON-RPC method. Bonus: package as an installable ExEx with a single CLI flag.
Design and prototype a small OP-Stack-compatible sequencer that batches encrypted intents and reveals them on inclusion. Integrate a basic commit-reveal scheme or threshold encryption (e.g. via Shamir secret sharing across a 3-of-5 committee). Settle to a local L1 fork. Demonstrate that observers can't see tx contents until the block is finalized. Architecture doc + working code + benchmark of throughput impact vs vanilla sequencer.
Build a production-quality ERC-4337 smart account contract plus an ERC-20 paymaster that charges users in USDC (priced via Chainlink ETH/USD oracle) instead of ETH. Add a session-key validator (24-hour expiry, scoped to one target). Deploy to a testnet, submit UserOps via Pimlico/Stackup/Alchemy, demonstrate a complete user flow where the user pays in USDC with no ETH balance. Include an audit-grade test suite (100% line coverage, fuzz tests for reentrancy variants).
Design and implement a Uniswap v4 hook that routes large swaps through CoW Protocol or UniswapX as a fallback when expected MEV loss exceeds a threshold. Emit structured analytics events on captured-vs-extracted MEV per swap. Run a 24-hour live test on a testnet (Sepolia) with synthetic large swaps and produce a one-page report on captured MEV. Defensive orientation: the goal is to protect users from sandwich attacks, not to extract MEV.
The complete spec for the account abstraction system covered in M6.