Scaling Summit 2021 Keynote Recap | STARK Validity Rollup — An Ultimate Scaling Technology
On December 18, 2021, at the 8th Old Friends Reunion Scaling Summit, we are pleased to have invited Eli Ben-Sasson, the Co-Founder & President of StarkWare to give us a thought-provoking keynote speech!
Overview
In a centralized system, all computers and nodes are controlled by a large centralized entity, with high capacity but this will result in a sacrifice of privacy. Under the blockchain system, thanks to the principle of ‘inclusive accountability,’ everyone is given the right to check the validity and accountability of the system. However, the privacy and scalability of these systems have been questionable.
The emergence of ZK can solve this situation. Simply put, this is a redefinition of the trust mechanism. ZK is the trust in maths. When the computer processes a large number of transactions, the trust mechanism is based on the trust in maths and cryptography, not on the computer itself. Based on ZK technology, StarkWare launched StarkEx to solve the problem of scalability. StarkEx consists of the prover and the verifier. The off-chain prover is responsible for processing a large number of transactions and generating the STARK proof to update the status of the rollup and confirm the mathematical correctness of these transactions. Then the verifier on the chain will carry out the transplantation of the whole process on the Ethereum main chain and verify the correctness of the transactions. This approach provides scalability and integrity at the same time because instead of all the nodes in the system verifying each transaction, all they need to do is to run a lightweight verifier. By doing that, they can check the system maintains its integrity and the new state is valid.
StarkEx is one of the leading L2 in terms of many parameters, such as cumulative trading over $270 billion. It has settled over 65 million transactions and has over $1 billion locked in total value. An average transaction on StarkEx costs less than 500 gas, roughly 100 to 1000 times cheaper than what it would cost on Ethereum. The form of brand-new product StarkNet is no different from that of Ethereum. Smart contracts can be deployed at will, and it will be way more scalable than Ethereum. A series of related tools will be launched in the future, including ERC20 contracts, L1 and L2 cross-chain bridges, and compilers from Cairo to Solidity.
We’ve captured the full learnings and video from Eli’s presentation below:
Hello. I am Eli Ben-Sasson, I’m the Co-founder and President at StarkWare, and I am very happy to be presenting at the IOSG 8th Old Friends Reunion Scaling Summit 2021. Thank you very much for inviting me here. Let’s start. I would like to tell you about STARK Validity Rollups, the ultimate scaling technology.
So let’s see. Here’s a paradox. Bitcoin was launched in 2008. Ethereum was launched in 2015. So why are these technologies so slow, especially when you compare them to banks, credit cards or systems like Alipay or WeChat Pay? The answer to this is that they work in a different model and especially a different trust model. So the model of the conventional world, the one that came before blockchain and bitcoin, is one that relies on trusted parties like banks and financial institutions. In it, we have one central entity that manages all of our information, all of our finances and all of the computations that are related to them. We need to trust the central party now in order to hold the party accountable and know that everything is done with integrity and correctly and validly. We delegate the process of holding those entities accountable to a small set of trusted entities like auditors, accountants, lawyers, judges, all kinds of appointed regulators. So we trust these central systems and we appoint and delegate the process of checking them and checking their integrity to specific humans.
This is the conventional world. It is very efficient. But however, blockchains offer a different way. In blockchain, we have inclusive accountability, which means that everyone is invited to take her laptop connected to the internet and using that laptop check that everything that is going on on the blockchain is done with integrity and validity. So we have a very beautiful principle that invites everyone to inspect and be an accountant and hold the system accountable for what’s going there. However, this means that we sacrifice both the privacy and the scalability because of each and every transaction. These are these little red squares in which people transact. Each one of these transactions is sent to all nodes on the blockchain, and every person operating a node, first of all, sees these transactions, which means that you lose privacy. Since we want the system to be inclusive and we want people to use their standard computers and smartphones to verify the integrity of the system, we must limit its scale. So because of the beautiful principle of inclusive accountability that invites everyone to check and verify the blockchain, we sacrifice both privacy and scalability. Now in this talk, I’m going to focus only on scalability. Even though the technology that we invented and we developed also can solve privacy, but that’s not the focus of this talk.
So how are we going to scale with inclusive and accountability while maintaining inclusive accountability? How can this be done? Let’s see, first of all, here is the current state of affairs, this is just summing up what we already saw on the left.
We have the trusted party model and on the right we have blockchains. Now in the trusted party model, we have some big computer or a set of computers that are all run by this one trusted entity. Because of that, you have a very great scale and you also have privacy from all but the entities running those computers. On the blockchain side, on the right, we have this brave new world where everyone can verify the full integrity of the system. However, we don’t have scalability. So what can we do? Let’s see some things that we might try to do. One thing we might do is try to ask everyone to buy bigger computers so that we can process more and maybe purchase a faster connection to the internet. What will happen will be that we slowly start excluding people because some of us won’t go out and buy a bigger computer, some server with many cores and large disk space. We will just opt out and slowly over time, fewer and fewer nodes will be able to track the system and verify its integrity. In a very short time, we will have arrived back at the situation of a single or a small set of trusted parties.
So this is not really a good solution. This is one that blockchains don’t want to embrace. Another solution relies on fraud proofs, fraud-proof rollups, such as Arbitrum and Optimism that are already out there. Here the premise is that anyone can run a big computer and we as end users have two options. We can either go out and buy and run a big computer that will track everything that is going on in the blockchain in which we increase its capacity or else we’re not going to do that. Then we need to trust that someone, one of these nodes will be checking and holding the system accountable on our behalf. This allows you a somewhat better scale. But it is also the only semi-inclusive because you can also imagine that a lot of the users and nodes that are tracking the system are going to fall out and maybe they don’t have someone to trust. This is suboptimal. The approach that StarkWare was basically the first to push forward and by now has been embraced by many other teams is one of scaling through the use of cryptographic validity proofs in particular. We’ll talk about StarkNet and other solutions. By now there are several other teams that are also advancing scalability, such as the Matter Labs and Aztec and several other teams that are looking at this direction. We were the first to talk about this many, many years ago, and we’ve been at it for more than three years with it for more than four years within StarkWare.
So the approach here is to trust math so that a single large computer will process a lot of transactions. But we do not need to trust anything about that computer. It could be executed and maintained by the most evil of entities. The math will prevent it from generating proofs that are invalid, and the math will prevent it from moving the system or processing transactions in a way that is illegal. This will be prevented. In our solution, in the solution that we invented and innovated across many iterations, you can have the best of both worlds. You can have a single big computer processing many transactions. However, you’re trusting that computer is not based on trusting humans. It is on trusting math and cryptography. This way, all the nodes in the network only need to check proofs, which we’ll talk about, but they are extremely fast and efficient to verify.
So what is the proof? Here’s an example of a proof. A proof, in this case, is a receipt that you get at a restaurant. Now, what exactly is this piece of paper and what is this text? What purpose does it serve? It is there to convince you that you should pay the amount at the total, meaning there’s a statement that the prover in this case it is the restaurant owner who wants to convince you is correct.
The statement, in this case, is that you should pay $89.50, and the way she is convincing you that this is correct is by presenting you with a proof. Now you as a verifier, don’t need to trust this proof. You can verify that it is correct, and the way you verify this particular proof is by doing a computation. You are re-executing the summation of items, and you can see for yourself whether the statement is correct or false. So a proof is something that convinces you that a statement about computation is correct. Now our proofs, called ZK-STARK proofs, are a little bit like these restaurant bills, but also much more powerful. One aspect that is not the focus of this talk is privacy. Our technology can let you be convinced that a statement is correct, even if you don’t see all of the inputs that go into it. So imagine that you get a restaurant bill where some of the items and sums are blinded out. Still, you know that you are paying the correct sum. It sounds a bit impossible, but this is one of the magical things that zero-knowledge proofs give you. But this is not the focus of this talk, and it is not the focus of our company right now.
The second aspect that I want to focus on in this talk is that of scalability, which means that we can generate using a STARK proof we can generate very efficiently a proof for the correct execution of a huge number of transactions. But the size of the proof in the time needed to verify it is exponentially smaller than the number of transactions that went into the computation. So you can see here a prover. It’s a big machine, but it need not be trusted. Its hardware doesn’t need to be trusted, and its software doesn’t need to be trusted and the party running it doesn’t need to be trusted or audited. All you need to know is that the verifier is operating correctly. Now what you get, the prover processes a large number of transactions. These are these little red boxes there and spits out a proof. The proof is extremely short. It is exponentially smaller than the size of the batch of transactions. This is what is sent to the verifier. Now we can send this to the blockchain. This proof. So instead of asking all nodes in our network to verify each and every transaction, we can offer them the same security level. But instead, all they need to do is run a verifier software. This can be run on their smartphones, and they get a new proof, along with a new commitment to the state of the system. They can check that the proof is valid, and because of that, they know that the system has been moved to a new state with integrity.
So if the state of the system captures, let’s say, the set of all accounts of citizens of a certain country, you could have a new commitment that captures the new state of accounts along with a very short proof. You could have this proof asserting that all transactions in that country that transpired over the past day. All of them are valid, such as the power of our technology. This proof, even if you take the largest of countries, which is China and take all of its transactions and you would generate the start proof for them for all their daily transactions, verifying that proof would take less than one second on a smartphone. It sounds impossible, but that’s the technology.
So far, we talked about theoretical things. I want to tell you now about how these things are actually implemented by StarkWare, which is the leading L2 Rollup company using validity proofs and the one that basically innovated and invented this whole approach. Let’s see how we put them to use. So we have two offerings. Both of them are already available and in production. One is StarkEX and the other is StarkNet. So StarkEx. Before that, I just want to tell you a little bit about StarkWare, so we’re very proud of the things that we contributed to the science and technology of blockchains.
We invented zero-knowledge Stark. We invented protocols like FRI. We invented a programming language called Cairo in which all our systems are built. We invented technological solutions such as shared proving the validity of data availability model and Volition another data availability model. All of these things are now embraced and used by others in the industry, and we’re very happy with that. Our mission is to bring scalability and privacy to a blockchain near you. We have a large set of products StarkNet and StarkEX. We have 60 team members and growing fast and we have over $160 million in funding. You can read more on our website.
Let’s talk about StarkEx. StarkEx is the largest L2 in terms of many parameters, such as cumulative trading over $270 billion. We settled over 65 million transactions. We have over $1 billion locked in total value and we are extremely efficient. We are proudly supporting 4 customers right now, dYdX, Sorare, Immutable X and DeversiFi and many more are going to join.
An average transaction on our system costs less than 500 gas, which is roughly 100 to 1000 times cheaper than what it would cost on Ethereum. Here’s a very brief video that explains how StarkEX works.
Blockchains are secure, decentralized and trustless, but transacting on-chain is expensive because blockchain’s capacity is limited, transacting off-chain through an operator like an exchange gives unlimited scalability. But it requires users to trust the integrity of the operator. So how do we increase scalability while enforcing integrity? StarkEx, our scalability engine has a prover and a verifier. The offchain prover processes a big batch of transactions and prepares an update for the state of the system. The prover also generates a tiny STARK proof that uses math to guarantee all transactions are valid. The STARK proof and the update to the state of the system are sent to the onchain verifier, which serves as a guardian of integrity. The proof is verified as valid, and only then can the state update be committed on chain. The division of Labor between the Stark, prover and verifier is uneven by design. Doubling the computational work for the prover adds only one unit of work to the verifier. This is how we scale massively and still enforce computational integrity. All transactions are validated offchain. The proof of their integrity is verified onchain. That’s how StarkEx provides both scalability and integrity with STARK.
Our second product line, which is also live now, it’s been live for the past 3 weeks, is called StarkNet. It is just like an Ethereum. It allows everyone to jump in, write smart contracts and deploy them, and everyone can send transactions permissionless to this network. It is very much like Ethereum, only at a much higher scale, thanks to the power of STARK.
We already have general computation L1, L2 interactions, permissionless deployment of contracts and transactions, and very soon, within the next month, you’ll have ERC20 contracts, bridges from L1 to L2 and many other things. StarkNet is built not just by StarkWare, but we have a very large ecosystem that is expanding rapidly. We have two separate independent full node approaches being built by independent teams. There’s going to be a compiler from Solidity to Cairo, which is the programming language in which all our systems, both StarkEx and StarkNet have been written. There is a block explorer that you can go out and check. If you just go down this QR code, you’ll get all your resources and a lot of very exciting stuff. So if you’re a developer, please jump on board, join our discord and start using the system. Just to summarize, we have an amazing technology that we invented and offered to the world, which is called zk-STARK. Based on this, we have two live robust production systems, StarkEx and StarkNet. They are all written in a toolchain that is now available to everyone under StarkNet. So I hope that you join us and check out these things.
Thank you very much. Thank you IOSG Ventures for having me on the Old Friends Reunion 8th, and thank you for listening to me.
About Co-hosts
IOSG Ventures, founded in 2017, is a community-friendly and research-driven early-stage venture firm. We focus on open finance, Web 3.0 and infrastructure for a decentralized economy. As a developer-friendly fund with long-term values, we launch the Kickstarter Program, which offers innovative and courageous developers capital and resources. Since we consistently cooperate with our partners and connect with communities, we work closely with our portfolio projects throughout their journey of entrepreneurship.
❄️ StarkWare
StarkWare invented, and continually develops, STARK-based Layer-2 Validity Proof scaling solutions over Ethereum. StarkWare’s solutions, which rely on Ethereum’s security, have settled over $250B, and over 60M transactions, serving hundreds of thousands of users. StarkNet, StarkWare’s permissionless general-purpose scaling solution, is live (Alpha) on Ethereum Mainnet. StarkEx, a custom standalone scaling service, has been powering applications since June 2020, including dYdX, Immutable X, Sorare, and DeversiFi.
❄️ imToken
imToken is a decentralized digital wallet used to manage and safeguard a wide range of blockchain- and token-based assets, identities, and data. Since its founding in 2016, it has helped its users transact and exchange billions of dollars in value across more than 150 countries around the world. imToken allows its users to manage assets on 12 mainstream blockchains and all EVM chains, it also supports decentralized token exchange and open DApp browser.
❄️ Arbitrum
Arbitrum is a leading Ethereum Layer-2 scaling solution developed by OffchainLabs. Based on the Optimistic Rollup scheme, Arbitrum enables ultrafast, low-cost transactions without sacrificing the security of the Ethereum ecosystem. Launched on August 31st, 2021, Arbitrum has attracted 100+ ecosystem projects. Arbitrum is currently EVM-compatible to the bytecode level. In the next upgrade, Arbitrum Nitro, Arbitrum will further increase developer experience by incorporating WASM support.
