ethertools.
THE BIG PICTURE · ALL 500 LESSONS AVAILABLE

One curious mind.
500 little breakthroughs.

Explore 500 complete lessons across 25 focused tracks. Start with the shared notebook picture, work through the bytes, and finish with practical local capstones.

01 Your first steps02 Digital value and units03 Wallets without mystery04 Explore safely05 From send to settlement06 Meet smart contracts07 Tokens and digital ownership08 Gas and execution fees09 The network behind the screen10 Scaling and layer 211 How people use Ethereum12 Write and read Solidity13 ABI encoding foundations14 Dynamic ABI and nested layouts15 Read logs and failures16 Storage, memory and layout17 Inside the EVM18 Execution traces and low-level calls19 Cryptography with intuition20 Trees, roots and proofs21 Smart contract security foundations22 Advanced security reasoning23 Build, test and reason24 Ethereum protocol concepts25 Connect everything together
TRACK 01 · beginner

Your first steps

20 focused lessons · Open this track ↗

  1. What is a blockchain?Read lesson ↗
  2. What is Ethereum?Read lesson ↗
  3. What is a digital ledger?Read lesson ↗
  4. Why do computers need to agree?Read lesson ↗
  5. What makes a block a block?Read lesson ↗
  6. How are blocks linked?Read lesson ↗
  7. What is a transaction?Read lesson ↗
  8. What does decentralization mean?Read lesson ↗
  9. Who can use Ethereum?Read lesson ↗
  10. Who owns Ethereum?Read lesson ↗
  11. Ethereum versus the internetRead lesson ↗
  12. Ethereum versus BitcoinRead lesson ↗
  13. What can a blockchain prove?Read lesson ↗
  14. What a blockchain cannot proveRead lesson ↗
  15. Public does not mean anonymousRead lesson ↗
  16. What is a network fee?Read lesson ↗
  17. What is an Ethereum account?Read lesson ↗
  18. Reading your first block explorer pageRead lesson ↗
  19. A tour of the Ethereum ecosystemRead lesson ↗
  20. Your first blockchain knowledge checkRead lesson ↗
TRACK 02 · beginner

Digital value and units

20 focused lessons · Open this track ↗

  1. ETH, Gwei and WeiRead lesson ↗
  2. What makes ETH different from tokens?Read lesson ↗
  3. Count a billion and a quintillionRead lesson ↗
  4. Convert ETH to Wei by handRead lesson ↗
  5. Convert Wei to ETH by handRead lesson ↗
  6. Why Ethereum uses whole numbersRead lesson ↗
  7. Why floating-point amounts can failRead lesson ↗
  8. Read a very large integerRead lesson ↗
  9. What are token decimals?Read lesson ↗
  10. Display units versus raw unitsRead lesson ↗
  11. Add and subtract exact ETH amountsRead lesson ↗
  12. Rounding versus truncationRead lesson ↗
  13. Why a converter is not a price feedRead lesson ↗
  14. What does a token balance mean?Read lesson ↗
  15. Native transfers versus token transfersRead lesson ↗
  16. Total supply versus circulating supplyRead lesson ↗
  17. What does burning mean?Read lesson ↗
  18. What does minting mean?Read lesson ↗
  19. Dust and very small balancesRead lesson ↗
  20. Unit conversion practice setRead lesson ↗
TRACK 03 · beginner

Wallets without mystery

