Analyzing StarkWare's Architecture and Ecosystem: An $8 Billion Valuation with Scalability Potential

Author: echo_z, Chain Teahouse

In the scaling roadmap of Ethereum, ZK Rollup has always been highly anticipated. Because ZK Rollup can generate extremely concise proofs, it further compresses on-chain storage requirements compared to Optimistic Rollup, thus freeing up more on-chain space (L2 background knowledge portal: “How Ethereum Will Change: Understanding the Merge, Scaling, and the L2 Battle”).

According to Vitalik's estimation, ZK Rollup can theoretically increase the mainnet TPS by ~100 times, which is far superior to the ~20 times increase achievable by sharding solutions.

Source: https://vitalik.ca/general/2021/01/05/rollup.html

There are two leading projects in the ZK Rollup space: StarkWare and ZKSync. Both have strong technical capabilities and numerous ecosystem projects on their testnets, but they each adopt different ZK Rollup technologies, leading to varying product capabilities and progress.

Among them, StarkWare has a more impressive capital background: it recently completed a $100 million Series D funding round at an $8 billion valuation, ranking first among the four mainstream Rollup projects.

Overview of mainstream L2 projects, created by Chain Teahouse

Why is StarkWare so favored by capital, and what scaling effects can its technology achieve? Chain Teahouse will attempt to analyze StarkWare's architecture and ecosystem in this article to understand its future prospects.

1. Product System

StarkWare's product system is divided into two parts.

The first is StarkEx as a ToB service, which provides dedicated Rollup technology services for each application. It has been officially launched on the Ethereum mainnet since 2020 and is relatively mature.

The second is StarkNet as a general-purpose L2, which can deploy any smart contract, unlike StarkEx, which requires custom development for specific applications. StarkNet was launched on the testnet last June and on the Ethereum mainnet last November, but ecosystem projects are still running on the testnet.

The underlying technology used by both is interconnected. StarkEx essentially uses ZK Rollup technology in a centralized manner through a single app, while StarkNet takes on the decentralized task of establishing a node network.

The following will first introduce the infrastructure adopted by StarkWare and the execution differences under the two product systems; secondly, it will introduce interesting innovations by StarkWare beyond ZK Rollup.

1.1 General Workflow

The following diagram illustrates the workflow of StarkEx, which is similar to StarkNet. We will use this as an overview to outline the technical points of StarkWare.

Source: https://docs.starkware.co/starkex-v4/overview

1）Applications: Users send transaction requests to the app, which forwards the transaction requests to the StarkEx Service module. The "Executing" in the diagram is somewhat uncertain; it may refer to some front-end processing or pre-processing.

2）StarkEx Service: This module verifies the validity of the transaction, such as confirming whether the user identity and assets match, whether the user account has sufficient balance, and whether the transaction has been executed previously. After confirmation, it will package a sufficient number of valid transactions and run the Cairo program to execute these transactions.

It is worth noting the "Cairo" programming language, which is StarkWare's solution to the common challenges faced by ZK Rollup: In most existing proof systems, the computation results must first be transformed into a polynomial equation over a specific domain, and the difficulty lies in how to unify the myriad execution results of smart contracts into a verifiable polynomial equation[1].

A significant contribution of StarkWare is that through the Turing-complete language Cairo, all smart contract computation results are transformed into provable polynomial equations, thus allowing compatibility between smart contracts and Validity Proof.

In this regard, ZKSync has also achieved this with an original solution, but StarkWare and ZKSync have made different trade-offs. The proof system adopted by StarkWare is STARK, which is a proof system created by the StarkWare team, with the advantage of being able to prove more transactions in a unit space and being more secure[2]; while ZKSync uses the SNARK system, which is a relatively mature proof system, with the advantage of being easier to achieve EVM compatibility. ZKSync 2.0 has indeed achieved EVM compatibility.

