Skip to main content

This site is for educational purposes only. Nothing here constitutes financial advice.

Topic 58 of 189

StarkNet Architecture

How StarkNet's Cairo VM, account-abstraction-native model, and STARK prover differ from EVM rollups — and what Madara, prover decentralisation, and the broader Starkware ecosystem mean for the network's future.

Beginner
8 min readUpdated November 2026Block Clarity Hub Editorial Team

The basics

What Makes StarkNet Different

StarkNet is a ZK rollup from Starkware, launched in alpha 2021 and mainnet in November 2021. Unlike zkSync Era (which compiles Solidity), StarkNet uses its own language and VM: Cairo. This was a deliberate choice — Cairo is purpose-built to be efficient inside STARK proofs. The cost: developers can't just port Solidity contracts; they have to rewrite in Cairo. The benefit: throughput, proving speed, and architectural cleanness.

Cairo as a Language

Cairo (now Cairo 1.0+) is a Rust-flavoured smart contract language. It's not EVM-compatible — there's no Solidity bridge. Instead, it's designed to translate efficiently into the polynomials a STARK prover needs. On Starknet, which Cairo targets, native account abstraction means every account is a contract and there are no EOAs. The language itself offers generics, traits with associated types, pattern matching, and variables that are immutable by default. Many developers describe it as 'feels modern' compared to Solidity's Ethereum-era constraints.

STARK Proofs at the Core

