Editor's Note: This article comes fromBabbitt Information (ID: bitcoin8btc)Editor's Note: This article comes from
Babbitt Information (ID: bitcoin8btc)
StarkWare expects to deploy Phase 1 in the coming months and move into Phases 2 and 3 by the end of 2021. StarkNet built by StarkWare is a decentralized two-layer ZK Rollup driven by STARK, which can support the general computing of Ethereum.
, Author: StarkWare, Compiler: Kyle, published with permission.
Zero-knowledge proof research and development organization StarkWare stated that its layer-2 expansion solution ZK Rollup "StarkNet" has completed the basic construction (phase 0), namely the Turing-complete framework Cairo, the STARK software stack, and the layer-2 expansion engine StarkEx, which will be constructed later Phase 1 to Phase 3. Among them, Phase 1 will support single application Rollup "Single-App Rollup", which will enable developers to build and deploy their own scalable applications on StarkNet; Phase 2 will support multi-application Rollup "Multi-App Rollup", which will support Running and accessing multiple applications on the same StarkNet instance will enable interoperability between different applications and reduce Gas costs; phase three will support decentralized Rollup "Decentralized Rollup".
StarkWare expects to deploy Phase 1 in the coming months and move into Phases 2 and 3 by the end of 2021. StarkNet built by StarkWare is a decentralized two-layer ZK Rollup driven by STARK, which can support the general computing of Ethereum.
The following is the full text of the announcement issued by StarkWare (translated):
We are building StarkNet in four steps:
Step 0 - Basics (Completed*)
Step II - Constellation: Multi-Application Summary
introduce
Step III - Cosmos: Decentralized Aggregation
We expect to deploy Step I within a few months and be well on track to Steps II and III by the end of 2021.
introduce
We are building StarkNet, a decentralized, permissionless, and censorship-resistant STARK technology that supports L2 ZK-Rollup to support general computation on 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 scheme: developers can build applications that implement their own business logic and deploy them on StarkNet. Users can send transactions to StarkNet for execution, just like they interact with Ethereum today. StarkNet nodes and participants will enjoy cryptoeconomic incentives to ensure that the network operates efficiently and fairly.
All StarkNet transactions will be periodically batched and their validity will be proven through a STARK proof and verified on Ethereum. The computation required to verify a STARK proof is much smaller than the computation required to verify it, so StarkNet scales Ethereum by several orders of magnitude.
Since all StarkNet state transitions will be STARK-verified, only valid transitions will be accepted on the Ethereum network. All data needed to reconstruct the full StarkNet state will be published on-chain. Anyone can run their own StarkNet node. These properties will make StarkNet as secure and permissionless as Ethereum.
Cairo
We've been in development for three years and have achieved some remarkable milestones in turning "Moon Math" into production-grade efficient software running on Ethereum. The way we do things is to first solve the hard problems, build the core technology, and then gradually bring it into production. We will continue to build in this way as StarkNet is completed.
Step 0 — Basics
We've laid some important groundwork for StarkNet.
Cairo is our Turing-complete high-level language and framework for generating STARK proofs for general computation. Application developers can use Cairo to define any business logic and have it proved and verified off-chain without handcrafting complex "circuits" or AIR. Cairo is already live on the mainnet, and developers can also use it.
In a few weeks, we will launch an alpha version of the Cairo General Proof Service (GPS) on the public Ethereum testnet. This will allow developers to build their own applications using Cairo, implementing whatever business logic they want. They can send their Cairo codes to GPS for verification and then on-chain.
GPS implements a single proof to confirm the execution integrity of completely separate and independent applications, enabling these applications to amortize the gas cost of proof verification.
Cairo and GPS are the foundations of StarkNet - our decision to externalize developers gives them early access to the technology, not only allowing them to start building on it, but potentially influencing the development of StarkNet.
We will continue to develop Cairo based on the needs and feedback of the developer community. We will enhance the language with new features, syntax, and built-in plugins to increase its usability, and continue to develop and improve Cairo tools: compiler, tracer/debugger, and integration with common IDEs.
StarkNet will have Cairo running in the background.
STARK software stack
StarkEx
We have developed the most powerful proof system in the ecosystem and it has been running on mainnet for several months. We have also developed an open-source proof program, ethSTARK, which is 20 times faster than other proof programs; it provides both zero-knowledge signatures and post-quantum secure signatures.
Our scaling criteria include processing 300,000 transactions in a single proof on mainnet, achieving a world record in aggregate throughput: 300,000 tps. In the process, we've achieved a world record for aggregated gas efficiency: 315 gas/tx, orders of magnitude cheaper than Ethereum L1 transactions.
This technology will be the cornerstone of StarkNet's decentralized proof-of-concept layer, so we will be publishing more and enhanced proofs as part of StarkNet's development (see an upcoming blog post for more information).
StarkEx is our L2 scaling engine. It has been providing mainnet services to DeversiFi’s customers since June 2020. It will power dYdX and ImmutableX in the coming weeks. StarkEx can handle complex trading logic (spot trading, derivatives, NFT) as well as payment.
Developing StarkEx is our way of extending the toolchain and testing it against real needs. Real applications and real user needs help tools mature and evolve best. It also helps us understand elements that need to be addressed to better serve the ecosystem, such as integration with wallets and block explorers.
StarkEx is a live example of scaling application functionality using STARK-based ZK-Rollup, and is Cairo's first production application written on mainnet. Therefore, it will also be one of the applications running on StarkNet.
Future development route
Step I - Planets: Single Application Summary
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 one application. Different instances can run different applications.
The StarkNet framework will include the following:
A mechanism to generate STARK proofs for arbitrary Cairo logic, then submit and verify on Ethereum.
Interaction with L1 Ethereum: Deposit, withdrawal of L1 tokens, release of on-chain data, escape mechanism to protect StarkNet users from malicious StarkNet operators, etc.
Management of L2 user balances and application storage and memory.
Developers will be able to fully focus on building the business logic of the application before going into production: deploying and running it at scale on StarkNet.
What enables us to build a general scalable ZK-Rollup is:
Cairo, a general-purpose, Turing-complete programming language
Our powerful STARK stack (prover and verifier) that bundles a lot of computation into a single proof
Step II - Constellation: Multi-Application Summary
The next step will be to support multiple applications running on the same StarkNet instance and accessing the same global L2 state. This will enable interoperability between different applications and reduce gas costs due to improved economies of scale.
Cairo, the powerful STARK stack, and GPS enhance StarkNet's competitive edge in supporting multi-application aggregation.
At this stage, StarkNet will be a fully functional framework for running multiple applications with arbitrary business logic on top of Ethereum, each instance run by an operator.
Step III - Cosmos: Decentralized Aggregation
epilogue
The final step in the evolution of StarkNet is to achieve decentralized operations.
Significant R&D issues that we are addressing now that impact this phase include (i) improving the mechanism for reaching consensus using ZK-Rollups, and (ii) designing cryptoeconomic mechanisms to incentivize decentralized StarkNet contributors and operators (transaction sequencer, prover, etc.) to run efficiently, fairly, and safely.