StarkWare's native Cairo language is very friendly to the STARK proof system, and it can be said to be a language created for the application of the STARK proof system. However, the accompanying issue is that it has a high learning cost for developers, making it difficult to directly migrate from the existing Ethereum ecosystem. To address this, StarkWare is collaborating with the third-party team Nethermind to develop a compiler Warp that translates Solidity to Cairo[3].

3）SHARP: After the Cairo program execution is completed, the results will be sent to SHARP, which stands for "Shared Prover." This is also a program developed by StarkWare, based on the STARK proof system, which generates a proof from the execution results of the Cairo program and sends it to L1, where L1 miner nodes call the verification contract for validation.

4）STARK Verifier and 5）StarkEx Contract are both smart contracts deployed on L1. The former is responsible for verifying the proof submitted by SHARP, while the latter is responsible for storing updated transaction states and other necessary information. Only when the L1 miner nodes run the Verifier and the verification passes will the state updates submitted in the StarkEx Service module be accepted by L1, updating the transaction state stored in the StarkEx Contract, thus completing the transaction.

In summary, the core modules are in StarkEx Service and SHARP. StarkEx Service verifies the validity of transactions, packages them, calls the Cairo program for execution, and then submits the proof generated by SHARP to the L1 smart contract for verification by L1 nodes.

The Cairo program and SHARP proof system constitute StarkWare's core technology, with the entire technology based on StarkWare's self-created STARK proof system, which has the characteristics of generating large proofs that are also more secure. However, to adapt to STARK, the Cairo language is not inherently EVM compatible, resulting in a high learning cost for developers.

So, which roles execute the various steps in the workflow mentioned above? Sections 1.2 and 1.3 will elaborate on this.

1.2 StarkEx Architecture and Data Availability

In StarkEx, all off-chain work, including transaction packaging, calling the Cairo program, and generating proofs, is completed by each application itself, representing a completely centralized operation. Additionally, since StarkEx is a customized ToB service, it has dedicated ZK circuits for each application, enhancing operational performance, allowing projects using the StarkEx engine to achieve very high TPS.

StarkEx also provides two modes of data availability: ZK Rollup and Validium, for each application to choose from.

Data availability is crucial in the blockchain context, referring to whether on-chain nodes can access all relevant data for each transaction execution (such as transaction instructions). If only the transaction results can be accessed without the execution process data, then the validity of the transaction cannot be verified on-chain. If any single transaction's data validity is in question, then the entire transaction history on the chain is at risk. A key point that various Layer 2 solutions grapple with is how much data to store on-chain, which also leads to different levels of security.

The following diagram shows the four mainstream L2 models, corresponding proof systems, and data availability schemes. It can be seen that both ZK Rollup and Validium use validity proofs, with the distinction being whether complete data is stored on-chain or off-chain.

Source: https://twitter.com/vitalikbuterin/status/1267455602764251138

In the Validium mode, only the updated state is sent to L1, and L1 nodes cannot reconstruct the complete transaction history from on-chain data. In this mode, the complete execution data of the transaction is first sent by SHARP to an off-chain "Data Availability Committee," which is a centralized committee composed of ConsenSys, Infura, Nethermind, Cephalopod, Iqlusion, and StarkWare, responsible for receiving and verifying off-chain data, and then sending signatures to L1. L1 nodes confirm the on-chain state updates by verifying the signatures[4]. The Validium mode sacrifices security for more efficient storage space, and users must trust this committee.

In the ZK Rollup mode, in addition to the new state, the differences before and after the state change are also sent on-chain, allowing L1 nodes to reconstruct the complete transaction history, achieving the highest level of security for Rollup.

Among the four projects currently using StarkEx, only dydx has adopted the data availability mode of ZK Rollup, while the other three projects use Validium mode.

Source: https://l2beat.com/

1.3 StarkNet Architecture and Maturity

The main architectural change of StarkNet compared to StarkEx is that off-chain work has been transferred from applications to miners.

Off-chain work consists of two parts: one is the verification of transaction validity, transaction packaging, and calling the Cairo program for execution, which is performed by the Sequencer in StarkNet; the other is the proof generation work performed by SHARP, which has an independent Prover in StarkNet.