20 focused lessons · Open this track ↗

  1. Wallets, keys and addressesRead lesson ↗
  2. What a wallet actually storesRead lesson ↗
  3. What is a recovery phrase?Read lesson ↗
  4. A public key versus a private keyRead lesson ↗
  5. A wallet address is not a usernameRead lesson ↗
  6. Software wallets and hardware walletsRead lesson ↗
  7. Watch-only walletsRead lesson ↗
  8. One recovery phrase, many accountsRead lesson ↗
  9. What is a derivation path?Read lesson ↗
  10. What is a contract wallet?Read lesson ↗
  11. What is a multisignature wallet?Read lesson ↗
  12. What does connecting a wallet allow?Read lesson ↗
  13. Disconnecting is not revoking approvalRead lesson ↗
  14. What are wallet networks?Read lesson ↗
  15. Why balances differ across networksRead lesson ↗
  16. Read a wallet confirmation screenRead lesson ↗
  17. Understand a receive screenRead lesson ↗
  18. Copy addresses without shortcutsRead lesson ↗
  19. Backups and recovery basicsRead lesson ↗
  20. Wallet safety knowledge checkRead lesson ↗
TRACK 04 · beginner

Explore safely

20 focused lessons · Open this track ↗

  1. Stay safe while exploringRead lesson ↗
  2. Spot a fake support messageRead lesson ↗
  3. Recognize a recovery phrase scamRead lesson ↗
  4. Address poisoning explainedRead lesson ↗
  5. Clipboard replacement attacksRead lesson ↗
  6. Read a domain carefullyRead lesson ↗
  7. Understand token approvalsRead lesson ↗
  8. Unlimited allowances explainedRead lesson ↗
  9. What is a malicious signature?Read lesson ↗
  10. Why an airdrop can be baitRead lesson ↗
  11. What a testnet is forRead lesson ↗
  12. Test ETH versus real ETHRead lesson ↗
  13. How to read a faucet warningRead lesson ↗
  14. Verify an address through two channelsRead lesson ↗
  15. Why transactions are usually irreversibleRead lesson ↗
  16. What a block explorer label does not proveRead lesson ↗
  17. Hardware wallets still need careful reviewRead lesson ↗
  18. Read-only practice habitsRead lesson ↗
  19. Prepare a personal transaction checklistRead lesson ↗
  20. Safety scenario challengeRead lesson ↗
TRACK 05 · beginner

From send to settlement

20 focused lessons · Open this track ↗

  1. Follow a transactionRead lesson ↗
  2. Write a payment instructionRead lesson ↗
  3. What is a transaction hash?Read lesson ↗
  4. What is a nonce?Read lesson ↗
  5. Pending, confirmed and finalizedRead lesson ↗
  6. What is a mempool?Read lesson ↗
  7. Who includes a transaction?Read lesson ↗
  8. Why a transaction may waitRead lesson ↗
  9. Why a transaction may failRead lesson ↗
  10. What is a transaction receipt?Read lesson ↗
  11. Gas used versus gas limitRead lesson ↗
  12. The recipient versus the senderRead lesson ↗
  13. Transaction value versus feeRead lesson ↗
  14. Read a simple transfer receiptRead lesson ↗
  15. What happens after pressing send?Read lesson ↗
  16. What is a replacement transaction?Read lesson ↗
  17. What does canceling a transaction mean?Read lesson ↗
  18. What is a chain reorganization?Read lesson ↗
  19. A transaction journey illustratedRead lesson ↗
  20. Transaction basics knowledge checkRead lesson ↗
TRACK 06 · beginner

Meet smart contracts

20 focused lessons · Open this track ↗

  1. Smart contracts, simplyRead lesson ↗
  2. A counter as a contractRead lesson ↗
  3. Functions and arguments explainedRead lesson ↗
  4. Reading a contract versus changing itRead lesson ↗
  5. What does contract state mean?Read lesson ↗
  6. Who can call a smart contract?Read lesson ↗
  7. A contract has an address tooRead lesson ↗
  8. What is deployment?Read lesson ↗
  9. What is contract bytecode?Read lesson ↗
  10. What is verified source code?Read lesson ↗
  11. What an ABI describesRead lesson ↗
  12. What contracts cannot do aloneRead lesson ↗
  13. What is an oracle?Read lesson ↗
  14. What is a permission check?Read lesson ↗
  15. What is an administrator key?Read lesson ↗
  16. Can a contract be upgraded?Read lesson ↗
  17. Why bugs can be expensiveRead lesson ↗
  18. A vending machine analogy and its limitsRead lesson ↗
  19. Walk through a pretend contract callRead lesson ↗
  20. Smart contract knowledge checkRead lesson ↗
