Starkware, StarkNet and StarkEx - The ultimate secondary layer for Ethereum

Scalability and privacy on Ethereum are the key words to describe Starkware’s project. The Israeli company develops secondary layer solutions that allow the network to increase its capabilities tenfold.

In this article we will present the three products developed by the Starkware team: StarkNet, StarkEx and Cairo. With advanced cryptographic tools, zero disclosure proofs of knowledge, Starkware allows Ethereum to scale, but also to regain its lost privacy.

Starkware: the company, the team and the genesis of the project

Eli Ben-Sasson, Uri Kolodny, Michael Riabzev and Alessandro Chiesa founded Starkware in 2018. It specializes inzero-knowledge proofs

(ZKP). Starkware leverages these cryptographic tools to develop scalability and privacy solutions for blockchains.

The team of about 50 people intends to transform the complex mathematical theories brought by fundamental research into functional products. Numerous engineers and coders, accompanied by their scientific advisors, are working hard to provide a scalable, transparent and secure second layer infrastructure for Ethereum

.

The interview with Starkware founder Eli Ben-Sasson will be available on our YouTube channel

soon. Starkware - FondateursStarkware - FondateursStarkware founders – Eli Ben-Sasson (President), Alessandro Chiesa (CTO), Uri Kolodny (CEO) and Michael Riabzev (Chief Architect)

Starkware started as a pet

ite startup with a passion for zero-knowledge proofs, wanting to use these cryptographic tools in the blockchain industry. The team quickly grew, and after leading a $75 million Series B round, their project went from theory to practice.

StarkNet: ZK-Rollups on Ethereum

Any Ethereum user knows its major problem: its poor scalability (the network’s ability to scale up, caused by ever-increasing usage). Its blockchain is clogged, which causes transaction fees to rise, among other things.

There are several approaches to alleviate this concern. The most popular one is thelayer 2 solutions of the network. In order to unload the main chain, as much off-chain data as possible must be processed, while maintaining a high level of security and decentralisation.

What are ZK-Rollups?

ZK-Rollups are data structures to offload the Ethereum blockchain. They are built using the famous Merkle trees and zero disclosure proofs of knowledge. Some computations and data are thus processed off-chain.

A zero-knowledge proof (ZKP) is a cryptographic protocol that allows to prove the truth of a proposition without having knowledge of the proposition itself. These protocols allow a “proof provider” to mathematically prove to a “verifier” the correctness of a proposition, without revealing any information other than the truth of the proposition.

Mathematically, zero-knowledge disclosure proofs must satisfy three properties:

  • Consistency(completeness): if the proof provider and the verifier follow the protocol, then the verifier must always accept the proof ;
  • Soundness: if the proposition is false, no malicious proof provider can convince an “honest” verifier that the proposition is true, and this with high probability;
  • Zero knowledge: the verifier learns nothing more from the evidence provider than the truth of the proposition. This is the most complex property to prove.

In concrete terms, transactions take place on the secondary layer of the network. They are aggregated in a rollup, which is then published on the main chain. A smart contract then compares the previous state of the rollup (the balance of the accounts) with the new one, and checks the validity of the transactions. If it is the case, the state of the blockchain is updated.

Principles of operation of StarkNet

StarkNet is thus a second layer platform(laye

r

2) for Ethereum, based on ZK-Rollups. It supports the same computations and operations as the Ethereum network, with the same degree of security, but with much more scalability. StarkNet has the same properties as Ethereum: the platform is decentralized, permissionless (anyone can access it), and censorship-resistant.

It allows its users to execute transactions as they would on Ethereum, but with much better scalability. StarkNet has its own programming language, called Cairo

, which we’ll talk about below. Developers can code their applications and then deploy them on StarkNet. StarkNet nodes have an economic incentive to act efficiently and fairly to ensure the security of the system. Of course, anyone can deploy a StarkNet node, which ensures its decentralization.

The operations that take place on StarkNet are aggregated. These aggregations are then accompanied by a cryptographic proof of their validity. Ethereum nodes can then verify it, and then update the state of the blockchain.

Starkware - StarkNet - ArchitectureStarkware - StarkNet - ArchitectureThe architecture of StarkNet – Starkware(Medium)

