StarkWare Ships Block-Sized Proofs on Starknet Mainnet

StarkWare has launched block-sized proofs on Starknet Mainnet, allowing applications to cover computation of up to 1.1 billion L2 gas with a single proof submitted in one transaction. The figure matters because it matches the scale of an entire block's worth of computation, compressed into one verifiable submission.

The mechanics are direct. Applications run their complex logic offchain and then submit a proof to Starknet, which verifies it on its mainnet. Under the new model, developers pay for the proof rather than for full onchain execution. Starknet is an Ethereum Layer 2 scaling solution, and the feature formally separates where application logic runs from where that logic is verified: computation moves offchain, while verification stays on the Starknet network.

What does this change for developers?

The practical shift is in the cost structure. Previously, an application performing heavy computation paid for every unit of gas that execution consumed on the network. A workload measured in hundreds of millions of gas units translated directly into a proportional fee bill. Under the proof-based model, the developer pays to generate and verify a proof instead. For computation reaching the 1.1 billion gas ceiling, the economics tilt toward whoever can run the logic cheaply offchain — in effect, standard server infrastructure — and then purchase only the verification step on Starknet.

To put the number in context: 1.1 billion gas is the computational budget of a full Starknet block. A single application can now account for block-scale computation and settle it in one transaction, rather than spreading execution across blocks or paying gas rates on every operation.

Where the logic runs, and where it is checked

StarkWare's design decouples two functions that Layer 2 applications have traditionally bundled together. The application's logic executes wherever the developer chooses — offchain, on hardware the developer controls or rents. The proof of that execution is what reaches Starknet. The network's role narrows to verification: checking that the submitted proof corresponds to a valid computation.

This division has operational consequences. Teams building computation-intensive applications — the category most constrained by per-transaction gas limits — gain headroom that block-level execution caps previously denied them. The verification step, not the execution footprint, becomes the onchain cost.

The commercial logic for StarkWare

For StarkWare, the feature positions Starknet as a verification layer rather than only an execution layer. Developers who run logic offchain still need the network's verification, which keeps fee flow tied to Starknet even as computation migrates away from it. The 1.1 billion gas ceiling defines the current envelope: proofs up to that size are supported at launch.

The parameter also sets a benchmark competitors will be measured against. Other zero-knowledge Layer 2 teams now face a launch where block-scale proofs are in production on a mainnet, not on a roadmap.

What comes next

The launch is live on Starknet Mainnet now. The open question for practitioners is adoption: whether applications with genuinely computation-heavy workloads migrate their execution offchain and begin settling proofs at Starknet, and whether StarkWare raises the 1.1 billion gas ceiling as demand for block-sized verification grows.