TRACK 07 · intermediate

Tokens and digital ownership

20 focused lessons · Open this track ↗

  1. Tokens, NFTs and allowancesRead lesson ↗
  2. How ERC-20 balances are recordedRead lesson ↗
  3. Understand transfer and transferFromRead lesson ↗
  4. Read an allowanceRead lesson ↗
  5. Approve zero and allowance changesRead lesson ↗
  6. The ERC-20 decimals conventionRead lesson ↗
  7. What makes an NFT unique?Read lesson ↗
  8. ERC-721 ownership and token IDsRead lesson ↗
  9. ERC-1155 multiple token typesRead lesson ↗
  10. Metadata and token ownership differRead lesson ↗
  11. Where NFT images can liveRead lesson ↗
  12. Onchain versus offchain metadataRead lesson ↗
  13. What does a token standard guarantee?Read lesson ↗
  14. Why token names are not identitiesRead lesson ↗
  15. Wrapped ETH explainedRead lesson ↗
  16. Stablecoin mechanisms at a glanceRead lesson ↗
  17. Rebasing tokens explainedRead lesson ↗
  18. Fee-on-transfer tokens explainedRead lesson ↗
  19. Events versus actual token behaviorRead lesson ↗
  20. Token interface practice setRead lesson ↗
TRACK 08 · intermediate

Gas and execution fees

20 focused lessons · Open this track ↗

  1. Gas without the guessworkRead lesson ↗
  2. Gas as a measure of workRead lesson ↗
  3. The 21,000 gas transfer exampleRead lesson ↗
  4. Gas limit versus block gas limitRead lesson ↗
  5. EIP-1559 in plain languageRead lesson ↗
  6. Base fee explainedRead lesson ↗
  7. Priority fee explainedRead lesson ↗
  8. Maximum fee cap explainedRead lesson ↗
  9. Calculate the effective gas priceRead lesson ↗
  10. What happens to unused gas?Read lesson ↗
  11. What happens when gas runs out?Read lesson ↗
  12. Why a revert still costs gasRead lesson ↗
  13. Why estimates can be wrongRead lesson ↗
  14. Warm versus cold access overviewRead lesson ↗
  15. Storage writes and gasRead lesson ↗
  16. Gas refunds and refund limitsRead lesson ↗
  17. Execution fees versus blob feesRead lesson ↗
  18. Layer 2 fee componentsRead lesson ↗
  19. Build a manual fee budgetRead lesson ↗
  20. Gas calculation practice setRead lesson ↗
TRACK 09 · intermediate

The network behind the screen

20 focused lessons · Open this track ↗

  1. Nodes and the shared stateRead lesson ↗
  2. How Ethereum agreesRead lesson ↗
  3. Execution clients and consensus clientsRead lesson ↗
  4. Nodes versus validatorsRead lesson ↗
  5. What does a full node verify?Read lesson ↗
  6. What an archive node retainsRead lesson ↗
  7. Peer-to-peer networking basicsRead lesson ↗
  8. What happens in a slot?Read lesson ↗
  9. What happens in an epoch?Read lesson ↗
  10. Block proposers explainedRead lesson ↗
  11. Attestations explainedRead lesson ↗
  12. Fork choice in plain languageRead lesson ↗
  13. Checkpoints and finalityRead lesson ↗
  14. Validator rewards and penaltiesRead lesson ↗
  15. What slashing meansRead lesson ↗
  16. Why client diversity mattersRead lesson ↗
  17. What a light client checksRead lesson ↗
  18. Trusting an RPC providerRead lesson ↗
  19. Read calls versus write transactionsRead lesson ↗
  20. Network architecture knowledge checkRead lesson ↗
TRACK 10 · intermediate