The proofs used are STARK (Scalable Transparent ARguments of Knowledge). We will go into the details of these proofs in a separate article. The main thing to remember is that they are light and transparent. They do not require a secret parameter (trusted setup), unlike SNARK used on ZCash

, for example.

The possibilities offered by StarkNet

It should be noted that the verification time

of then of the evidence decreases exponentially with the size of the evidence:

From a scalability perspective, Starkware’s results are thus very impressive. Indeed, the team can boast of having set the world record in terms of transactions per second that can be processed on Ethereum.

Thanks to StarkNet, it is possible to reach 300,000 transactions for a single proof on the mainnet: this brings the throughput to 3000 transactions / s. As for the fees, it is also a record: only 315 gas / transaction.

Concretely, StarkNet allows its users to perform transactions as they would do on Ethereum. Developers can deploy their dApps without worrying about current constraints (poor scalability, high deployment costs). Each instance of StarkNet can host and run an application.

This is the first step on the Starkware roadmap, called “Planets”.

Starkware - StarkNet - RoadmapStarkware - StarkNet - Roadmap

For the second stage, “Constellations”, multiple applications will be able to run on the same instance and access the same secondary layer state. This will make them interoperable and reduce gas costs through economies of scale.

Finally, the third stage, “Universe”, will be dedicated to the total decentralization of StarkNet. This will involve improving its consensus mechanisms and designing economic incentives to improve its transparency, efficiency and security.

StarkEx: an engine for Ethereum scalability

StarkEx is the engine dedicated to the scalability of the secondary layer of Ethereum. Already deployed on the mainnet, it allows to perform complex operations: spot trading, creation of financial derivatives and NFT. It is notably used by

DeversiFi, dYdX and ImmutableX. In the future, it will also be possible to deploy AMMs

.

StarkEx has allowed the Starkware team to test their tools and better understand the needs of the ecosystem. It integrates price oracles, and is compatible with several wallets

(Ledger, Authereum, WalletConnect, Metamask).

It is possible to deploy StarkEx using ZK-Rollups (data is published on-chain) or using Validium mode. Validium allows to check the availability of the data thanks to a sidechain. This mode has the advantage of not requiring an on-chain payment. Only the gas

cost of verifying the proof is required to update the state of the blockchain. In the future,

users will be able to choose the data access mode themselves (Volition).

Starkware - StarkEx - ArchitectureStarkware - StarkEx - ArchitectureThe StarkEx architecture

Transactions executed by an application are sent to the StarkEx Service, which will aggregate them. The batch of transactions then goes through the SHARP (shared proving service) module. The latter will generate a proof of their validity. The STARK proof is then sent on-chain

to the smart contract verifier (STARK Verifier). If the proof is valid, the state of the Ethereum blockchain is updated by the StarkEx Contract.

The StarkEx engine works on both layers of Ethereum (layer 1 and layer

2).

Cairo: the backbone of StarkNet

StarkNet and StarkEx are based on a programming language specifically designed by the Starkware team: <a href=”https://www.cairo-lang.org/” target=”_blank” rel=”noop

ener”>Cairo. This Turing-complete language (like Solidity) allows developers to use the power of STARK proofs to create scalable and efficient applications.

Its name derives from the phrase “CPU Algebraic Intermediate Representation“. STARKs are based on polynomial equations: from the developer’s point of view, Cairo allows to simplify the code underlying the interactions between proof providers and verifiers.

Thanks to Cairo’s GPS(Generic Proof Service) system, developers “prove” their code, which will then be verified on the blockchain. A single proof ensures the integrity of the execution of independent applications, which reduces gas expenses.

This language allows coders to easily integrate STARKS proofs into their decentralized applications. They can focus on their business logic, without worrying about proof generation. Cairo comes with a compiler, a virtual machine, a debugger, and an integrated development environment.

In conclusion

Starkware is setting the bar very high in designing its second-layer solution for Ethereum, based on zero-knowledge disclosure proofs. These mathematical tools are very complex, and the fundamental research on them is prolific. Putting this field of cryptography into practice is a real headache. The contributions of Starkware’s team of experienced engineers and researchers are immense. The design of their STARK proofs make them the most powerful, in terms of transparency and scalability.

If you are interested in the adventure, Starkware recruits qualified profiles: DevOps engineers, SRE engineers, back-end developers, researchers, etc.

Resources