Live
The Starknet Codex

Zero-Knowledge.
Infinite Scale.

16 modules. One real project. Every command narrated. Every error explained. Master Cairo, STARK validity proofs, native account abstraction, and L1-L2 messaging — and leave with a portfolio project and the lore.

16Modules
~6Hours
40+Error Recoveries
1Real Project
Start Free Trial → View Curriculum ↓
Why Starknet

Why practitioners choose Starknet

▴
STARK proofs: provable computation

Starknet uses STARK validity proofs — no trusted setup, post-quantum secure. Every state transition is mathematically proven correct before being posted to Ethereum L1.

⊛
Cairo: purpose-built for ZK

Cairo is designed from the ground up for provable computation. It's not Solidity with ZK bolted on — it's a language where every execution produces a verifiable proof by design.

★
Native account abstraction

Every account on Starknet is a smart contract. Social recovery, session keys, multi-factor auth, and custom validation logic are built into the protocol — not added later.

⬢
Ethereum security, L2 performance

Starknet inherits Ethereum's security while offering dramatically lower fees and higher throughput. The best of both worlds for serious applications.

Curriculum

Every module builds toward one real product

You don't do isolated exercises. From Module 00 to Module 15, you build a complete application on Starknet. By the end, you'll have a production-ready project and the lore to back it up.

00
Environment Setup + Day 0 Quick Win
Get Scarb, Starkli, and Katana running. Deploy your first Cairo contract.
15 min

What You'll Learn

  • Scarb and Starkli setup
  • Katana local devnet

What You'll Do

  • Install toolchain
  • Deploy hello-world contract
01
Consensus: Validity Rollups & STARK Proofs
How Starknet proves computation, posts state diffs to L1, and achieves finality.
theoryZKSTARKFREE
30 min

What You'll Learn

  • Validity rollup architecture
  • STARK vs SNARK proofs
  • State diff posting to L1

What You'll Do

  • Build mental model of validity proofs
  • Compare to optimistic rollups
02
Run Your Local Devnet
Katana devnet. Deploy contracts, watch blocks, query Starknet RPC.
29 min

What You'll Learn

  • Katana architecture
  • Starknet JSON-RPC

What You'll Do

  • Run local devnet
  • Query block data
  • BREAK IT — misconfigured devnet
03
Accounts & Native Account Abstraction
Every account is a contract. Deploy accounts, custom validation, social recovery.
30 min

What You'll Learn

  • Account contract model
  • __validate__ and __execute__
  • Custom validation logic

What You'll Do

  • Deploy account contract
  • Custom signature validation
  • BREAK IT — validation failure
04
Account State & Balances
Contract storage, felts, and the Starknet state model.
25 min

What You'll Learn

  • Felt252 arithmetic
  • Contract storage layout

What You'll Do

  • Query storage slots
  • Inspect account state
05
Transactions: Full Lifecycle
INVOKE, DECLARE, DEPLOY_ACCOUNT. Transaction structure and execution flow.
29 min

What You'll Learn

  • Transaction types
  • Nonce management
  • Fee estimation

What You'll Do

  • Send all transaction types
  • BREAK IT — nonce mismatch
06
Cairo Smart Contracts
Cairo language fundamentals. Write, compile, and deploy your first real contract.
28 min

What You'll Learn

  • Cairo syntax and types
  • Contract interfaces
  • Storage variables

What You'll Do

  • Write Cairo contract
  • Declare and deploy
  • BREAK IT — felt overflow
07
ERC-20 Tokens & DeFi Primitives
Implement ERC-20 in Cairo. The foundation for DeFi on Starknet.
31 min

What You'll Learn

  • ERC-20 in Cairo
  • OpenZeppelin contracts

What You'll Do

  • Deploy ERC-20 token
  • Implement approval flow
08
ERC-721 NFTs
Non-fungible tokens on Starknet. Minting, metadata, and the Cairo implementation.
28 min