Scaling and layer 2

20 focused lessons · Open this track ↗

  1. Layer 2 and rollupsRead lesson ↗
  2. Layer 1 versus layer 2Read lesson ↗
  3. What is a rollup batch?Read lesson ↗
  4. Optimistic rollups explainedRead lesson ↗
  5. Validity rollups explainedRead lesson ↗
  6. Fraud proofs and challenge periodsRead lesson ↗
  7. Validity proofs and verificationRead lesson ↗
  8. What is a sequencer?Read lesson ↗
  9. Sequencer availability and escape pathsRead lesson ↗
  10. Settlement versus executionRead lesson ↗
  11. What is data availability?Read lesson ↗
  12. Blob data in plain languageRead lesson ↗
  13. Bridges as separate risk systemsRead lesson ↗
  14. Canonical bridges versus third-party bridgesRead lesson ↗
  15. Deposits and withdrawalsRead lesson ↗
  16. Why withdrawal timing differsRead lesson ↗
  17. What is a sidechain?Read lesson ↗
  18. Network IDs and chain IDsRead lesson ↗
  19. Compare scaling trust assumptionsRead lesson ↗
  20. Layer 2 scenario practiceRead lesson ↗
TRACK 11 · intermediate

How people use Ethereum

20 focused lessons · Open this track ↗

  1. DeFi without the hypeRead lesson ↗
  2. Payments with EthereumRead lesson ↗
  3. Stablecoins for everyday useRead lesson ↗
  4. Decentralized exchanges explainedRead lesson ↗
  5. Liquidity pools explainedRead lesson ↗
  6. Price impact versus slippageRead lesson ↗
  7. Lending and collateralRead lesson ↗
  8. Liquidation explainedRead lesson ↗
  9. Interest rate models at a glanceRead lesson ↗
  10. Oracles in financial appsRead lesson ↗
  11. DAOs and shared decisionsRead lesson ↗
  12. Governance proposals and votingRead lesson ↗
  13. Voting power versus ownershipRead lesson ↗
  14. Decentralized identity explainedRead lesson ↗
  15. ENS names explainedRead lesson ↗
  16. Public goods funding explainedRead lesson ↗
  17. Digital collectibles beyond speculationRead lesson ↗
  18. Account abstraction for usersRead lesson ↗
  19. Composability and shared riskRead lesson ↗
  20. Application risk knowledge checkRead lesson ↗
TRACK 12 · advanced

Write and read Solidity

20 focused lessons · Open this track ↗

  1. Read your first Solidity contractRead lesson ↗
  2. A Solidity source file explainedRead lesson ↗
  3. Pragma directives and compiler versionsRead lesson ↗
  4. Contract declarations and constructorsRead lesson ↗
  5. Boolean and integer typesRead lesson ↗
  6. Signed versus unsigned integersRead lesson ↗
  7. Addresses and payable addressesRead lesson ↗
  8. Fixed bytes versus dynamic bytesRead lesson ↗
  9. Strings and UTF-8Read lesson ↗
  10. State variables versus local variablesRead lesson ↗
  11. Functions and visibilityRead lesson ↗
  12. View and pure functionsRead lesson ↗
  13. Function parameters and return valuesRead lesson ↗
  14. Require, revert and assertRead lesson ↗
  15. Modifiers and access checksRead lesson ↗
  16. Events in a contractRead lesson ↗
  17. Custom errors in SolidityRead lesson ↗
  18. Interfaces and inheritance basicsRead lesson ↗
  19. Receive and fallback functionsRead lesson ↗
  20. Read a complete small contractRead lesson ↗
TRACK 13 · advanced

ABI encoding foundations

