Enjoy the security and feel of Ethereum with the scale of a ZK-Rollup
We’re building StarkNet in four steps:
- Step 0 — Foundations (completed*)
- Step I — Planets: Single-App Rollups
- Step II — Constellations: Multi-App Rollups
- Step III — Universe: A Decentralized Rollup
We expect to have Step I deployed in a few short months, and be well on our way to Steps II & III by the end of 2021.
StarkWare is building StarkNet, a decentralized, permissionless and censorship-resistant STARK-powered L2 ZK-Rollup that supports general-computation over Ethereum. It is based on the Turing-complete Cairo language.
Developers, users and StarkNet nodes will be able to do everything one would expect from a permissionless L2 Rollup: Developers may build applications implementing their own business logic and deploy them on StarkNet. Users may send transactions to StarkNet to be executed, just like they interact with Ethereum today. StarkNet nodes and participants will be crypto-economically incentivized to ensure the network operates efficiently and fairly.
All StarkNet transactions will be periodically batched, and their validity will be proven in a STARK proof, to be verified on Ethereum. As the computational effort required to verify STARK proofs is exponentially small compared to the computation proven, StarkNet will scale Ethereum by orders of magnitude.
Since all StarkNet state transitions will be STARK-proven, only valid ones will be accepted on Ethereum. All data required to reconstruct the full StarkNet state will be published on-chain. Anyone will be able to run their own StarkNet node. These properties will make StarkNet as secure and permissionless as Ethereum.
We’ve been at it for three years, and have already achieved some remarkable milestones in turning “Moon Math” into production-grade and efficient software running on Ethereum. The way StarkWare does things is tackle the hard problems first, build the core technology, and then release it to production in piecemeal fashion. We will continue to build in this manner as we bring StarkNet to completion.
Step 0 — Foundations
StarkWare has completed laying down some important foundations for StarkNet.
Cairo is our Turing-Complete High-Level Language & framework for producing STARK proofs for general computation. Instead of hand-crafting complex “circuits” or AIRs, an application developer may use Cairo to define any business logic, have it proven off-chain, and verified on-chain. Cairo is in production on Mainnet, and is also available to developers.
In a couple of weeks we will launch on a public Ethereum testnet an Alpha version of Cairo’s Generic Proof Service (GPS). This will allow developers to build their own applications using Cairo, implementing whatever business logic they wish. They will send their Cairo code to the GPS to be proven, and then verified on-chain.
GPS enables a single proof to assert the integrity of execution of altogether separate and independent applications, thereby giving those applications the ability to amortize the gas expense of proof verification amongst them.
Cairo and GPS are the basis of StarkNet — our decision to externalize both to developers provides them with early exposure to this technology, not only so they can start building on top of it, but also so they may influence StarkNet’s evolution.
We shall continue developing Cairo based on the needs and feedback of the developer community. We shall enhance this language with new features, syntax, and builtins that improve its usability, and we shall continue to develop and improve Cairo tooling: compilers, tracer/debugger, and integrations to common IDEs.
StarkNet will have Cairo running under the hood.
The STARK Software Stack
StarkWare has developed the most powerful proof system in the ecosystem, and it’s been live on Mainnet for months. StarkWare has also developed ethSTARK, our open-source prover, which is 20X faster than any other prover; it offers both zero-knowledge and post-quantum-secure signatures.
Our scaling measurements — not extrapolations, nor promises — include the processing of 300K transactions in a single proof on Mainnet, achieving the world record in Rollup throughput: 3K tps. In the process, we’ve achieved the world record for Rollup gas efficiency: 315 gas/tx, orders of magnitude cheaper than transactions on Ethereum L1.
This technology will be the cornerstone of the decentralized Proving Layer of StarkNet, and hence we shall release additional and enhanced provers as part of StarkNet’s development (more on that in an upcoming blog post).
StarkEx is our L2 scalability engine. It has been serving DeversiFi’s customers on Mainnet since June 2020. It will power both dYdX and ImmutableX starting in a few short weeks. StarkEx can handle complex trading logic (spot trading, derivatives, NFTs) as well as payments.
Developing StarkEx was our way of dogfooding our toolchain and testing it against real-world needs. There’s nothing like the demands of actual applications and live users to help tools mature and evolve. It also helps us understand which elements need to be addressed to better serve the ecosystem — for example, integrations with wallets and block explorers.
StarkEx is a live example of the ability to scale applications using a STARK-based ZK-Rollup, and is the first application in production on Mainnet written in Cairo. As such, it will also be one of the applications running on StarkNet.
The Road Ahead
Step I — Planets: Single-App Rollups
This step will enable developers to build and deploy their own scalable applications on StarkNet.
At this point, each StarkNet instance will be able to run a single application. Different instances may run different applications.
The StarkNet framework will include the following:
- Mechanisms needed to generate STARK proofs for arbitrary Cairo logic, and then submit and verify them on Ethereum.
- Interactions with L1 Ethereum: deposits and withdrawals of L1 tokens, publishing of the on-chain data, Escape Mechanisms protecting StarkNet users from malicious StarkNet operators, etc.
- Management of the L2 user balances, and of the application’s storage and memory.
Developers will be able to focus solely on building their application’s business logic, and then move into production: deploy and run it at scale on StarkNet.
What enables us to build a general-computation scalable ZK-Rollup is the combination of:
- Cairo, which is a general-purpose Turing-complete programming language
- Our strong STARK stack (prover and verifier), that enables bundling enormous computations into a single proof
Step II — Constellations: Multi-App Rollups
The next step will support multiple applications running on the same StarkNet instance and accessing the same global L2 state. This will enable interoperability between different applications, as well as reduced gas cost due to improved economies of scale.
Cairo, the powerful STARK stack, and GPS amplify StarkNet’ competitive advantage in supporting a multi-app Rollup.
At this stage, StarkNet will be a fully functional framework for running multiple applications with any arbitrary business logic on top of Ethereum, with each instance run by a single operator.
An operator may now spin up a StarkNet node, and application developers may deploy their contracts on it. From the users’ perspective, StarkNet now looks and feels like Ethereum, with a higher scale.
Step III — Universe: Decentralized Rollup
The last step in the evolution of StarkNet is decentralizing its operation.
Intriguing R&D questions we’re now tackling that affect this stage include (i) using ZK-Rollups to improve consensus-reaching mechanisms, and (ii) designing crypto-economic mechanisms to incentivize the decentralized StarkNet contributors and operators (transaction sequencers, provers, etc.) to function efficiently, fairly and securely.
StarkWare is building StarkNet, a decentralized permissionless STARK-powered L2 ZK-Rollup over Ethereum, that supports general-computation based on the Cairo language.
StarkNet will enable applications to scale without compromising security, users to pay reasonable transaction fees, and the entire ecosystem to grow substantially and fulfill its promise.
We gladly invite the developer community to join us on this journey.