What You'll Learn

  • ERC-721 in Cairo
  • Metadata patterns

What You'll Do

  • Deploy NFT collection
  • Mint and transfer
09
Account Abstraction Deep Dive
Custom signers, session keys, multi-factor authentication, and social recovery.
26 min

What You'll Learn

  • Custom signer implementations
  • Session key patterns
  • Social recovery

What You'll Do

  • Implement session keys
  • Build social recovery
10
Multicall & Atomic Batching
Batch multiple operations in a single transaction. The power of native account abstraction.
34 min

What You'll Learn

  • Multicall mechanics
  • Atomic batching patterns

What You'll Do

  • Batch approve + swap in one tx
  • Build complex atomic flows
11
Contract Composability & Components
Cairo components, library dispatch, and building composable contract systems.
31 min

What You'll Learn

  • Cairo components system
  • Library dispatch

What You'll Do

  • Build reusable components
  • Compose contract systems
12
Events, Indexing & Off-Chain Data
Event emission, indexing with Apibara, and building data pipelines.
26 min

What You'll Learn

  • Event emission in Cairo
  • Indexing with Apibara

What You'll Do

  • Emit and query events
  • Build event pipeline
13
L1-L2 Messaging & Bridges
Send messages between Ethereum L1 and Starknet L2. The core of L2 composability.
29 min

What You'll Learn

  • L1-L2 messaging protocol
  • Message verification

What You'll Do

  • Send L1 to L2 message
  • Consume L2 to L1 message
14
Production Key Management
Account guardian patterns, key rotation, and production security on Starknet.
30 min

What You'll Learn

  • Guardian patterns
  • Key rotation

What You'll Do

  • Implement guardian
  • Production deploy checklist
15
Internals: How the Provable Ledger Works
Proof generation, state diffs, Sierra compilation, and the proving pipeline.
30 min

What You'll Learn

  • Sierra and CASM compilation
  • Proof generation pipeline

What You'll Do

  • Inspect compiled contracts
  • Trace proof generation
Live Sandbox

Try Starknet in your browser
— no install required

Spin up a Starknet devnet directly in your browser. Write Cairo, deploy contracts, and test — all from a single tab.

Launch Sandbox →
Pricing

Start your Starknet apprenticeship.
7 days free on every tier.

Start with a free trial — full access to your chosen tier for 7 days. Cancel anytime. Annual plans save 2 months.

Apprentice
$15/mo
or $150/year (save $30) · 1 chain
  • 1 blockchain codex of your choice
  • All modules — full curriculum
  • Cloud progress tracking
  • Completion certificates
  • GitHub portfolio scaffold
  • All curriculum updates
Start Free Trial →
Practitioner
$30/mo
or $300/year (save $60) · 3 chains
  • 3 blockchain codexes of your choice
  • Everything in Apprentice
  • Voice Pro (ElevenLabs, OpenAI, Google)
  • ChainKit Dashboard
  • Community rank
Start Free Trial →
Master
$50/mo
or $500/year (save $100) · all 6 chains
  • All 6 blockchain codexes
  • Everything in Practitioner
  • Live Sandbox environment
  • Priority support
  • Early access to new chains
Start Free Trial →

Previously purchased The XRPL Codex? Your access is permanent. Link your purchase to unlock your grandfathered access.

The Starknet lore is waiting
to be mastered

16 modules. One real project. Every error explained. Start your free trial today.

Start Your Free Trial →
7-day free trial on all tiers · Cancel anytime · Annual plans save 2 months
Related Chains

Continue your apprenticeship

The Ethereum Codex

Starknet is an Ethereum L2. Understanding Ethereum's EVM, gas model, and security assumptions gives you the full picture of the L1 that Starknet inherits from.

Explore Ethereum →
The NEAR Codex

NEAR offers a different scaling approach through dynamic sharding. Compare ZK rollups to sharded execution for a complete view of blockchain scalability.

Explore NEAR →