20 focused lessons · Open this track ↗

  1. ABI: the contract’s interfaceRead lesson ↗
  2. Trace calldata byte by byteRead lesson ↗
  3. Canonical function signaturesRead lesson ↗
  4. Calculate a function selectorRead lesson ↗
  5. Encode uint256 step by stepRead lesson ↗
  6. Encode signed integersRead lesson ↗
  7. Encode an address wordRead lesson ↗
  8. Encode a boolean wordRead lesson ↗
  9. Encode bytes4 versus bytes32Read lesson ↗
  10. Static tuples explainedRead lesson ↗
  11. Fixed-size arrays in the ABIRead lesson ↗
  12. ABI return values without selectorsRead lesson ↗
  13. Decode multiple return valuesRead lesson ↗
  14. Function overloads and selectorsRead lesson ↗
  15. The JSON ABI formatRead lesson ↗
  16. Why ABI data is not self-describingRead lesson ↗
  17. Selector collisions explainedRead lesson ↗
  18. ABI encoding versus packed encodingRead lesson ↗
  19. A complete ERC-20 calldata walkthroughRead lesson ↗
  20. Static ABI decoding challenge setRead lesson ↗
TRACK 14 · advanced

Dynamic ABI and nested layouts

20 focused lessons · Open this track ↗

  1. Head and tail encodingRead lesson ↗
  2. Understand relative offsetsRead lesson ↗
  3. Encode one stringRead lesson ↗
  4. Count UTF-8 bytes correctlyRead lesson ↗
  5. Padding dynamic bytesRead lesson ↗
  6. Encode two dynamic argumentsRead lesson ↗
  7. Encode a uint256 arrayRead lesson ↗
  8. Encode a string arrayRead lesson ↗
  9. Fixed arrays of dynamic valuesRead lesson ↗
  10. Dynamic arrays of static tuplesRead lesson ↗
  11. Tuples containing stringsRead lesson ↗
  12. Nested tuple offset basesRead lesson ↗
  13. Nested dynamic array walkthroughRead lesson ↗
  14. Empty strings and empty arraysRead lesson ↗
  15. Malformed offsets and decoding failuresRead lesson ↗
  16. Bounds checks in ABI decodersRead lesson ↗
  17. ABI coder version behaviorRead lesson ↗
  18. Cross-language encoding consistencyRead lesson ↗
  19. Build a dynamic encoding traceRead lesson ↗
  20. Nested ABI challenge setRead lesson ↗
TRACK 15 · advanced

Read logs and failures

20 focused lessons · Open this track ↗

  1. Events, topics and logsRead lesson ↗
  2. Understand why a call revertedRead lesson ↗
  3. Compute an event signature hashRead lesson ↗
  4. Indexed versus non-indexed argumentsRead lesson ↗
  5. Decode an ERC-20 Transfer eventRead lesson ↗
  6. Decode an Approval eventRead lesson ↗
  7. Anonymous events explainedRead lesson ↗
  8. Indexed strings and hashed topicsRead lesson ↗
  9. Logs inside a receiptRead lesson ↗
  10. Why reverted logs do not persistRead lesson ↗
  11. Event ordering in nested callsRead lesson ↗
  12. Decode Error(string)Read lesson ↗
  13. Decode Panic(uint256)Read lesson ↗
  14. Read arithmetic panic codesRead lesson ↗
  15. Decode a custom Solidity errorRead lesson ↗
  16. Empty revert data explainedRead lesson ↗
  17. Errors can be bubbled upRead lesson ↗
  18. Why revert bytes can be spoofedRead lesson ↗
  19. Link an error to a call frameRead lesson ↗
  20. Receipt and error challenge setRead lesson ↗
TRACK 16 · advanced

Storage, memory and layout

