Protocol 25 min read

Starknet Explained

The leading ZK-rollup on Ethereum using STARK proofs. Understanding Cairo, the sequencer architecture, and Starknet's path to becoming a settlement layer.

What is Starknet?

Starknet is a permissionless, decentralized ZK-rollup (zero-knowledge rollup) that operates as a Layer 2 network on Ethereum. It uses STARK cryptographic proofs to enable scalable, secure transactions while inheriting Ethereum's security guarantees.

Unlike optimistic rollups that assume transactions are valid and use fraud proofs to challenge invalid ones, ZK-rollups like Starknet generate mathematical proofs that cryptographically verify the correctness of all transactions. This provides immediate finality on L2 and stronger security guarantees.

Key Insight

Starknet processes thousands of transactions off-chain, compresses them into a single STARK proof, and posts only the proof and state diff to Ethereum. This achieves 100-200x cost reduction compared to Ethereum L1.

Why Starknet Matters

Starknet represents a different approach to Ethereum scaling than competitors like Optimism or Arbitrum. By using validity proofs (ZK proofs) instead of fraud proofs, Starknet offers:

  • Instant finality - No 7-day withdrawal period like optimistic rollups
  • Cryptographic security - Mathematical guarantees, not economic incentives
  • Better compression - Only state diffs posted to L1, not full transaction data
  • Post-quantum resistance - STARK proofs are quantum-resistant (unlike SNARKs)

STARK vs SNARK: Why It Matters

The ZK-rollup space is divided between two main proof systems: SNARKs (used by zkSync, Polygon zkEVM) and STARKs (used by Starknet). Understanding the difference is crucial for evaluating these protocols.

No Trusted Setup

STARKs require no trusted setup ceremony. SNARKs need a multi-party computation that, if compromised, could allow fake proofs. STARKs are "transparent."

Quantum Resistant

STARKs rely on hash functions, not elliptic curves. When quantum computers arrive, STARKs remain secure while SNARKs become vulnerable.

Larger Proofs

The trade-off: STARK proofs are larger (~100KB vs ~300B for SNARKs), meaning higher L1 verification costs. Starknet optimizes this with recursive proofs.

The Trusted Setup Risk

SNARK systems like zkSync's require a trusted setup where participants must destroy their secret contributions. If even one participant kept their secret, they could forge proofs. STARKs eliminate this risk entirely through mathematical transparency.

The Cairo Language

Cairo is Starknet's native programming language, purpose-built for writing provable programs. Unlike Solidity, which was retrofitted for ZK proofs, Cairo was designed from the ground up to express computations that can be efficiently proven.

Why a New Language?

ZK proofs work by converting programs into mathematical constraints (called an "algebraic intermediate representation" or AIR). Not all operations are equally easy to prove:

  • Cheap to prove: Addition, multiplication, hash functions
  • Expensive to prove: Division, comparisons, branching
  • Very expensive: Arbitrary memory access, loops with variable bounds

Cairo's syntax and semantics guide developers toward "ZK-friendly" patterns, making it easier to write efficient provable code. The language has evolved significantly:

Cairo Evolution

  • Cairo 0: Assembly-like, difficult to use
  • Cairo 1.0: Rust-inspired syntax, much more developer-friendly
  • Cairo Native: Compiles to native machine code for faster execution

Developer Experience

Cairo 1.0 brought a dramatically improved developer experience with Rust-like syntax, a type system, and better tooling. Projects like Kakarot are even building an EVM interpreter in Cairo, allowing Solidity contracts to run on Starknet.

Architecture Deep Dive

Understanding Starknet's architecture helps explain its performance characteristics and the trade-offs involved in its design.

The Sequencer

The sequencer is currently the centralized component that orders and executes transactions. It performs several functions:

  1. Receives transactions from users
  2. Orders transactions into blocks
  3. Executes transactions and computes state changes
  4. Generates execution traces for the prover

The Prover

SHARP (Shared Prover) takes execution traces from the sequencer and generates STARK proofs. This is computationally intensive but can be parallelized. Multiple Starknet blocks are aggregated into a single proof through recursive proving.

State Diffs & Data Availability

