Tech Stack

In order to prove the validity of a computation in a STARK proof, it must be expressed in algebraic form. Cairo is a CPU architecture, decoupling the business logic, which can now be written in a high-level programming language from the algebraic representation that can be efficiently proven by STARK. This way, developers can focus on writing the desired business logic, without the need to understand and account for translating it to efficient mathematical representations. Cairo is a modern programming language reminiscent of Rust. Cairo makes it easy to develop, test, and maintain contract logic without the need to deep dive into the STARK algebra.

StarkWare defines the Cairo-Architecture and implements it both as a native VM, and as a proving-optimized algebraic form. StarkWare develops additional developer tools around the Cairo programming language, such as compilers from higher-level languages, debugger, IDE support, and more.

The Cairo toolchain is developed in Rust for great flexibility, performance, developer experience, and readability.

Starknet is a permissionless decentralized ZK-Rollup operating as an L2 network over Ethereum. StarkNet solves the blockchain scalability problem by enabling significantly higher network throughput, thus also lower cost per transaction while leveraging Ethereum’s security. Developers can write Starknet contracts using the Cairo language and deploy them on the network, and users can send transactions to these contracts (in a similar manner to Ethereum).

The two main components running Starknet are the Sequencer (which generates blocks, similar to miners in Bitcoin or validators in Ethereum) and the Full Node (that syncs on the state of the network). Both are built in Rust, to enable both safety and good performance. This optimizes the proving performance of each transaction execution. A Solidity contract deployed on Ethereum connects the Starknet network (L2) to Ethereum (L1).

The Starknet transaction execution environment, called Starknet OS (similar to the Ethereum Virtual Machine), is implemented in Cairo.

The Starknet Prover is optimized for performance by implementing C++ and some low-level assembly. It runs over micro-services architecture in the cloud.

The Verifier is implemented in Solidity, allowing proofs to be verified on the Ethereum blockchain.

StarkWare runs separate instances of its L2 appchain (an L2 system providing scale on top of Ethereum) for premium customers.

Such services do the heavy lifting of communicating with the Blockchain and the Application smart contract (over Starknet or Ethereum), to apply off-chain logic as required, and expose an application-specific API, allowing the customers to focus on their core competence.

The off-chain services are implemented in Python and typically implement a cloud micro-services architecture.

Stone Prover, a cornerstone of Starknet’s Layer 2 tech stack, is available under the Apache 2.0 license. It is capable of proving the computational integrity of a VM running Cairo. By nature of the STARK algorithm it implements, the verification of proofs is logarithmic in the size of the Cairo statement (program traces) run. This is leveraged by Starknet for scaling Ethereum.

By open-sourcing this robust tool, reflecting the spirit of a truly decentralized and permissionless Layer 2 network, StarkWare offers developers this versatile proving engine for them to prove their Cairo programs and help contribute to the development of Starknet’s ecosystem.

Since launch, STARK-tech scaling solutions built with this Prover at their basis have compressed and proved $1T in cumulative transaction volume, 500M transactions, and more than 100M NFT mintings.

Representing StarkWare’s complete commitment to scaling Ethereum, SHARP (SHARed Prover) is poised to redefine the benchmarks of scalability solutions in the Layer 2 crypto domain.

Built upon the robust foundation of the Stone Prover, SHARP is a powerful system designed to generate STARK proofs for aggregated Cairo programs. It does this by processing vast amounts of batch transactions off-chain and subsequently validates their computations through an on-chain Solidity verifier contract on Ethereum’s Mainnet. The result is enhanced throughput, reduced gas fees, and minimized latency.

Stwo, our open-source next-generation STARK prover, will implement the ground-breaking Circle STARK protocol to offer a blazing-fast proving experience Stwo will be developed under the Apache 2.0 license from day one.

The unprecedented performance facilitated by Stwo’s efficient implementation of Circle STARKs will benefit both users and devs in the Starknet ecosystem, reducing latency until finality and transaction fees!