StarkNet uses STARK proofs end-to-end — no SNARK wrapping like zkSync. STARK proofs are larger than SNARK proofs, which generally raises on-chain verification cost on Ethereum (though Starknet's Grinta post says its onchain costs have become almost negligible thanks to advances in its proving stack and blobs). They require no trusted setup and rely only on hash functions, which makes them resistant to known quantum attacks; Starknet as a whole is targeting full post-quantum security in 2027, so this covers the proofs rather than every layer. Starkware's argument: the trusted-setup-free guarantee and quantum resistance are worth it for long-lived infrastructure. Since late 2025 Starknet blocks have been proven by S-two, StarkWare's Circle-STARK prover, which replaced Stone.

  • Custom VM (Cairo) instead of EVM — better for proving, worse for porting
  • Native account abstraction throughout
  • STARK proofs end-to-end — no trusted setup, post-quantum secure
  • Larger proofs = higher L1 verification cost, but transparent + quantum-resistant

Key Takeaways

  • StarkNet uses Cairo, a custom VM optimised for STARK proving
  • No EVM compatibility — developers rewrite in Cairo
  • STARK proofs are transparent (no trusted setup) and post-quantum secure
  • The trade-off: developer onboarding friction in exchange for cryptographic cleanness and proving speed

Going deeper

The Cairo VM and Polynomial-Friendly Execution

Cairo VM is a register-based VM (unlike EVM's stack-based design) with explicit memory model. Every operation translates directly into polynomial constraints the STARK prover can prove. This 'algebraic friendliness' is the source of Cairo's proving speed — there's no impedance mismatch between execution semantics and proof generation. EVM-compatible ZK rollups (such as ZKsync, where EVM code is compiled for or interpreted on EraVM, and, until its July 2026 sunset, Polygon zkEVM) have to map EVM semantics onto their own VM or circuits, whereas Cairo programs run directly on the VM the prover is built for. Starknet's current prover, S-two (which replaced Stone on mainnet in late 2025), is described by StarkWare as generating proofs up to an order of magnitude faster than Stone.

Madara — The Modular StarkNet Stack

Madara is the StarkNet equivalent of the OP Stack: an open framework letting anyone deploy a StarkNet-compatible chain. As of 10 November 2026, the Madara docs describe it as an official implementation of the SN Stack that lets anyone start a new appchain settling either to Ethereum or to Starknet.

Account Abstraction Throughout

StarkNet's native AA is among the most thorough of any chain. Every account on StarkNet is a deployed contract. Wallets listed in Starknet's own directory include Ready (from Argent Labs, the team behind the earlier Argent and Argent X wallets; its browser extension is now called Ready X), Cartridge Controller and Xverse, with Braavos and Argent accounts supported on Ledger. Features that need ERC-4337 plumbing on Ethereum mainnet, such as custom signature schemes (social recovery, biometric signing) and paying fees in other tokens, are what Starknet's docs list as natively enabled by account abstraction, and the Grinta release added a standardized paymaster interface.

StarkEx — The Centralised Cousin

Separately from StarkNet, Starkware operates 'StarkEx' — a centralised proving service used by specific applications (past examples are dYdX V3, ImmutableX and Sorare, all now listed as archived by ETHBEAT, formerly L2BEAT). StarkEx is operationally simpler — applications use it as a SaaS — but isn't a public chain. The distinction matters: StarkNet is the permissionless rollup; StarkEx is the white-label proving infrastructure. Both were proved for years with the same Stone prover, which S-two has since replaced on Starknet.

Key Takeaways

  • Cairo VM's register-based, algebraically friendly design is built for efficient STARK proving
  • Madara is the StarkNet equivalent of OP Stack — open framework for new chains
  • Account abstraction is built in throughout; wallets such as Ready (from Argent Labs) and Braavos are built on this
  • StarkEx is Starkware's centralised SaaS prover — distinct from StarkNet the public rollup

Under the hood

Prover Decentralisation Roadmap

StarkNet's proving is still run by StarkWare: ETHBEAT (formerly L2BEAT) describes state advancement as a permissioned pipeline through StarkWare's SHARP service (using Stwo for proving tasks and Stone for the roots of the recursive tree), and since Starknet v0.14.0 (September 2025) sequencing is spread across several sequencers that StarkWare still controls. ETHBEAT lists Starknet at Stage 1 but notes that it does not pass the walkaway test. Starknet's decentralization roadmap says fully decentralized sequencing and proving are still to come in future versions. One route is a permissionless prover marketplace where any party can submit proofs and compete on speed and cost, which would require solving non-trivial problems: ensuring honest proof generation, preventing griefing via slow provers, and creating fair fee distribution.

Settlement and Withdrawal Times

StarkNet posts proofs to Ethereum periodically, and a withdrawal can be completed on L1 once the proof covering it has been verified there, with no optimistic-style challenge window — much faster than an optimistic rollup's week-long delay. Deposit is near-instant. The bridge contract on L1 enforces the proof verification, so an invalid state update cannot be settled. Exits are not fully self-service, though: ETHBEAT notes that there is no user-callable forced-inclusion function, that a censored user can only ask a Security Council minority to include their message, and that funds can be frozen if the operator censors a withdrawal transaction. Sequencer trust is therefore in flux during the decentralisation transition.

StarkNet's Ecosystem and TVL

StarkNet TVL is smaller than the largest EVM-based rollups (ETHBEAT, formerly L2BEAT, lists about $330 million for Starknet on 10 November 2026, against about $13.9 billion for Base and $9.2 billion for Arbitrum One, though ahead of ZKsync Era at about $216 million) — partly because Cairo's lack of Solidity compatibility raised the barrier to deploying existing protocols. The native ecosystem includes apps such as Ekubo (a DEX) and Vesu (lending), but Uniswap, Aave and Lido themselves are not deployed on Starknet (DefiLlama lists none of them there), which limits the pull for users seeking those established DeFi brands. The trade-off plays out in real metrics — StarkNet's architectural advantages translate slowly into ecosystem mass when the developer ramp is higher.

v0.13 and the Volition Model

StarkNet's v3 transactions (introduced in v0.13.0, January 2024) reserve fields for 'volition' — a planned per-application choice between data availability on Ethereum (full security) or on a cheaper DA layer (cheaper but with weaker guarantees). Starknet's version notes (which run through v0.14.1, December 2025) list volition only as a reserved feature and do not record it as released; since v0.13.1 (March 2024) state diffs are posted to Ethereum as EIP-4844 blobs. If volition ships, high-stakes DeFi could stay on Ethereum DA while game state and other less-critical data could use cheaper alternatives, similar in spirit to the EigenDA / Celestia tradeoffs but built into the protocol. ETHBEAT lists Starknet's data availability as onchain on Ethereum; a volition option would matter more as adoption grows.

Cairo Is a Real Investment

If you're building on StarkNet, plan for substantial Cairo learning. The language is approachable and well-documented, but it's genuinely different from Solidity — different mental model, different patterns, different debugging tools. Existing Solidity codebases don't port; they get rewritten. The investment pays off in proving speed and security, but it's a multi-month onboarding for a previously-Ethereum team.

Key Takeaways

  • Prover decentralisation is on the roadmap; sequencing is already spread across several StarkWare-controlled sequencers
  • Withdrawals need no optimistic-style challenge window, so they are much faster than optimistic rollups'
  • Ecosystem TVL is smaller than the largest EVM rollups, a gap partly attributed to Cairo's compatibility barrier
  • Volition (a per-application choice of Ethereum vs cheaper DA) is reserved in v3 transactions but not recorded as released in Starknet's version notes
  • Cairo is a real investment for teams porting from Solidity — months of onboarding

Related Content

Solver Networks

How solver markets shape DEX prices, the competitive structure across CoW Swap, 1inch Fusion, Hashflow, and other venues, and why solver consolidation is a central debate in DeFi market structure.

Liquidation Cascades

The mechanical structure of cascading liquidations — Black Thursday, May 19 2021, August 2024, October 2025 — what amplifies them, who profits, and why over-leverage creates correlated risk across the entire DeFi stack.

Flash Loan Economics

Why flash loans exist, the legitimate uses (arbitrage, collateral swaps, refinancing), and how the same primitive that enables capital-efficient DeFi also enables governance attacks and oracle manipulation.

zkSync Era Architecture

How zkSync Era's prover (Boojum), native account abstraction, and unique EVM-compatibility-via-zkEVM design differ from competing rollups — and what the architectural choices mean for users and developers.

Arbitrum Nitro and Stylus

How Arbitrum Nitro evolved from Arbitrum One's custom architecture to running Geth-on-WASM, what BoLD fraud proofs change, and what Stylus's WASM extension brings (Rust/C/C++ smart contracts).

Optimism Bedrock and the Superchain

How OP Mainnet's Bedrock architecture, fault-proof rollout, and Superchain interop strategy reshape Optimism from a single rollup into a widely deployed modular L2 framework (Optimism says 54 mainnet chains ran on the OP Stack as of October 2026).

Base Architecture

How Coinbase's Base L2 launched on the OP Stack and has been moving to its own Base-operated stack, how Coinbase's exchange-side integration drives uniquely smooth UX, what the sequencer's centralised reality means today, and the path to a 'stage-2' rollup.

Linea and Polygon zkEVM Compared

How two zkEVMs — Linea (Consensys) and Polygon zkEVM, whose Mainnet Beta sequencer was sunset on 3 July 2026 — compare on EVM-equivalence levels, prover technology, ecosystem strategy, and what each chain's positioning means for users and developers.

References & further reading