20 focused lessons · Open this track ↗

  1. Solidity storage slotsRead lesson ↗
  2. The 32-byte storage wordRead lesson ↗
  3. Pack adjacent value typesRead lesson ↗
  4. Byte offsets and low-order alignmentRead lesson ↗
  5. Struct storage layoutRead lesson ↗
  6. Fixed array storage layoutRead lesson ↗
  7. Dynamic array base slotsRead lesson ↗
  8. Mapping entry slot calculationsRead lesson ↗
  9. Nested mappings explainedRead lesson ↗
  10. Mapping to a structRead lesson ↗
  11. Short bytes and short strings in storageRead lesson ↗
  12. Long bytes and strings in storageRead lesson ↗
  13. Inheritance and storage orderingRead lesson ↗
  14. Storage layout and proxiesRead lesson ↗
  15. Namespaced storage explainedRead lesson ↗
  16. Memory expansion basicsRead lesson ↗
  17. The free memory pointerRead lesson ↗
  18. Calldata versus memory copiesRead lesson ↗
  19. Transient storage explainedRead lesson ↗
  20. Storage layout challenge setRead lesson ↗
TRACK 17 · advanced

Inside the EVM

20 focused lessons · Open this track ↗

  1. Step inside the EVMRead lesson ↗
  2. Bytecode versus source codeRead lesson ↗
  3. The program counterRead lesson ↗
  4. The 256-bit stackRead lesson ↗
  5. PUSH, DUP and SWAPRead lesson ↗
  6. ADD, MUL and modular arithmeticRead lesson ↗
  7. Signed arithmetic opcodesRead lesson ↗
  8. Bitwise AND, OR and XORRead lesson ↗
  9. Shifts and byte extractionRead lesson ↗
  10. MLOAD and MSTORERead lesson ↗
  11. SLOAD and SSTORERead lesson ↗
  12. Calldata load and copyRead lesson ↗
  13. Return data and copyingRead lesson ↗
  14. JUMP, JUMPI and JUMPDESTRead lesson ↗
  15. STOP, RETURN and REVERTRead lesson ↗
  16. CALL opcode basicsRead lesson ↗
  17. STATICCALL explainedRead lesson ↗
  18. DELEGATECALL and execution contextRead lesson ↗
  19. LOG opcodes and topicsRead lesson ↗
  20. Trace a small EVM programRead lesson ↗
TRACK 18 · advanced

Execution traces and low-level calls

20 focused lessons · Open this track ↗

  1. Transaction context versus call contextRead lesson ↗
  2. msg.sender versus tx.originRead lesson ↗
  3. msg.value in nested callsRead lesson ↗
  4. Contract creation with CREATERead lesson ↗
  5. Deterministic creation with CREATE2Read lesson ↗
  6. Init code versus runtime codeRead lesson ↗
  7. Value transfer and call failuresRead lesson ↗
  8. Call depth and stack limitsRead lesson ↗
  9. Gas forwarding and the 63/64 ruleRead lesson ↗
  10. Return-data griefing explainedRead lesson ↗
  11. Precompiles in the EVMRead lesson ↗
  12. SELFDESTRUCT after protocol changesRead lesson ↗
  13. Code size and deployment limitsRead lesson ↗
  14. Reentrancy across call framesRead lesson ↗
  15. State rollback boundariesRead lesson ↗
  16. Static context restrictionsRead lesson ↗
  17. Inspect a delegatecall traceRead lesson ↗
  18. Trace a failed token transferRead lesson ↗
  19. Trace proxy fallback executionRead lesson ↗
  20. Low-level trace challenge setRead lesson ↗
TRACK 19 · advanced

Cryptography with intuition

20 focused lessons · Open this track ↗

  1. Hashes: fingerprints for dataRead lesson ↗
  2. Signatures and permissionsRead lesson ↗
  3. Bytes versus hexadecimal displayRead lesson ↗
  4. Keccak-256 versus SHA3-256Read lesson ↗
  5. Hash preimages and collisionsRead lesson ↗
  6. Domain separation explainedRead lesson ↗
  7. Elliptic curve intuitionRead lesson ↗
  8. secp256k1 keys at a glanceRead lesson ↗
  9. Ethereum address derivationRead lesson ↗
  10. Signature r, s and v fieldsRead lesson ↗
  11. Recovering an externally owned signerRead lesson ↗
  12. Personal message signing prefixesRead lesson ↗
  13. EIP-712 domain separatorsRead lesson ↗
  14. EIP-712 typed structsRead lesson ↗
  15. Nonces and replay protectionRead lesson ↗
  16. Deadlines and signature expiryRead lesson ↗
  17. ERC-1271 contract signaturesRead lesson ↗
  18. Malleability and signature normalizationRead lesson ↗
  19. Commit and reveal patternsRead lesson ↗
  20. Signature verification practice setRead lesson ↗
