Starknet Chain Profile: Cairo VM Validity Rollup on Ethereum
Starknet is the production STARK-based validity rollup built by StarkWare on Ethereum. It runs Cairo VM rather than EVM, finalizes to L1 in roughly 90 minutes via cryptographic proofs (not 7-day optimistic challenges), and hosts $184,408,132 in TVL — anchored by Starknet BTC Staking ($43.1M), Vesu lending ($15.3M) and Endur liquid staking ($7.2M). This page covers consensus, throughput, ecosystem and peer-relative positioning, not how to swap.
Starknet is not a generalist EVM L2 — and that is the point. By choosing STARK validity proofs over optimistic fraud proofs, and Cairo VM over EVM compatibility, Starknet trades plug-and-play Solidity portability for two concrete advantages: cryptographic finality to Ethereum L1 in 5,400 seconds versus the 7-day challenge window on Arbitrum, Optimism and Base; and native protocol-level account abstraction, where every account is a smart contract from day one. The chain's $184,408,132 TVL is concentrated in Bitcoin yield infrastructure — Starknet BTC Staking alone is $43,097,087, roughly 23% of total chain TVL — alongside Vesu ($15.3M), Endur liquid staking ($7.2M), Troves yield ($4.0M) and Nostra Money Market ($3.2M). Native DEX liquidity is deliberately thin (JediSwap V1, 10KSwap and mySwap V1 are all under $1M), which makes Starknet a natural target for non-custodial cross-chain swap aggregators routing in and out of the chain. Starknet serves three audiences: Cairo-fluent developers who want STARK-grade proving and protocol-level account abstraction; Bitcoin holders looking for trust-minimized yield through STARK-verified staking; and infrastructure teams deploying app-chains on the Starknet Stack. The chain launched November 29, 2021, the STRK token shipped February 20, 2024, and the Cairo Native sequencer went live February 1, 2025 — a measured, infrastructure-first roadmap rather than a memecoin-driven one.
About Starknet
Starknet is an Ethereum Layer 2 validity rollup developed by StarkWare and launched as Mainnet Alpha on November 29, 2021. Unlike optimistic L2s such as Arbitrum or Base, Starknet posts cryptographic STARK proofs to Ethereum, allowing the L1 to verify rollup state correctness mathematically rather than waiting out a 7-day fraud window. The trade-off is a heavier prover stack and a non-EVM execution layer — Starknet runs Cairo VM, a STARK-friendly virtual machine that is not bytecode-compatible with Ethereum. Developers write in Cairo, a Rust-inspired language purpose-built for provable computation, which gives Starknet a clean separation from the EVM L2 cluster and locks it into its own tooling, wallet (Argent X, Braavos) and bridge ecosystem.
Economically, Starknet is dual-token at the gas layer: STRK is the native staking and governance asset (TGE on February 20, 2024 with a large airdrop to historical users), while ETH bridged from L1 has historically also been accepted as gas. The native STRK token currently anchors validator staking on testnet rollout and fee abstraction features that let dApps sponsor user fees via Cairo's native account-abstraction primitive. With Total Value Locked of $184,408,132 according to DefiLlama as of June 2026, Starknet sits behind Base ($3.84B), Arbitrum ($1.24B) and Polygon ($1.04B) but well above X Layer ($73.9M), Scroll ($10.8M) and Abstract ($11.1M) inside the EVM L2 category, despite not being bytecode-EVM at all.
On the protocol-distribution side, Starknet's TVL is unusually top-heavy. Starknet BTC Staking alone holds $43,097,087 — roughly 23% of the entire chain's TVL — making Bitcoin yield, not classic DeFi, the chain's largest single use case in 2026. Beyond that, Vesu lending sits at $15,280,606, liquid-staking protocol Endur at $7,195,819, Troves yield at $4,006,086, and Nostra Money Market at $3,175,943. Native DEX liquidity is comparatively thin (JediSwap V1, 10KSwap and mySwap V1 are all under $1M each), which reflects the chain's strategic pivot from being a general-purpose DeFi L2 toward becoming a Bitcoin-extension execution layer.
Starknet is best understood as a specialist L2 rather than a general one. It serves three audiences: developers who want STARK-grade cryptographic security and account abstraction baked into the protocol layer; Bitcoin holders looking for trust-minimized yield through STARK-verified staking constructions; and infrastructure teams that want to deploy app-chains using the same prover stack via Starknet Stack. If you arrived here looking to move assets across chains, a non-custodial cross-chain swap aggregator can route in and out of Starknet without forcing you to bridge manually — but this page is about the chain itself, not the routing layer.
Starknet technical parameters
Starknet's technical identity rests on two non-negotiable choices: validity proofs instead of fraud proofs, and Cairo VM instead of EVM. Every performance number, every ecosystem decision, and every wallet-compatibility friction point flows from those two choices. Understanding them is the difference between treating Starknet as 'another L2' and understanding what role it actually plays in the Ethereum stack.
| Consensus | Validity rollup (STARK proofs) inheriting Ethereum PoS |
|---|---|
| VM | Cairo VM |
| Block time | 2.5 s |
| Finality | 1.5 h |
| TPS | 3 typical / 992 max |
| Gas token | STRK / ETH (gas) |
| Launched | 2021-11-29 |
| Token standard | Cairo native (ERC-20-like / ERC-721-like) |
| Address | hex (felt252, up to 252 bits) |
Consensus mechanism
Starknet does not have an independent consensus mechanism — it is a validity rollup that inherits Ethereum's Proof-of-Stake consensus for state finality. Here is what actually happens: a centralized sequencer (currently operated by StarkWare) orders and executes transactions on Starknet, producing new state roots. A separate prover then generates a STARK proof attesting that the new state root is the correct result of executing those transactions according to Cairo VM rules. That proof is posted to a verifier contract on Ethereum L1. If the L1 verifier accepts the proof, the state transition is final — full stop, no challenge period, no fraud window. This is fundamentally different from Arbitrum and Optimism, which assume the state root is correct and give anyone 7 days to submit a fraud proof. Starknet's 5,400-second (90-minute) finality is the wall-clock time for proof generation plus L1 inclusion, not a security wait period. The trade-off: proving STARKs is computationally expensive, which is why Starknet's typical 3 TPS is materially lower than Base's 1,500 TPS — though the theoretical ceiling of 992 TPS, combined with the Stwo prover and February 2025 Cairo Native sequencer rollout, shows the headroom is engineering work, not protocol limit.
Performance context
Raw numbers without context mislead. Starknet posts 2.5-second block times, ~3 TPS typical throughput, 992 TPS theoretical maximum, and 5,400-second L1 finality. Compared with peers: Base achieves 1,500 typical TPS but inherits a 7-day optimistic withdrawal window; Arbitrum hits 40 TPS typical with the same 7-day window; Scroll's bytecode-EVM zkEVM does 30 TPS typical and finalizes in 3,600 seconds. The honest read: Starknet is mid-pack on raw throughput, top-tier on cryptographic finality among non-bytecode-EVM peers, and architecturally most similar to Scroll among the L2 cohort — but with a non-EVM VM that makes direct comparison messy. For a user moving $100K cross-chain, Starknet's 90-minute finality means real settled funds on L1 inside two hours, versus a 7-day wait on Arbitrum or trust in a third-party fast-withdrawal bridge.
Starknet ecosystem map
Starknet's ecosystem reflects a chain that has pivoted decisively toward Bitcoin yield infrastructure. The top eight protocols by TVL on Starknet are dominated by a single Bitcoin-staking primitive, with classic DEX liquidity intentionally underweighted relative to lending, liquid-staking and BTC-yield constructions. The shape of this ecosystem is unusual inside the EVM L2 category and reveals where Starknet's product-market fit has settled in 2026.
Infrastructure
Starknet BTC Staking ($43,097,087 TVL) is the single largest protocol on the chain, accounting for roughly 23% of total network TVL. It uses STARK proofs to verify Bitcoin staking constructions and positions Starknet as a credible Bitcoin-extension execution layer rather than a generalist DeFi L2.
Lending
Vesu ($15,280,606 TVL) is Starknet's flagship lending protocol — a permissionless, isolated-pool money market built natively in Cairo. Nostra Money Market ($3,175,943 TVL) is the second lending pillar, offering interest-bearing positions with Cairo-native account-abstraction UX for gas sponsorship.
Wallet
Endur ($7,195,819 TVL) is Starknet's leading liquid staking protocol issuing xSTRK, the canonical liquid-staked STRK derivative. It plugs directly into Cairo-native validator staking — an area Starknet rolled out only after the STRK token launch and Cairo Native sequencer upgrade.
Lending
Troves ($4,006,086 TVL) is a yield protocol that aggregates positions across Vesu, Endur and Starknet BTC Staking — its existence signals enough underlying yield primitives to justify a structured-yield meta-layer, which is a maturity milestone for any L2.
DEX
Native DEX liquidity is deliberately thin: JediSwap V1 ($701,615), 10KSwap ($681,859) and mySwap V1 ($610,949) sit well below $1M each. Real swap liquidity on Starknet routes through aggregators and the cross-chain swap layer rather than concentrated AMMs — a defensible design given Cairo VM's non-EVM execution model.
Bridge
StarkGate is the canonical L1↔L2 bridge for ETH, USDC and select ERC-20s, with finality on the L2 side typically 90 minutes (5,400 seconds) compared with 7 days (604,800 seconds) on Arbitrum and Optimism — a direct consequence of using validity proofs instead of optimistic challenges.
| # | Protocol | Category | TVL |
|---|---|---|---|
| 1 | Starknet BTC Staking | Staking Pool | $43.10M |
| 2 | Vesu | Lending | $15.28M |
| 3 | Endur | Liquid Staking | $7.20M |
| 4 | Troves | Yield | $4.01M |
| 5 | Nostra Money Market | Lending | $3.18M |
| 6 | JediSwap V1 | Dexs | $701.62K |
| 7 | 10KSwap | Dexs | $681.86K |
| 8 | mySwap V1 | Dexs | $610.95K |
Starknet vs peers
Inside the EVM L2 category Starknet is the only non-EVM execution environment — every peer here (Arbitrum, Optimism, Base, Polygon, X Layer, Scroll, Abstract) is EVM-compatible at some level. That single architectural choice — Cairo VM over zkEVM or optimistic-EVM — explains nearly every difference in finality, TVL and ecosystem shape that follows.
| Chain | Block | Finality | TPS | TVL |
|---|---|---|---|---|
| Arbitrum | 250 ms | 168 h | 40 | $1.24B |
| Optimism | 2 s | 168 h | 30 | $0.00 |
| Base | 2 s | 13 min | 1.5k | $3.84B |
| Polygon | 2 s | 5 s | 60 | $1.05B |
| Starknetcurrent | 2.5 s | 1.5 h | 3 | $184.41M |
| X Layer | 2 s | — | 100 | $73.95M |
| Scroll | 3 s | 1 h | 30 | $10.79M |
| Abstract | 1 s | — | — | $11.13M |
Comparison insights
- Finality vs the optimistic cohort: Starknet finalizes to Ethereum L1 in 5,400 seconds (90 minutes) via STARK proofs. Arbitrum and Optimism both have 604,800-second (7-day) challenge windows. Base inherits the OP Stack with a reported 780-second finality assumption but uses the same 7-day withdrawal window in practice. For risk-sensitive users moving size, Starknet's validity-proof finality is materially closer to L1 economic finality than the optimistic peers.
- TVL ranking inside EVM L2: At $184,408,132, Starknet is the 4th-largest by TVL in this peer set — behind Base ($3.84B), Arbitrum ($1.24B) and Polygon ($1.04B), and well above X Layer ($73.9M), Scroll ($10.8M) and Abstract ($11.1M). For a chain that requires a completely new execution VM and language (Cairo), holding the #4 EVM L2 TVL slot is a non-trivial achievement.
- Throughput trade-off: Starknet's measured typical throughput sits at 3 TPS with a 992 TPS theoretical ceiling and 2.5s block time. Base hits 1,500 TPS typical (3,571 max), and Arbitrum sits at 40 TPS typical with 0.25s block time. The gap is real — validity proving is expensive — but the 992 TPS ceiling shows the architecture is not capped, and the Stwo prover and Cairo Native sequencer are designed to close it.
- Ecosystem shape: Starknet is the only L2 in this peer set where Bitcoin staking, not classic DEX/lending, is the dominant TVL category. Arbitrum and Base have deep AMM and perp DEX liquidity; Polygon hosts mainstream consumer apps; Scroll and X Layer are bytecode-EVM-equivalent zkEVMs targeting EVM developer reuse. Starknet has staked out a specialist position — Bitcoin yield + STARK-native applications — that the bytecode-compatible peers structurally cannot replicate.
- Wallet and developer overhead: Because Starknet uses felt252 addresses and Cairo bytecode, MetaMask does not natively work — users need Argent X or Braavos, and developers cannot redeploy Solidity contracts. Every other chain in this peer set accepts MetaMask out of the box. This is the single largest friction point for Starknet adoption versus its EVM L2 peers, and it is structural rather than incidental.
Starknet timeline
Starknet's Mainnet Alpha went live on November 29, 2021, making it one of the first production-deployed STARK-based rollups on Ethereum and a direct contemporary of Arbitrum (August 2021) and Optimism (December 2021). The early years were defined by aggressive cryptographic R&D rather than TVL growth: StarkWare shipped the Cairo language, the Cairo VM and the SHARP shared prover, and decoupled Starknet from its earlier StarkEx app-specific model. The STRK token launched on February 20, 2024 with a large airdrop to historical users — a notable distribution event that finally gave the network its own economic asset distinct from bridged ETH, though it landed in a market saturated with L2 token launches. Through 2024 the protocol team focused on prover throughput and developer experience, particularly the Stwo next-generation prover designed to dramatically reduce proving cost per transaction. On February 1, 2025, the Cairo Native sequencer rolled out, compiling Cairo execution directly to native machine code and substantially cutting sequencer-side execution latency — a meaningful infrastructure upgrade rather than a user-facing feature. Unlike Solana (multiple multi-hour outages 2021-2024) or BSC (~$570M Token Hub cross-chain bridge exploit in October 2022), Starknet has no high-profile chain-level hack or outage on record as of June 2026 — partially a credit to the validity-proof security model, partially reflecting smaller surface area: with TVL at $184M, it is simply a smaller target than the $5B+ EVM L1s and L2s. The chain's recent direction has shifted toward Bitcoin-extension use cases, evidenced by Starknet BTC Staking now accounting for ~23% of all on-chain TVL.
- 2021-11-29launchMainnet Alpha launch
- 2024-02-20milestoneSTRK token launch and airdrop
- 2025-02-01upgradeCairo Native sequencer rollout
Developer reference
Starknet exposes a JSON-RPC compatible with the Starknet spec (not Ethereum JSON-RPC) at https://starknet-mainnet.public.blastapi.io as a public default endpoint; production deployments should use a paid provider such as Alchemy, Infura, or Nethermind's Juno node. The primary block explorer is starkscan.co (Voyager is the alternative). Address format is hex felt252 — up to 252 bits, NOT 160-bit Ethereum addresses — so EVM tooling that hard-codes 20-byte addresses will break. Contracts and transactions are written in Cairo (Rust-inspired, compiled to Sierra → CASM). Account abstraction is native: every account on Starknet IS a smart contract, with no externally-owned EOA equivalent. Official docs live at docs.starknet.io. Supported wallets include Argent X, Braavos, Ledger and WalletConnect. Key SDKs: starknet.js (JavaScript/TypeScript), starknet.py (Python), starknet-rs (Rust). The Cairo Native sequencer rollout in February 2025 cut sequencer execution time by compiling Cairo directly to native machine code.
Assets swappable on Starknet
Grouped by category. Click any asset to open its swap page for a live quote.
DeFi assets
1 assets
Starknet settle-time comparison
Shorter bars mean faster confirmations. Real settle time also depends on network congestion — figures are indicative.
Starknet asset coverage comparison
Longer bars mean more assets are swappable on that chain.
Popular swap routes involving Starknet
Routes below reflect actual user preference. Click to jump straight to the swap page.
Starknet FAQ
01Is Starknet a Layer 2 and is it decentralized?
Yes, Starknet is an Ethereum Layer 2 validity rollup that posts STARK proofs to L1, so it inherits Ethereum PoS security for state correctness. Sequencing and proving are still operated primarily by StarkWare in 2026 — full decentralization of the sequencer and prover is on the published roadmap but not yet shipped, which is the same status as Arbitrum, Optimism and Base.
02What is Starknet's finality time and how does it compare to optimistic L2s?
Starknet's finality on Ethereum L1 is approximately 5,400 seconds (90 minutes) — the time for a STARK proof to be generated, posted and verified on L1. By contrast, optimistic rollups like Arbitrum and Optimism have a 604,800-second (7-day) challenge window before withdrawals finalize. Starknet's validity-proof model is roughly 112x faster to final L1 settlement.
03Is Starknet EVM-compatible?
No. Starknet runs the Cairo VM, not the EVM. Contracts are written in Cairo (a Rust-inspired language compiled to Sierra and CASM), and there is no bytecode-level EVM compatibility. Solidity contracts cannot be directly redeployed. This is the core differentiation versus zkEVMs like Scroll or X Layer, and the reason Starknet has its own wallet stack (Argent X, Braavos) rather than reusing MetaMask.
04What's the difference between Starknet's STARK proofs and zkSNARK rollups like zkSync or Scroll?
STARK proofs (Scalable Transparent Arguments of Knowledge) are quantum-resistant, require no trusted setup, and scale better with computation size, but the proofs themselves are larger than SNARKs. zkSNARK rollups like Scroll use Halo2/OpenVM SNARKs which produce smaller proofs but historically required trusted setups. Both inherit Ethereum PoS finality — the difference is cryptographic assumption and proof size, not security model.
05What is STRK and is it required for gas on Starknet?
STRK is Starknet's native token, launched on February 20, 2024 alongside an airdrop to historical users. It is used for staking, governance, and as one of two accepted gas tokens — Starknet supports paying gas in both STRK and bridged ETH. dApps can also use Cairo's native account-abstraction primitive to sponsor user gas entirely, so end users may interact without holding either token.