Written by: @Yinan_cycle
(This article was first published on PANews: StarkWare Empire: An Analysis of the Innovation Journey of StarkEx and StarkNet)
background
Starting in 2018, StarkWare pioneered the use of STARK validity proof to solve the scalability problem of Ethereum. It launched StarkEx based on a SaaS business model, created the Cairo programming language, and built Starknet, the first decentralized network in production that allows writing custom logic.
StarkWare is committed to having a dual focus on technology, mathematics, innovation and product delivery; supporting other teams advancing Ethereum and/or STARK; and striving to make the product open source, decentralized and focused on making STARK a public good.
In the future, StarkWare will work on making Starknet a permissionless decentralized validity rollup governed by the Starknet Foundation, and focus on the various components of decentralizing Starknet, such as Prover, Sequencer, and governance.
STARK technology is based on proofs, specifically integrity proofs. STARK uses mathematics to ensure integrity, ensuring calculations are done correctly even when no one is watching. The concept of this technique began with a 1991 article by László Babai, Lance Fortnow, Leonid Levin, and Mario Szegedy, which introduced the concept of using a single reliable computer to monitor a group of unreliable supercomputers. The technology, called "PCP," uses mathematics to monitor and ensure the integrity of large calculations.
STARK technology is an improved version of PCP technology that allows small users to check and ensure the correct functioning of large corporations, monopolies or governments. Blockchain restores the peer-to-peer nature of currency exchange, eliminating the need for trusted intermediaries. Ethereum takes this concept even further, allowing the creation of universal programs that form the basis of a social economy.
Starkware
StarkWare is one of the best companies in the zk rollups track. It was co-founded by Professor Eli Ben-Sasson of the Israel Institute of Technology (co-inventor of zk SNARK & zk STARK). It provides solutions based on STARK technology for the blockchain industry . Two products are currently developed: StarkEx & StarkNet, both of which are introduced below.
Starkware Team
Eli Ben-Sasson: Co-Founder & Chief Scientist, Professor of Computer Science at the Technion-Israel Institute of Technology. Founding scientist of Zcash and inventor of zkSNARKs.
Alessandro Chiesa: Co-Founder & Chief Scientist, Professor of Computer Science at the University of California, Berkeley. Founding scientist of Zcash, co-inventor of zk-SNARKs, and core developer of libsnark.
Uri Kolodny: Co-Founder & CEO, Uri is a serial entrepreneur with rich business experience and good at cooperation.
Michael Riabzev: Co-Founder & Chief Architect. PhD from the Israel Institute of Technology, worked at Intel and IBM.
Oren Katz: Vice President of Engineering. Graduated from Hebrew University in Computer Science, Tel Aviv MBA, and is a senior engineer with 20 years of experience.
Financing
The company is currently valued at US$8 billion and has received full support from capital such as Vitalik, Paradigm, and Sequioa. It is the team with the highest valuation in the field of expansion.
StarkEx
An application-specific Layer-2 scaling engine based on the Ethereum blockchain, designed to solve the scalability issues of Layer-1 blockchain networks such as Ethereum. StarkEx enables fast, low-cost transactions without compromising security, privacy and self-custody by using an advanced cryptography system called STARK proofs.
It provides a series of application processes for implementing cheap off-chain calculations, packaging multiple transactions in a STARK proof, and then verifying them on the chain, reducing the average gas cost of each transaction. The working principle of the StarkEx expansion engine includes four steps: batch processing, verification and update, generation of proof, and on-chain verification.
StarkEx has been successfully deployed in multiple applications such as dYdX, Immutable, Sorare, DeversiFi and Celer.
The difference from StarkNet is:
StarkEx and StarkNet are two different technologies developed by StarkWare. They both use STARK zero-knowledge proof technology, but have different goals and uses.
StarkEx: StarkEx is an application-specific Layer-2 scaling engine focused on optimizing the performance of a single application on the Ethereum blockchain. It enables faster, lower-cost transactions by batching multiple transactions and verifying them off-chain. Mainly used in decentralized exchanges (DEX), NFT markets and games, etc. By using STARK proof technology, StarkEx provides a secure, efficient and low-cost trading experience.
StarkNet is a permissionless, more general, complete Layer-2 solution that provides the entire Ethereum ecosystem with a decentralized computing platform where developers can deploy smart contracts written in the Cairo language. StarkNet supports interaction with other contracts, allows for a rich combination of protocols, and can interact with Ethereum contracts through asynchronous messaging. The goal is to provide a scalable, low-cost, and secure environment on which developers can build and deploy smart contracts. Unlike StarkEx, StarkNet can be viewed as a comprehensive Layer-2 operating system that allows developers to create a variety of decentralized applications, not just solutions for specific purposes.
In short, StarkEx is an application-specific Layer-2 extension engine that focuses on performance optimization of specific applications, while StarkNet is a more general and comprehensive Layer-2 solution that aims to provide a decentralized solution for the entire Ethereum ecosystem. Centralized computing platform.
Starknet
Starknet is a permissionless, decentralized validity rollup network (also known as "ZK-Rollup"). It operates as an L2 network on Ethereum, enabling any dApp to achieve infinitely scalable computing without compromising Ethereum composability and security, thanks to Starknet relying on the most secure and scalable Cryptoproof proof system STARK.
Starknet contracts and the Starknet operating system are written in Cairo - enabling deployment and scaling of any use case, regardless of business logic. Starknet is a decentralized layer 2 network solution designed to provide higher scalability and performance for decentralized applications (dApps). By running on Ethereum, it leverages existing infrastructure and security while providing increased computing power.
Cairo is a programming language designed specifically for Starknet to simplify the development and deployment of smart contracts. By using Cairo, developers can easily build highly scalable applications for a variety of use cases, including finance, gaming, supply chain, and more.
Starknet is a validity rollup, which means that execution within each block needs to be proven, which is where STARKs come in handy. However, STARK proofs can solve statements formulated in a polynomial constraint language and have no knowledge of smart contract execution. To overcome this gap, Cairo was developed.
Overall, Starknet is a layer 2 network solution full of potential that can give existing dApps a major step forward in scalability and performance. By adopting the STARK cryptographic proof system and the Cairo programming language, Starknet provides developers with a powerful and flexible platform to meet various business needs.
new version update
What happens next? Starknet Alpha v0.11.0: Transition to Cairo 1.0 begins
Further language improvements to Cairo 1.0
Performance Improvements: As promised, Starknet continues to make progress towards significantly improving TPS. The next step in the roadmap is the transition to Rust sequencers, which are publicly developed under the Apache 2.0 license. The new sequencer will use Rust CairoVM and Papyrus full nodes to form the Performance Trio.
Off-chain DA
In this version, Starknet handles the calculation part of transaction costs. In an upcoming version, on-chain data costs will be addressed, which is the main cost of the average transaction today.
Here is a further explanation of Starknet’s sequencer:
Sequencer refers to the StarkNet Sequencer, which is part of StarkNet and aims to significantly increase throughput (number of transactions per second) by switching to a Rust sequencer, using Rust CairoVM and Papyrus full nodes, thus forming a "performance trio" ".
The "performance trio" refers to the three components of the StarkNet Sequencer: the Rust sequencer, Rust CairoVM, and the Papyrus full node. Among them, the Rust sequencer is the core of StarkNet Sequencer, which is responsible for processing transactions and generating blocks. Rust CairoVM is a virtual machine that can run smart contracts on StarkNet. The Papyrus full node is a node in the StarkNet network that stores all data on StarkNet and can process transactions. These three parts work together to significantly increase StarkNet's throughput (number of transactions per second).
Starknet v0.11.0 (currently only on Goerli testnet)
Once the Goerli testing period ends, Starknet v0.11.0 will be released on the mainnet.
Starknet v0.10.3 (22-12-12)
Performance - Separate state commitment calculations from transaction execution
Added starknet-class-hash command to calculate class hash of compiled Starknet contracts
Starknet v0.10.2 (11/29/22)
This version introduces sequencer parallelization!
A new endpoint estimate_fee_bulk is added to the feeder gateway. This will allow estimating fees for several transactions simultaneously, where each transaction is executed relative to the resulting state of the previous transaction applied.
Starknet v0.10.1 (10/25/22)
Add the DeployAccount transaction (it will replace the Deploy transaction to deploy the account contract). To use it, you should first add enough funds to your account address to cover the transaction fees, then you can call DeployAccount
Split the starknet deploy_accountCLI command into starknet new_account and starknet deploy_account
It is expected that account contracts deployed in this manner should implement the validate_deployDeployAccount() entry point, which should check the signature of the transaction
Improved L1 fee calculation: calculate fees based on differences in storage status
API: entry_point_type removes fields from transaction information
Starknet v0.10.0 (05-09-22)
This release introduces the next steps in the design of Starknet account abstractions, specifically the verification/execution separation.
Starknet v0.9.1 (07/20/22)
API changes
StarNet CLI
Starknet v0.9.0 (Jun 6, 22)
This release brings the contract class/instance paradigm to Starknet
About account
Ethereum account structure
In Ethereum, individual user accounts are called Externally Owned Accounts (EOAs).
EOAs differ from smart contracts in that they are not controlled by code. EOA is determined by a pair of private and public keys.
The account's address is derived from these keys, and transactions can only be initiated from the account if one has the private key. While Ethereum contracts are “passive”, meaning they can only change when called in a transaction, EOAs can initiate transactions.
Despite their simplicity, EOAs have a major drawback, which is that there is no flexibility in account behavior. The Ethereum protocol dictates when transactions initiated by EOAs are valid (the signature scheme is fixed). In particular, control of the public key gives complete control over the account. While in theory this is a secure method of account management, in practice it has some disadvantages, such as requiring you to keep your seed phrase secure while making it accessible to you, and having limited flexibility with wallet features .
EIP-4337 is a design proposal for Ethereum that outlines an account abstraction to manage all accounts through dedicated smart contracts on the Ethereum network to increase flexibility and usability. You can add account abstraction to Ethereum by adding custom logic on top of basic EOA functionality.
What is account abstraction?
The idea behind account abstraction is to allow more flexibility in account management, rather than having their behavior determined at the protocol level. This can be achieved by introducing account contracts - smart contracts with programmable logic that determine the user's account behavior.
By using account abstraction, you can now program your account functionality.
For example, you can:
Determine what a valid signature means, or which contracts your account is allowed to interact with. This is called "signature abstraction"
Pay transaction fees in different tokens - this is sometimes called "fee abstraction"
Design your own replay protection mechanism and allow multiple unrelated transactions to be sent in parallel. Compare this to the sequential nonce solution used in Ethereum, which results in transactions being sequential in nature, even if you want to send two transactions in parallel, you have to wait for some confirmations of the first transaction before sending the second Two transactions. Otherwise, the second transaction may be rejected due to an invalid nonce. Using account abstraction, different solutions can be discussed to bypass the sequential nonce requirement. This is called "nonce abstraction".
Today, Starknet provides signature abstraction. In the future, Starknet will enrich the current account abstraction design.
Two examples of custom account functionality using account abstraction
Social Recovery This is a process that allows you to retrieve your wallet via a social network of your choice when you lose it, greatly improving the typical wallet recovery experience.
Operate your account with facial recognition With signature abstraction, you can sign transactions using your phone's native hardware, making it virtually impossible to take over another user's account (even in the event the phone itself is stolen).
These examples demonstrate how account abstraction can be leveraged to provide users with a more flexible, secure, and highly customized wallet and account management experience. By writing custom logic, users can tailor account functionality to their needs and preferences, improving security while also improving ease of use.
The Starknet account contract must include the following two functions
validate
execute
These functions serve different purposes to ensure that only the account owner can initiate transactions and that you can be charged for the resources you use.
Starknet's account types are inspired by Ethereum EIP-4337, where instead of EOA (Externally Owned Account) you now use smart contract accounts with arbitrary verification logic.
By using smart contracts, complete flexibility is gained in account implementation.
Although not mandatory at the protocol level, the community developed a richer standard account interface. This standard was developed by OpenZeppelin, working closely with the wallet team and other core Starknet developers.
Token Economics:
The role of tokens:
transaction fee:
Currently, fees in StarkNet are paid in Ethereum (ETH). But later on, we expect fees to be paid entirely using native StarkNet tokens. To support a good user experience, automated and decentralized on-chain mechanisms will allow users to pay fees in ETH.
Pledge:
Certain services critical to the liveness and security of StarkNet may require staking of StarkNet tokens. These services may include ordering, reaching interim L2 consensus before reaching L1 final results, STARK attestation services, and data availability provisioning.
Governance:
Proposals to improve StarkNet will require a minimum token support threshold to be defined later. All changes to the protocol that are critical to the liveness, security, and maintenance of StarkNet require voting, either directly or through delegation. For example, all major updates to the StarkNet operating system require token holder approval.
Total amount: 10 billion, initial distribution of tokens: Token Economics
17% — StarkWare investors
32.9% — Core Contributors: StarkWare and its employees and consultants, and StarkNet software development partners
StarkWare grants 50.1% to the Foundation for the following purposes:
9% - Community Supply: Used to reward people who work on StarkNet and provide support for its underlying technology, such as those who have used the StarkEx L2 system in the past. Importantly, all community replenishment will be based on verifiable work that has been completed in the past. For example, for past StarkEx users, allocations will be determined based on verifiable usage of StarkEx technology that occurred before June 1, 2022.
9%—Community Rebate: Partially used to cover the cost of moving from Ethereum to StarkNet. To prevent gamification, community rebates only apply to transactions that occurred after the rebate mechanism was announced.
12% — Funding for research and development, testing, deployment, and maintenance of the StarkNet protocol.
10% - strategic reserve to fund ecosystem activities consistent with the foundation's mission.
2% — donated to highly respected institutions and organizations such as universities, NGOs, etc., decided jointly by StarkNet token holders and the Foundation.
8.1%—Unallocated: The Foundation’s unallocated financial reserves will be used to further support the StarkNet community, with specific support methods determined by the community.
In order to align the long-term incentives of core contributors and investors with the interests of the StarkNet community and follow the practices of the decentralized ecosystem, all tokens allocated to core contributors and investors will be subject to a 4-year lock-up period, with Linear release and one year cliff.
If you are an end user, use StarkNet only if it meets your current needs. Use it for transactions and applications you value rather than expecting future returns of StarkNet tokens. When community supplies are announced, they will only relate to snapshots that occurred prior to the announcement date, filtering and excluding usage considered abusive and manipulative of the network based on information available at the time. When community rebate systems are established, they will never apply to transactions that occurred before the rebate was announced, so trading today in the expectation of future rebates is futile.
Based on the summary analysis of token economics above:
The first 9% of the community supply part may be airdropped to users, which means that users will be divided among the 450 million together with those who work for Starknet and provide technical support and development.
The second 9% community rebate is used to subsidize the handling fees after the subsequent rebate rules are announced. It is useless to pay the handling fees before the rules are announced.
The third 10% strategic reserve is used for ecological applications on the chain and is allocated to ecological application protocols.
business model
StarkEx sells customized technology engine services and charges service fees directly from customers with expansion needs. It is essentially a customized 2B service.
Create a decentralized Layer 2 network StarkNet that supports independent deployment of dApps. It can charge users Layer 2 transaction fees, and can also obtain the value of MEV through the sequencer's auction mechanism. It can also issue tokens in the future and use technology and funds to incubate StarkNet projects. Drive ecological development through tokenomics.
Summarize
StarkWare is one of the best companies in the zk rollups circuit, with products including StarkEX and StarkNet.
StarkEx is a Layer2 extension engine that provides technical services for dApps.
StarkNet is a more general, complete Layer-2 solution that is permissionless.
There are more than 80 team members, and the core members are quite eye-catching. Eli Ben-Sasson is the founding scientist of Zcash and the inventor of zkSNARKs. He has very deep research and influence in the ZK-Rollup field, and his current valuation reaches 8 billion. Top VCs and individuals such as paradigm, Pantera, polychain and Buterin are all investors of StarkWare.
In terms of ecological applications, because the Cairo language is used, it is not compatible with EVM, so the progress in ecological development will be slower. Currently, it is beginning to transition to Cairo 1.0 and develop towards a higher TPS. Even so, but the current The application experience is not very smooth, and there is still a gap between technology and reality. I hope to see better development of Starknet in the future.