In-depth analysis of StarkWare: Want to build a ZK "universe"?
Original compilation: ChinaDeFi
Original compilation: ChinaDeFi
StarkWare is a ZK company focused on building ZK-based rollup solutions for Ethereum at scale. Their first product, StarkEx, was launched in 2020, and in November 2021, StarkNet with more features was released.
technology
technology
StarkWare built a new technology that compresses thousands of transactions into a single proof of validity called STARK and submits it to Ethereum L1. Compared with SNARK, STARK has two main advantages:
It does not require an initial trust setup.
Has faster computation time than SNARK. It could improve Ethereum’s scalability by orders of magnitude since less computation is required.
Architecture
The StarkWare stack mainly consists of shared provers (SHARP) and verifiers (present on L1). SHARP bundles multiple transactions from different dapps and generates a proof. It then shares proofs with validators on L1. This saves costs because computation is shared between different applications. The verifier checks that the SHARP proof is valid. If valid, they will be shared in the Fact Registry. The application can interface with StarkEx or directly with SHARP (StarkNet application).
StarkNet's L2 nodes (sequencers) will execute every transaction and periodically update the state to the Ethereum mainnet. It should be noted that StarkNet's transaction finality is tied to L1, which means that L2 nodes must verify both StarkNet and Ethereum. StarkNet introduced a solution involving checkpointing of the Ethereum mainnet, enabling it to achieve efficient finality on the rollup side very quickly. Therefore, all L2 nodes contain an L1 full node.
data availability
data availability
StarkNet uses the Validium mechanism to achieve data availability. It is almost the same as ZK-rollup, except that it keeps data off-chain, while ZK-rollup and Optimistic Rollup (OR) keeps data on-chain. Validium only issues proofs of validity on L1 while keeping the data off-chain. This enables Validium to achieve reasonably high throughput and reduce the cost per transaction.
The cost of storing data off-chain is that it requires trust in a third party, which can prevent users from accessing their balances. StarkWare aims to solve this problem through the Data Availability Committee (DAC), which is composed of 8 independent members who have a copy of the transaction. They also need to maintain this data by making it available at all times. If the operator blocks users from accessing their funds, committee members will confirm whether their request is valid.
StarkWare also plans to implement a Volition mechanism where users can choose whether to send data on-chain or not. It shifts the decision of data availability from the application level to the user level, even for individual transactions. If a user wants to send a high-value NFT with all the data on-chain, they can pay an additional cost to transfer it on-chain. This will be achieved with ImmutableX and Sorare.
Cairo programming language
New technologies bring new requirements. Cairo is a Turing-complete programming language built specifically for STARK. It's better in terms of performance and scalability, but it's very new. Many developers are unfamiliar with it, making it difficult to migrate existing applications to StarkNet. Warp, developed by Nethermind, is the EVM for the Cairo transpiler. Warp allows seamless conversion of Solidity contracts to Cairo.
A breakthrough of the Cairo language is that it allows only one verifier to use one proof to confirm the integrity of many different program executions.
StarkNet Vs OR
Not only does StarkNet have a faster withdrawal window compared to OR's 7-day wait time, but the underlying architecture is also different. StarkNet uses "stateless", you only need to store the state root of the entire state on L1, and users need to provide Merkle proofs to access specific state items. OR follows a "stateful" solution where each state item is recorded on-chain. This will lead to greater state bloat and may prove not to scale well when adopted in the future.
ecosystem
ecosystem
The StarkWare ecosystem is growing. With permissionless deployments on StarkNet, many developers have expressed interest. StarkEx's open ecosystem and rich documentation make it easy for developers to implement it. DeFi Pooling is possible on StarkNet. It allows users to exist on L2, while DeFI is still on L1 where it was born, and many exciting things are being built. Many games and NFT game items have appeared on StarkNet.
in conclusion
in conclusion
Original link