TRACK 20 · advanced

Trees, roots and proofs

20 focused lessons · Open this track ↗

  1. Merkle trees and proofsRead lesson ↗
  2. Hash a Merkle leafRead lesson ↗
  3. Hash a pair of nodesRead lesson ↗
  4. Sorted pairs versus ordered pairsRead lesson ↗
  5. Odd leaf construction choicesRead lesson ↗
  6. Build a membership proofRead lesson ↗
  7. Verify a membership proofRead lesson ↗
  8. Proof size and tree depthRead lesson ↗
  9. Why a trusted root mattersRead lesson ↗
  10. Multiproofs at a glanceRead lesson ↗
  11. Merkle allowlists explainedRead lesson ↗
  12. Leaf encoding ambiguityRead lesson ↗
  13. Double-hashed leaf conventionsRead lesson ↗
  14. Ethereum tries versus binary Merkle treesRead lesson ↗
  15. State roots versus transaction rootsRead lesson ↗
  16. Receipts roots explainedRead lesson ↗
  17. Account proofs at a glanceRead lesson ↗
  18. Storage proofs at a glanceRead lesson ↗
  19. Verkle trees as a design directionRead lesson ↗
  20. Merkle proof challenge setRead lesson ↗
TRACK 21 · advanced

Smart contract security foundations

20 focused lessons · Open this track ↗

  1. Checks, effects and interactionsRead lesson ↗
  2. Reentrancy explained with a counterexampleRead lesson ↗
  3. Cross-function reentrancyRead lesson ↗
  4. Read-only reentrancyRead lesson ↗
  5. Access control mistakesRead lesson ↗
  6. Uninitialized contracts and initializersRead lesson ↗
  7. Arithmetic checks and unchecked blocksRead lesson ↗
  8. Rounding direction in financial codeRead lesson ↗
  9. ERC-20 return value differencesRead lesson ↗
  10. Approval race conditionsRead lesson ↗
  11. Unsafe external call assumptionsRead lesson ↗
  12. Denial of service in loopsRead lesson ↗
  13. Unbounded storage growthRead lesson ↗
  14. Timestamp dependenceRead lesson ↗
  15. Predictable randomnessRead lesson ↗
  16. Oracle manipulation basicsRead lesson ↗
  17. Flash loans as a mechanismRead lesson ↗
  18. Slippage and sandwich attacksRead lesson ↗
  19. Frontend security versus contract securityRead lesson ↗
  20. Security review practice setRead lesson ↗
TRACK 22 · advanced

Advanced security reasoning

20 focused lessons · Open this track ↗

  1. Delegatecall storage collisionsRead lesson ↗
  2. Proxy admin and implementation risksRead lesson ↗
  3. Upgrade authorization failuresRead lesson ↗
  4. Signature replay across chainsRead lesson ↗
  5. EIP-712 domain mistakesRead lesson ↗
  6. ERC-1271 validation assumptionsRead lesson ↗
  7. Calldata validation and type confusionRead lesson ↗
  8. abi.encodePacked collisionsRead lesson ↗
  9. Merkle proof leaf ambiguityRead lesson ↗
  10. Callback trust boundariesRead lesson ↗
  11. Token hook reentrancyRead lesson ↗
  12. Cross-chain message authenticationRead lesson ↗
  13. Bridge replay protectionRead lesson ↗
  14. Accounting invariantsRead lesson ↗
  15. Donation and inflation attacksRead lesson ↗
  16. Liquidation edge casesRead lesson ↗
  17. Precision loss across decimalsRead lesson ↗
  18. Emergency controls and governance riskRead lesson ↗
  19. Write a threat modelRead lesson ↗
  20. Advanced security scenario setRead lesson ↗