Sequencer + Prover is equivalent to miners in the ETH network, completing the process of selecting transactions from the transaction pool, executing transactions, and generating proofs, thereby generating blocks on StarkNet. As for whether the roles of Sequencer and Prover will be combined or separated, the official team has not provided a solution yet. There is a complex issue here: the time required for the Prover to generate a proof is significantly longer than the time required for the Sequencer to produce a block, leading to a time gap of several hours between block generation and proof generation. How to utilize division of labor to address this time gap will be a considerable challenge[5].

Source: https://www.youtube.com/watch?v=wFZ_YIetK1o

As a general-purpose L2, StarkNet's application scenarios are certainly broader than those of StarkEx, but in terms of the product itself, its maturity is still not high enough.

Firstly, StarkNet's performance is not good enough. This is because StarkNet needs to create ZK general circuits, while StarkEx develops circuits tailored for each application, making the complexity of issues handled by StarkNet far higher than that of StarkEx.

The official team has not disclosed StarkNet's TPS data, but from the block explorer, it can be seen that whether on the mainnet (left) or the testnet (right), it can only achieve about 300~400 transactions per hour or 15 transactions per minute, with a TPS of only 0.1~0.25. Of course, this number may also be due to a low user count, but the overall TPS is likely to be low.

Source: https://voyager.online/; https://goerli.voyager.online/

Secondly, StarkNet has not yet achieved decentralization. Currently, both the Sequencer and Prover are operated by the StarkWare official team, and decentralized miner nodes have not been established. However, in this regard, both Optimistic and Arbitrum are also operated by centralized Sequencer nodes, which is a common issue faced by L2.

The official team released a blog in February, stating that StarkNet has currently achieved usability, and the next goals are to improve performance and achieve decentralization. In terms of performance, they aim to achieve a TPS that is an order of magnitude higher than ETH in the second half of 2022[6].

1.4 Future Vision

In addition to the scaling solution based on the STARK proof system, StarkWare has also envisioned many other innovations, such as cross-L2 joint LP pools: users can swap tokens in multiple L2 LP pools to enhance liquidity. However, this comes at the cost of increasing the risk of impermanent loss, which may not be an ideal solution[7].

However, StarkWare has a design vision that presents a grand future: achieving fractal layering (Fractal Layering) through L3 (or Ln). Simply put, this means constructing ZK Rollups in layers using fractal design on StarkNet, effectively doubling performance. Moreover, according to the official Medium, StarkEx will also migrate to StarkNet in the future, serving as an L3 layer for other protocols.

Source: https://medium.com/starkware/dydx-now-on-mainnet-c21c84d8e342

If the fractal layering design of Ln can indeed be realized, then the TPS increase will be calculated at least by hundreds of times, and Ethereum may no longer need Sharding. Of course, this vision will undoubtedly face many challenges, such as whether the proof generation delay in L2 will be exacerbated by layering, how to handle it, and how to ensure the security of each layer, etc. The realization of fractal layering is likely still a long way off.

2. Ecosystem Operations

On the ToB service side, StarkEx provides relatively mature services, currently with a TVL of ~1 billion USD, of which dYdX accounts for over 95%.

Source: https://starkware.co/starkex/; https://l2beat.com/

On the ToC service L2 side, there is currently no TVL data, but it can be seen that StarkWare has strong ecosystem appeal. The official team has collected over 60 projects that are currently being built, mainly in DeFi, Games, and NFTs.

Source: https://starkware.notion.site/Projects-Building-on-StarkNet-a33dee55778a4515a9be9bdae02ee682

It is noteworthy that two well-known projects, AAVE and Maker, will also be deployed on StarkNet. Two weeks ago, Maker launched the transfer of DAI between the mainnet and StarkNet, and AAVE recently announced in the community that it expects to complete the first phase of deployment on StarkNet with aTokens in June[8].