Rather than posting full transaction data to Ethereum (like optimistic rollups), Starknet posts only state diffs - the changes to account balances and contract storage. This significantly reduces L1 costs.

~$0.01 Average transaction cost
~100 TPS Current throughput
2-3 hrs L1 finality

Native Account Abstraction

Unlike Ethereum where account abstraction was added as ERC-4337, Starknet has native account abstraction built into the protocol. Every account on Starknet is a smart contract, enabling:

  • Custom signature schemes (WebAuthn, multisig, etc.)
  • Social recovery
  • Gas payment in any token
  • Session keys for improved UX

The Bolt Upgrade

The Bolt upgrade represents a significant performance improvement for Starknet, focusing on sequencer efficiency and block production.

Key Improvements

  • Parallel Transaction Processing: Multiple transactions executed simultaneously
  • Optimized State Management: More efficient state diff computation
  • Reduced Block Times: Faster block production without sacrificing security
  • Better Fee Estimation: More predictable transaction costs

Bolt also introduced improvements to the mempool and transaction ordering, reducing the time between transaction submission and inclusion in a block.

Cairo Native Execution

Cairo Native is a significant optimization that compiles Cairo code directly to native machine code rather than interpreting it through the Cairo VM.

How It Works

Previously, Cairo programs ran in an interpreted environment (the Cairo VM). Cairo Native uses LLVM to compile Cairo to native x86/ARM instructions, providing:

  • 10-100x faster execution for complex contracts
  • Lower sequencer resource usage
  • Higher throughput potential

Proof Generation Unchanged

Cairo Native optimizes execution but doesn't change how proofs are generated. The sequencer runs faster, but the prover still works with the same execution traces.

Bitcoin Integration

Starknet's roadmap includes ambitious plans for Bitcoin integration, positioning it as a settlement layer that bridges both Ethereum and Bitcoin ecosystems.

The Vision

StarkWare envisions Starknet as a "settlement layer" that can verify STARK proofs from multiple sources - including Bitcoin. This would enable:

  • Bitcoin Light Client: Verify Bitcoin block headers on Starknet
  • Trustless BTC Bridges: Move BTC to Starknet without centralized custodians
  • Cross-Chain Atomic Swaps: Trade ETH for BTC atomically
  • Bitcoin DeFi: Use BTC in Starknet DeFi protocols

Technical Approach

The integration relies on implementing Bitcoin script verification in Cairo, allowing Starknet to validate Bitcoin transactions. Combined with OP_CAT proposals on Bitcoin, this could enable two-way bridges.

STRK Tokenomics

STRK is Starknet's native token, serving multiple functions in the network:

Token Utility

  • Transaction Fees: Pay for computation and state updates
  • Staking: Secure the network as it decentralizes
  • Governance: Vote on protocol upgrades and parameters

Distribution

The STRK token launched in February 2024 with an airdrop to early users. The distribution includes allocations for:

  • Community provisions (airdrops, grants)
  • Core contributors (StarkWare)
  • Investors
  • Foundation reserve

Inflation Considerations

STRK has ongoing emissions for staking rewards and ecosystem incentives. Investors should monitor the inflation schedule and how fee burn mechanisms might offset new token issuance over time.

Roadmap & Future

Starknet's roadmap focuses on three key areas: performance, decentralization, and ecosystem expansion.

Near-Term (2024-2025)

  • Decentralized Sequencing: Move away from single sequencer
  • Data Availability Sampling: Reduce L1 costs further
  • Volition: Choose between on-chain and off-chain data availability
  • Parallel Proving: Multiple provers competing/cooperating

Medium-Term

  • Layer 3s: Application-specific chains settling on Starknet
  • Bitcoin Settlement: Full Bitcoin integration
  • Cross-Rollup Communication: Atomic transactions across ZK-rollups

Investment Thesis

Starknet bets on ZK technology being the endgame for blockchain scaling. If STARK proofs become the dominant scaling solution, Starknet's first-mover advantage in tooling, ecosystem, and developer experience could prove decisive.

Key risks include: execution complexity, competition from EVM-compatible ZK-rollups, and the need for continued innovation in proof generation costs.