background
background
Starting in 2018, StarkWare pioneered the use of STARK validity proofs to solve the scalability problem of Ethereum. It launched StarkEx based on the 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 a dual focus including 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 STARK as a public product.
In the future, StarkWare will work on making Starknet a permissionless decentralized validity rollup governed by the Starknet Foundation, and focus on decentralizing various components of Starknet, such as Prover, Sequencer, and governance.
STARK technology is based on proofs, specifically integrity proofs. STARK uses mathematics to ensure integrity, ensuring that calculations are done correctly even when no one is watching. The concept for this technique started with a 1991 paper by Lszl 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. Dubbed "PCP," the technique mathematically monitors and ensures the integrity of large computations.
first level title
Starkware:
secondary title
Starkware team
Eli Ben-Sasson: Co-Founder & Chief Scientist, Professor of Computer Science at the Israel Institute of Technology.
Founding scientist of Zcash, inventor of zkSNARKs.
Alessandro Chiesa: Co-Founder & Chief Scientist, Professor of Computer Science at UC Berkeley.
Founding scientist of Zcash, co-inventor of zk-SNARKs, core developer of libsnark.
Kolodny: Co-Founder & CEO, Uri is a serial entrepreneur with rich business experience and good at cooperation.
secondary title
financing
first level title
StarkEx
An application-specific Layer-2 scaling engine based on the Ethereum blockchain, designed to solve the scalability problem 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 cheap off-chain computing, packages multiple transactions in a STARK proof, and then verifies them on the chain, reducing the average gas cost per transaction. The working principle of the StarkEx extension engine includes four steps: batch processing, verification and update, proof generation, and 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, both use STARK zero-knowledge proof technology, but have different goals and uses.
1. StarkEx: StarkEx is an application-specific Layer-2 scaling engine that focuses on optimizing the performance of a single application on the Ethereum blockchain. It enables faster, lower-cost transactions by batching multiple transactions and validating them off-chain. It is mainly used for decentralized exchanges (DEX), NFT markets and games, etc.
2. By using STARK proof technology, StarkEx provides a safe, efficient and low-cost trading experience. StarkNet is a more general and complete Layer-2 solution without permission, which provides a decentralized computing platform for the entire Ethereum ecosystem, where developers can deploy smart contracts written in the Cairo language.
StarkNet supports interaction with other contracts, allows rich protocol composition, 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 seen as a comprehensive Layer-2 operating system that allows developers to create various decentralized applications, not just specific-purpose solutions.
first level title
Starknet
Starknet is a permissionless decentralized validity-folding network (also known as "ZK-Rollup"). It operates as an L2 network on Ethereum, enabling any dApp to infinitely scale computing without compromising Ethereum composability and security, thanks to Starknet's reliance on the most secure and scalable Cryptographic proof system STARK.
Starknet contracts and Starknet OS 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 can leverage existing infrastructure and security while providing higher computing power.
Cairo is a programming language designed specifically for Starknet, which aims 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 the execution within each block needs to be proven, and this is where STARKs come in handy. However, STARK proofs can solve statements formulated in a polynomial constraint language and have no knowledge of the execution of smart contracts. To overcome this gap, Cairo was developed.
first level title
new version update
What's next? Starknet Alpha v 0.11.0: Beginning of the transition to Cairo 1.0
- Further language improvements over Cairo 1.0
- Performance Improvements: As promised, Starknet continues to move towards significantly improving TPS. The next step in the roadmap is the transition to the Rust sequencer, which is openly developed under the Apache 2.0 license. The new sequencer will use Rust CairoVM and Papyrus full nodes to form a Performance Trio.
- Off-chain DA
In this version, Starknet handles the computational part of transaction costs. In an upcoming release, on-chain data costs, which are the primary cost of an average transaction today, will be addressed.
Here is a further description of Starknet's sequencer:
Sequencer refers to StarkNet Sequencer, which is a part of StarkNet that aims to significantly increase throughput (number of transactions per second) by switching to the Rust sequencer, using Rust CairoVM and Papyrus full nodes, thus forming a "performance trio" .
The "performance trio" refers to the three components of StarkNet Sequencer: the Rust sequencer, Rust CairoVM, and Papyrus full nodes. Among them, the Rust sorter 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. Papyrus full node is a node in the StarkNet network, which stores all data on StarkNet and can process transactions. These three parts work together to significantly increase the throughput (transactions per second) of StarkNet.
Starknet v 0.11.0 (currently only on Goerli testnet)
Once the Goerli beta period is over, Starknet v 0.11.0 will be released on mainnet.
Starknet v 0.10.3 (22/12, 12/12)
Performance - separate state commitment calculation from transaction execution Add starknet-class-hash command to calculate class hash for compiled Starknet contracts
Starknet v 0.10.2 (29 Nov 22)
This release introduces sequencer parallelization! A new endpoint estimate_fee_bulk was added to the feeder gateway. This will allow estimating the fees of several transactions at the same time, where each transaction is executed relative to the resulting state of the previous transaction applied.
Starknet v 0.10.1 (25 Oct 22)
Add DeployAccount transaction (it will replace Deploy transaction to deploy account contract). To use it, you should first add enough funds to your account address to cover transaction fees, then you can call DeployAccount Split the starknet deploy_accountCLI command into starknet new_account and starknet deploy_account Account contracts deployed this way should implement validate_deployDeployAccount () entry point, which should check the signature of the transaction Improved L1 fee calculation: Calculate fee based on the difference of stored state API: entry_point_type Remove field from transaction information
Starknet v 0.10.0 (5 Sep 22)
This release introduces the next step in the design of the Starknet account abstraction, specifically the verification/execution separation.
Starknet v 0.9.1 (20 Jul 22)
API changes Starnet CLI
Starknet v 0.9.0 (6.06.22)
first level title
About Account
Ethereum account structure
In Ethereum, individual user accounts are called Externally Owned Accounts (EOAs).
EOAs are different from smart contracts because they are not controlled by code. EOA is determined by a pair of private and public keys.
The address of the account is derived from these keys, and only the possession of the private key can initiate a transaction from the account. While Ethereum contracts are "passive", i.e. they can only change when called in a transaction, EOAs can initiate transactions.
Despite their simplicity, EOAs have a major drawback in that there is no flexibility in account behavior, the Ethereum protocol dictates when a transaction initiated by an EOA is valid (the signature scheme is fixed). In particular, control over 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 drawbacks such as requiring you to keep the seed phrase secure while making it accessible to you, and limited flexibility in wallet functionality .
EIP-4337 is a design proposal for Ethereum that outlines the abstraction of accounts that manage all accounts through dedicated smart contracts on the Ethereum network to improve flexibility and usability. You can add custom logic on top of the basic EOA functionality, bringing account abstraction to Ethereum.
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 the 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" to pay transaction fees in different tokens - this is sometimes called "fee abstraction" to 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 causes transactions to be sequential in nature, and even if you want to send two transactions in parallel, you have to wait for some confirmation of the first transaction before sending the second Two deals. Otherwise, the second transaction may be rejected due to an invalid nonce. Using the account abstraction, different solutions to circumvent the sequential nonce requirement can be discussed. 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 is a process where, when you lose your wallet, it can be retrieved via the social network of your choice, greatly improving the typical experience of wallet recovery. Manipulate your account through facial recognition With signature abstraction, you can use the phone's native hardware to sign transactions, making it virtually impossible to take over another user's account (even if the phone itself is stolen).
These examples show 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 customize account functionality according to their needs and preferences, improving ease of use while increasing security.
The Starknet account contract must include the following two functions
validate
execute
These functions have different purposes to ensure that only the account owner can initiate a transaction and can charge you for resources used.
Starknet's account type is inspired by Ethereum's EIP-4337, where instead of EOAs (externally owned accounts), you now use smart contract accounts with arbitrary verification logic.
By using smart contracts, complete flexibility is gained in account implementation.
first level title
secondary title
The role of tokens
transaction fee:
Currently, fees in StarkNet are paid in Ether (ETH). But at a later date, we expect fees to be paid entirely in native StarkNet tokens. To support a good user experience, an automated and decentralized on-chain mechanism will allow users to pay fees in ETH.
Pledge:
Certain services that are critical to the liveness and security of StarkNet may require StarkNet tokens to be staked. These services may include ordering, interim L2 consensus until L1 finality is reached, STARK proof services, and data availability provisioning.
Governance:
Proposals to improve StarkNet will require a minimum token support threshold, defined later. All changes to the protocol that are critical to the liveness, security, and maintenance of StarkNet require a vote, either directly or via delegation. For example, all major updates to the StarkNet operating system require approval from token holders.
Total amount: 10 billion, initial allocation of tokens: token economics
17% — StarkWare investor
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 Giveaway: Used to reward those who work on StarkNet and support its underlying technology, such as those who used the StarkEx L2 system in the past. Importantly, all community feeds will be based on verifiable work that has been done in the past. For example, for past StarkEx users, allocation will be based on verifiable use 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 are only available for transactions that occur after the rebate mechanism is announced.
12% — Funding for research and development, testing, deployment, and maintenance of the StarkNet protocol.
10% — Strategic reserve to fund ecosystem activities aligned with the Foundation’s mission.
2% — donated to highly respected institutions and organizations such as universities, NGOs, etc., as determined 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, and the specific support method is 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 following the practice of decentralized ecosystems, 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're an end user, use StarkNet only if it meets your current needs. Use it for transactions and applications that matter to you, rather than expecting future rewards in StarkNet tokens. When community feeds are announced, they will only involve snapshots that occurred prior to the date of the announcement, and based on the information available at the time, use that is considered abusive and manipulative of the network is filtered and excluded. When community rebates were established, they would never apply to transactions that occurred before the rebate was announced, so it is futile to expect future rebates to transact today.
Based on the summary analysis of token economics above:
The first 9% of community supply may be airdropped to users, which means that users will be divided among the 450 million people who work for Starknet and provide technical support and development.
The second 9% community rebate is used to subsidize the handling fee after the announcement of the subsequent rebate rules. It is useless to pay the handling fee before the announcement of the rules.
The third 10% strategic reserve is used for ecological applications on the chain and allocated to ecological application protocols.
first level title
Summarize:
StarkWare is one of the best companies in the zk rollups track, and its products include StarkEX and StarkNet.
StarkEx is a Layer 2 extension engine that provides technical services for dApps.
StarkNet is a more general and complete Layer-2 solution that does not require permission.
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 field of ZK-Rollup, and the current valuation has reached 8 billion. Top VCs and individuals like Paradigm, Pantera, polychain, and Vitalik are the capital of StarkWare.
In terms of ecological applications, because the Cairo language is used, it is not compatible with EVM, so the progress of ecological development will be relatively slow. At present, it is beginning to transition to Cairo 1.0 and develop towards a higher TPS. Even so, 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.