In addition to mature DeFi projects, a relatively well-known new project is Jediswap, which claims to enable zero-fee trading and has around ~10k followers on Twitter.

The team also seems to place significant emphasis on game development, with the core logic being that StarkNet can handle a large amount of computation, which is very beneficial for developing high-quality games[9]. Currently, relatively complex games like @LootRealms and @TheDopeWars are preparing to launch, and there are also simpler games already available, such as @briqNFT, a project where users can freely draw pixel images and generate NFTs.

Additionally, the ecosystem includes the native StarkNet wallet Argent X and the development tool Warp that compiles Solidity into Cairo language.

3. Team and Financing

StarkWare is a team from Israel with a strong academic and technical background, primarily composed of engineers, with a total of four partners.

Co-founder and Chairman Eli Ben-Sasson obtained his Ph.D. in theoretical computer science from the Hebrew University in 2001, specializing in cryptography and zero-knowledge proofs. He is one of the inventors of the STARK proof system and has participated in establishing several crypto projects, including Zcash. Before co-founding StarkWare, Eli served as a full professor of computer science at the Technion in Israel.

Co-founder and CEO Uri Kolodny obtained a bachelor's degree in computer science from the Hebrew University and an MBA from MIT Sloan. Uri is a serial entrepreneur who has co-founded several tech companies, including the medical device company OmniGuide and the big data visualization development tool Mondria. Previously, Uri worked as an EIR (Entrepreneur in Residence) at two Israeli VCs and was also a McKinsey analyst.

Co-founder and Chief Architect Dr. Michael Riabzev is a Ph.D. student of Eli Ben-Sasson and is also a co-inventor of the ZK-STARK protocol.

The last co-founder and Chief Scientist Alessandro Chiesa co-founded Zcash with Eli Ben-Sasson and teaches at UC Berkeley's computer science department.

StarkWare also has very strong capital support. Just last May, StarkWare announced that it had raised $100 million in a Series D funding round at an $8 billion valuation. So far, StarkWare has raised a total of $273 million, with investors including Coatue, Greenoaks Capital, Sequoia, Paradigm, 3Arrows, Alameda Research, and the Ethereum Foundation, receiving not only support from the Ethereum community but also significant capital interest.

4. Advantages and Challenges

StarkWare has very clear advantages:

1）The founding team inherits from Zcash, possessing both a strong academic and technical background and successful entrepreneurial experience in the crypto field, making it a rare star team;

2）Great scaling potential, with the STARK-based proof system maximizing on-chain information compression, surpassing ZKSync and OP competitors in this regard, and the core technology is self-developed, demonstrating strong control over technology;

3）An excellent reputation also benefits ecosystem construction, having already attracted mature projects like AAVE and Maker for deployment, indicating strong appeal to developers.

The main challenges faced by StarkWare include:

1）Lack of EVM compatibility, resulting in a higher threshold for developers, which is a key difference compared to ZKSync. In this regard, the third-party team Nethermind is developing the Warp compiler to translate Solidity to Cairo, which will be a critical variable for the speed of ecosystem development;

2）Currently, the Sequencer on StarkNet is still operated centrally by the team. How to ensure security while achieving decentralization will also be a challenge. This issue is similarly faced by relatively mature L2 projects like Arbitrum and Optimism, where both currently operate their Sequencers in a centralized manner. For StarkNet, in addition to the Sequencer role responsible for selecting transactions and producing blocks, there is also the Prover role responsible for generating proofs, and the latter will have delays compared to the former, making this issue more complex.

StarkWare has achieved a high valuation of $8 billion without issuing a token, while Optimism currently has an FDV of ~ $2.5 billion. In a bear market, there is a possibility that StarkWare's token price may experience a premium. This may lead StarkWare to be more cautious about issuing a token, as the team does not lack funds, and for users, the transaction fees of ZK Rollup are inherently low, making financial issues less prominent than those of OP systems. Of course, for retail investors in the secondary market, this may create a good entry opportunity.