TRACK 23 · advanced

Build, test and reason

20 focused lessons · Open this track ↗

  1. Set up a local Solidity projectRead lesson ↗
  2. Read compiler errorsRead lesson ↗
  3. Unit tests for a counterRead lesson ↗
  4. Test access controlRead lesson ↗
  5. Test revert dataRead lesson ↗
  6. Test event emissionRead lesson ↗
  7. Test token decimalsRead lesson ↗
  8. Test storage invariantsRead lesson ↗
  9. Fuzz testing explainedRead lesson ↗
  10. Invariant testing explainedRead lesson ↗
  11. Property-based ABI round tripsRead lesson ↗
  12. Fork testing and its limitsRead lesson ↗
  13. Mocks versus real dependenciesRead lesson ↗
  14. Differential testingRead lesson ↗
  15. Gas snapshots and their limitsRead lesson ↗
  16. Read compiler storage outputRead lesson ↗
  17. Verify deployed source conceptuallyRead lesson ↗
  18. Document contract assumptionsRead lesson ↗
  19. Review a pull request for safetyRead lesson ↗
  20. A local-only testing capstoneRead lesson ↗
TRACK 24 · advanced

Ethereum protocol concepts

20 focused lessons · Open this track ↗

  1. Execution payloads explainedRead lesson ↗
  2. Block headers at a glanceRead lesson ↗
  3. Transaction types and envelopesRead lesson ↗
  4. EIP-155 replay protectionRead lesson ↗
  5. EIP-1559 transaction fieldsRead lesson ↗
  6. Access list transactionsRead lesson ↗
  7. Blob-carrying transactionsRead lesson ↗
  8. Blob commitments at a glanceRead lesson ↗
  9. The state transition functionRead lesson ↗
  10. Account state fieldsRead lesson ↗
  11. Account nonce versus transaction nonceRead lesson ↗
  12. The fee recipientRead lesson ↗
  13. Withdrawal processing basicsRead lesson ↗
  14. Validator lifecycle overviewRead lesson ↗
  15. Weak subjectivity explainedRead lesson ↗
  16. Finality failures and recoveryRead lesson ↗
  17. MEV and proposer incentivesRead lesson ↗
  18. Builder and proposer separationRead lesson ↗
  19. Protocol upgrades and EIPsRead lesson ↗
  20. Protocol reading challenge setRead lesson ↗
TRACK 25 · advanced

Connect everything together

20 focused lessons · Open this track ↗

  1. Design a beginner-friendly transfer explainerRead lesson ↗
  2. Build an exact unit converterRead lesson ↗
  3. Build an address checksum checkerRead lesson ↗
  4. Build a function selector calculatorRead lesson ↗
  5. Encode a token transfer by handRead lesson ↗
  6. Decode a dynamic string callRead lesson ↗
  7. Decode a complete Transfer receiptRead lesson ↗
  8. Build a manual execution fee calculatorRead lesson ↗
  9. Build a storage packing visualizerRead lesson ↗
  10. Compute an address mapping slotRead lesson ↗
  11. Build and verify a Merkle proofRead lesson ↗
  12. Decode standard and custom revertsRead lesson ↗
  13. Trace a tiny stack programRead lesson ↗
  14. Review a signature permission requestRead lesson ↗
  15. Threat-model a token approval flowRead lesson ↗
  16. Explain a rollup to a new learnerRead lesson ↗
  17. Review an upgrade storage changeRead lesson ↗
  18. Write a safe learning sandboxRead lesson ↗
  19. Publish a source-linked technical lessonRead lesson ↗
  20. Your Ethereum learning portfolioRead lesson ↗