Ten of the protocols that shaped Ethereum and Solana, each stripped down to a version you can write yourself and break.
You can read the Optimism specification three times and still not know what a fraud proof actually checks, because specifications describe decisions rather than making you take them. Here you build first-iteration versions of ten protocols across both chains — the layer itself, not applications sitting on top of it — each stripped to the one mechanism that carries the whole design. On Ethereum: optimistic rollups with a sequencer, a batcher and a single-round fraud-proof game; validity-proof rollups (zk-rollups) with an off-chain prover and an on-chain verifier; ZCash-style privacy pools built from note commitments, nullifiers and a Groth16 verifier; EigenLayer restaking with operator registration and slashing; and ERC-4337 account abstraction with a bundler and a gas-sponsoring paymaster. On Solana: Phoenix-style central limit order books, Bubblegum-style state compression over concurrent Merkle trees, Token-2022 confidential transfers using ElGamal encryption and range proofs, and Wormhole-style guardian bridges. Module 1 is shared foundations — forking mainnet, the account model, threat modelling, and knowing when a toy has taught you enough. This is the cross-chain course: the same primitive twice, so you can see which design choices came from the chain and which were universal. Finish by shipping one of five capstones.
Built by Lakshya Kumar
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.
Assume every batch is honest, then make it cheap to prove otherwise — and learn why that bet needs a seven-day window to be safe.
Matching buyers to sellers is easy until it has to be fair, fast and paid for by the block — build the version that survives all three.
Instead of waiting to catch cheating, prove correctness up front — write the circuit, run the prover, and verify it on chain for pennies.
Commitments and nullifiers are how a ledger can prove you have the right to spend without revealing which deposit was yours.
Keep the data off chain and only the proof on it — the trick that made issuing millions of tokens affordable instead of absurd.
Let already-staked capital back a second service, with real penalties when an operator misbehaves. Registration, tasks and slashing.
Encrypt balances, prove no one minted value out of nothing, and still leave an auditor a way in when the rules demand it.
Let someone else pay the fees, let friends help recover a lost account, and stop asking normal people to guard twelve words.
Bridges hold the most money and get robbed the most often — build one with signed attestations, replay protection and honest finality.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Implement the full privacy-pool primitive: a circom circuit proving (note ∈ Merkle tree) ∧ (nullifier hash matches), a Solidity contract that accepts fixed-denomination deposits and verifies withdrawals against the Groth16 verifier, and a TypeScript client that generates proofs. Demonstrate a deposit from address A and a withdrawal to address B with no on-chain link. Document anonymity set considerations and one realistic side-channel attack. ~150 lines of circom, ~250 lines of Solidity, ~200 lines of TS.
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 to build first-iteration toy versions of major Ethereum and Solana protocols — Optimism (optimistic rollups), zkSync (zk-rollups), Tornado Cash / ZCash (privacy pools), EigenLayer (restaking), ERC-4337 (account abstraction), Phoenix (on-chain CLOB), Bubblegum (state compression), Token-2022 confidential transfer, and Wormhole (guardian bridge). The goal is to build the load-bearing mechanism of each in <500 lines and understand the design space across both chains. Help me work through the mechanics with reference to real contracts, real programs, real specs, and real exploits.
Implement a minimal on-chain order book in Anchor: slab allocator for orders, limit + market order instructions, price-time priority matching, basic self-trade prevention. Support a 100-order book, demonstrate correct matching across multiple price levels, and document the CU cost per instruction. ~400 lines of Rust.
Build a minimal optimistic rollup against a forked L1: a sequencer that orders L2 transactions, a batcher that posts compressed batches to L1, a state oracle that publishes L2 state roots, and a single-round fraud-proof game. Demonstrate a successful happy-path deposit and withdrawal AND a successful challenge of a malicious state root. ~600 lines of Solidity, ~250 lines of TypeScript.
Implement a minimal confidential balance system: a Token-2022 mint with confidential transfer extension enabled, deposit/transfer/withdraw flows leveraging the SPL ZK Token program, optional auditor key for selective disclosure. Demonstrate that on-chain inspection cannot reveal balances but the auditor key can. ~400 lines of Anchor + TS client.
Implement a lock-mint bridge between Solana and EVM (Anvil): a Lock program on Solana, a Mint contract on EVM, a 3-of-5 guardian signer set, an off-chain relayer that observes Solana events and submits signed messages to the destination. Demonstrate end-to-end transfer with replay protection. ~400 lines total.
Reference implementation for the privacy-pool module.