zkSync - a Simple Overview of a Complex Technology
If you’re a non-technical person who is newer to cryptocurrency blockchains and want to learn about the basics of zkSync then you’ve come to the right place. My aim is to explain this cutting-edge technology to you in ways that made it possible for me to understand. If I can grasp the concepts of this zkRollup protocol, so can you. While the main focus of this article is on zkSync and how it plans to be the end-game for scaling Ethereum, I will also touch on a number of different points that will give you a better understanding of cryptocurrency as a whole. The first topic we will discuss is Ethereum since it’s the layer 1 foundation that zkSync is built on top of.
A Brief Description of Ethereum
Ethereum is a layer 1 [1]smart contract enabled blockchain co-founded by Vitalik Buterin in 2015. Being the first project with smart contracts gave Ethereum a first mover advantage. The benefit of having a head start on the competition has contributed to Ethereum being the most robust ecosystem and the primary blockchain for [2]Defi and [3]NFTs, the 2 largest use cases in crypto today. Ethereum has at least 2x the amount of active developers contributing to its network than any other blockchain. This activity by the developers has directly contributed to Ethereum having the most [4]Dapps and TVL (total value locked) [5]on-chain. TVL represents the sum of fiat denominated assets deposited into a given protocol by its users. This metric reflects the demand for, and utilization of, a protocol. First mover advantage and developer activity has played a major role in Ethereum’s success but I believe the most important factor has been the community and developers’ commitment to [6]decentralization while developing and optimizing the network. You may be wondering, “If Ethereum is so great why does it need help from zkSync?”. In crypto there is a phrase called the “blockchain trilemma” which refers to the idea that no blockchain can have all three components required for the perfect blockchain: decentralization, security, and scalability. Instead, a benefit in one or more of these areas typically requires a compromise in another. If you have ever spent any time using the Ethereum blockchain I feel confident that you already know which component needs help. While Ethereum is highly touted for its decentralization and security, scalability remains its primary problem.
Ethereum is Far from Perfect
Currently, Ethereum only processes roughly 20 transactions per second. For comparison Visa can “in theory” process up to 65,000 transactions per second. This means if Ethereum can’t find a way to process transactions more efficiently it will not be able to facilitate global adoption. Because Ethereum is the most active blockchain and unable to process a large number of transactions quickly the network gets congested regularly, especially in a bull market. Last year when Yuga labs (parent company of Bored Ape Yacht Club) released the “Otherside” NFT land sale one user paid $44,000 in gas fees for 2 plots of digital land. Gas fees are fees paid to perform any function on the Ethereum network with Ethereum’s native token ether or how most people refer to it, ETH. Originally, the Ethereum gas fee structure was market based; users willing to pay the most in fees would have their transaction preferentially processed. This created bidding wars where the cost to send a simple transaction could cost hundreds of dollars. That’s right; if you wanted to send your friend $20 worth of ETH the gas fee could have cost you upwards of $500 USD. Thankfully, those days are gone… right? Unfortunately not — the gas fee situation on Ethereum still sucks.
To make ETH gas fees suck a little less EIP1559 (EIP — Ethereum Improvement Proposal) was implemented on August 5, 2021. One common misconception about EIP1559 is that it was intended to lower gas fees, however this is untrue. Instead, this proposal intended to make the gas fees more predictable. With EIP1559 there is a base fee amount per [7]block, the fee amount is determined by how full the prior block was. Using a sliding scale, the price change from the prior block to following block can range anywhere from -12.5% all the way up to +12.5% and anywhere in between. For instance, if the prior block was completely empty the following block base fee would decrease by 12.5%, if the prior block was completely full the following block base fee would increase by 12.5%, and if the prior block was filled exactly half way there would be no change to the following block. With this model the user can give a tip called a “priority fee” and again the higher a user is willing to pay the faster their transaction will make it into the new block. Now if the network is congested and the user wants their transaction put in the next block the $500 fee will be more predictable. I can picture ETH users jumping for joy right now (sarcasm). Alright, I think you guys get the point, Ethereum is slow and expensive as hell. One way developers are attempting to solve the blockchain trilemma is by building protocols on top of existing blockchains and structuring the protocol in such a way that its strengths make up for the underlying blockchains weaknesses. The project built on top of the layer 1 blockchain would be referred to as a layer 2 blockchain or a layer 2 scaling solution. I’m here to tell you, not only will zkSync solve the scalability problems that plague the Ethereum network but it will also massively improve its security when interacting with a layer 2 protocol.
Matter Labs
Let me begin by giving a brief history of how zkSync was originated. In 2018 Alex Gluchowski (Ukrainian) and Alexandr Vlasov (Russian) co-founded “Matter Labs”, and based the company in Berlin, Germany. The Matter Labs team early on was made up of mostly engineers but as the company grew the more diverse team has become. Their mission statement, as per the Matter Labs website, is “to scale Ethereum to billions of users, fully preserving its most valuable properties — permissionlessness, trustlessness, and resilience — in order to protect and enhance global economic freedom.” To achieve this goal Matter Labs created the layer 2 scaling solution zkSync and released it on the Ethereum mainnet June 15, 2020.
ZK-rollups
zkSync is a ZK-rollup technology which is a layer 2 scaling solution built on top of Ethereum. First, the “zk” in zkSync and ZK-rollup stands for “zero knowledge”, as in zero knowledge proofs. The concept of zero knowledge proofs originates from 1985 by three men, one of which being Silvio Micali, the founder of the Algorand blockchain.
· What are zero knowledge proofs? In crypto, a ZK proof is a method where one party (Prover) can prove to another party (Verifier) that a statement is true without revealing any underlying information. zkSync’s ZK proof is referred to as a validity proof.
· What is a rollup? A rollup is a technology that bundles a large number of transactions together in a single batch that gets computed and compressed [8]off-chain into a ZK proof (validity proof) and then sent to the verifier contract where the data will be put on-chain. This allows for the batch of transactions to be executed all at once onto the Ethereum mainnet at a greatly reduced cost.
· The fact that rollups add more throughput onto the layer 1 blockchain and decrease user fees is exactly what defines this technology as a layer 2 scaling solution. Throughput is the rate at which the blockchain processes valid transactions.
Onboarding to zkSync
Currently, zkSync 2.0 is at the Baby Alpha milestone of its roadmap. During this phase of the roadmap the mainnet is live with limited access for internal testing. Even though Dapps can only be built and ported on the testnet users can still receive, deposit and transfer assets to each other on top of zkSync’s Version 1.0 Mainnet. To use zkSync, users need to first [9]bridge funds over from Ethereum mainnet. The easiest way to get started is by first setting up a MetaMask wallet, buy some ETH from an exchange, send ETH from an exchange to a MetaMask wallet and then bridge Eth over to zkSync. There are tutorials on https://docs.zksync.io/userdocs/tutorials that will help with this process (there are also great tutorials on there for zkSync 2.0 testnet). Once the user has funds on their layer 2 account, they can send those funds to another person on the zkSync blockchain. Before the funds can be sent the user will have to sign the transaction, this can be done by selecting “Authorize to send on zkSync” prompt, after this a notification from MetaMask will pop up and you will see a “Sign” prompt, only select this if you agree to the transaction. Signing a transaction is like giving the blockchain your stamp of approval. So, what happens behind the scenes once this transaction is sent?
Basic Order of Operations
· After the transaction is signed it will be sent to the Operator (also referred to as the Prover or Sequencer depending on what function they are performing).
· Once the Operator receives enough transactions to fill an entire block, they will bundle the transactions together and then create a validity proof.
· A small amount of data from each transaction along with the validity proof will then be sent to the Verifier, which in this case is the Ethereum layer 1 verifier smart contract. The validity proof (ZK proof) and transactional data will allow the verifier contract to verify the legitimacy and order of the transactions.
· Once the verifier contract confirms the order and legitimacy of the transactions the [10]state change will be posted onto the Ethereum blockchain. This is a basic overview of the operations. I understand that we haven’t covered what some of these terms mean yet, but don’t worry; we will breakdown each step into further detail.
PLONK
The specific proof algorithm responsible for mathematically generating zkSync 1.0 validity proofs is a proof scheme referred to as PLONK. PLONK is an acronym for “Permutations over Lagrange-bases for Oecumenical Noninteractive arguments of Knowledge”. In layman’s terms this just states the methods used to mathematically generate the proof with a single statement (validity proof) that can be verified. PLONK is also considered a SNARK but we will get to that in a minute. To implement PLONK there needed to be a trusted setup. In simple terms a trusted setup means that one has to trust that the people who contributed to the setup did it honestly. For this specific trusted setup to be labeled secure it would need to be initiated once and need only 1 person acting honestly out of the group that contributed to the setup. Luckily, the group for this trusted setup consisted of 176 people, most of which being made up of respected crypto enthusiasts along with Vitalik Buterin. During this process there will be a common parameter that will be used in the Operator’s validity proofs as well as in the verifier contract. This makes it mathematically possible for the verifier contract to know if the validity proof is true. After the initial run passes it becomes trustless because the proof scheme has been proven to be legitimate. From this point on the users will be able to rely on math instead of men. What makes PLONK universal is that it is a very generalized proof scheme that can verify all different programs on zkSync using the power of polynomials.
It will not be necessary for every Dapp to have their own specialized proof scheme, which would require each one to have its own trusted setup resulting in increased security risks. There are plans for zkSync 2.0 to implement another proof scheme called RedShift. RedShift will be a ZK-STARK but before we get into that let’s go over ZK-SNARK’s first. SNARK stands for Succinct Non-interactive Argument of Knowledge. Let’s break this down. In this case “succinct” refers to the otherwise large computation of all the transactions being compressed down into the form of a validity proof requiring much less data needing to be stored on-chain, which in turn will result in much cheaper fees. Non-interactive argument of knowledge means there will not be a back-and-forth engagement between the Operator and Verifier; the Operator will only send one zero knowledge proof statement to the Verifier and the verifier contract will either accept its validity or it won’t. RedShift is considered a STARK or Transparent SNARK. The T in STARK stands for Transparent while all the other letters have the same meaning in both words. The difference from a ZK-SNARK to ZK-STARK here is that a common parameter will not need to be shared between Operator and Verifier to make the proof scheme work, because of this there is no need for a trusted setup, hence why it is called transparent. ZK-STARKS are not vulnerable to quantum computer attacks because of this design, unlike ZK-SNARK’s.
Operator and Verifier
Now that you have read how the core of this technology was constructed let’s move onto the next steps. Once the user sends funds from their layer 2 zkSync wallet the signed transaction will make its way to the Operator. Currently the Operator node is operated by the Matter Labs team, however once they feel the protocol has been developed properly, they will release the Operator nodes over to the public, making it more decentralized. Once there are enough transactions to fill an entire block, the Operator will bundle all of the transactions together into a batch and create a validity proof. To create a validity proof the Operator uses data from the batch of transactions to perform computations off-chain that mathematically proves the order and legitimacy of the transactions, the validity proof will act as a compressed representation of the computation. The validity proof along with a very small amount of data from each transaction of the batch will be sent to the verifier contract. The transactional data will show the updated [11]Merkle root (new state) of the network to the verifier smart contract while the validity proof will prove to it that these state changes are accurate. The Merkle root verifies and keeps track of the order of all the transactions and state changes on the blockchain. The Merkle root shows the current state of the network and also allows users to be able to trace back the path of every prior transaction. Once the transaction data and validity proof are sent to the Ethereum verifier smart contract the smart contract will quickly verify the validity proof and update the Merkle root state on the blockchain. ZK proofs ensure invalid transactions can never be executed. The transaction data will be stored as calldata. The stored calldata guarantees users can withdraw their funds from layer 2 to layer 1 anytime they want even if zkSync validators go offline and never return because the data will always be stored on the Ethereum mainnet to prove rightful ownership. This is referred to as data availability.
If that wasn’t impressive enough already, zkSync uses a strategy called recursive PLONK verification. According to Alex Gluchowski there is a separate circuit specifically dedicated to recursive proofs. The intermediate circuit’s sole purpose is to take multiple validity proofs and produce an aggregated validity proof and send it for verification on layer 1. Basically, how this works is validity proofs are merged together with one another in a tree like structure. The more times a new validity proof is produced the more transactions in total it will represent (similar to the structure of the Merkle tree pictured above). Up to 20 normal blocks can be aggregated by a single validity proof that is sent to the layer 1 verifier contract. zkSync’s zkRollup using recursive proofs gives the protocol up to 3,000 TPS (transactions per second) throughput, enabling thousands of transactions to be verified together all at once and costing users a fraction of the fees. And to think, the zkRollup is only one part of the equation.
zkPorter
Once zkSync 2.0 goes live it’s going to release another technology that is very similar to its zkRollup, but with some key changes. The Matter Labs team described zkPorter as “The engine for mass crypto adoption”. I don’t think I can do it justice by explaining how potentially groundbreaking this technology truly is. ZkPorter will lower fees and increase throughput even more than zkSync’s zkRollup. The fees will be over 100x less than the zkRollup fees (keep in mind the rollup fees are already 100x less than the Ethereum layer 1 fees). It will improve the theoretical maximum throughput dramatically by providing over 20,000 transactions per second, this is almost 10x more than zkSync’s zkRollup and about 100x more than Ethereum mainnet.
What is zkPorter and how can it achieve these feats? First, zkPorter is classified as a volition which means that user data can either be stored off-chain or on-chain. Dapps and blockchains will be able to create and govern their own zkPorter shard. Projects running on a zkPorter shard will be able to decide if their shard will offer public or private transactions, where they store data, and which governance model they desire. When users decide to store data off-chain, instead of Ethereum mainnet, the data will be protected by a network of “Guardians”. Guardians will be made up of zkSync token holders that will keep track of all the state changes and confirm data availability. At least 2/3’s of all Guardians will have to sign every block for the user’s data to be stored. While the complete Merkle root data is stored off-chain with Guardians, the final state [12]hash will still be updated on the Ethereum mainnet along with the validity proof that will be verified by the Ethereum verifier contract, this ensures all transactions and state changes are valid. Since the mainnet blockchain will only store the new state and no transaction data, user fees will be 100x cheaper with a zkPorter shard than the zkRollup. These cheap fees however come with a cost, because the Merkle root data is kept off-chain it will not be guaranteed to the user that they will be able to bridge over their funds to their layer 1 account. Without a complete record of the Merkle root state changes there is no way for the user to prove to the layer 1 chain who the true owner is. The user will have to depend on the Proof of Stake network of Guardians to secure their data. zkPorter does not offer as many security guarantees as zkSync’s zkRollup, however it still provides more security than other layer 2 scaling solutions like sidechains and optimistic rollups.
There are risks associated with zkPorter that the zkRollup doesn’t have, if more than 1/3 of Guardians are acting maliciously, they will be able to halt block production and stop the network. Luckily, the Matter Lab’s team has planned for this and they are designing a forced exit mechanism to be able to get all the user funds off of zkPorter, the Guardians stake however will stay frozen. If over 2/3 of Guardians are acting maliciously, they can freeze all accounts on zkPorter, at this point even the forced exit mechanism will not work. With that said there is no real incentive for people to attack the network, because transactions can only be executed with validity proofs on zkPorter, the Operator and Guardians can NEVER steal user funds. The worst-case scenario is that funds can be frozen. If the Guardians collude and freeze all zkPorter accounts that means they also froze all of their stake in the process, it doesn’t make sense to do unless they are doing it for some kind of political reason, however unlikely it is still possible.
So, as you can see zkPorter offers incredible throughput and low fees that come at the cost of a little less security. Each user will have to weigh their risk tolerance and also take into account what use case they are using the zkSync blockchain for. For example, a zkSync user might use the zkRollup for sending 10 ETH to a defi app and use zkPorter for a transaction that will change the color of their sword in a metaverse game they’re playing. Accounts and smart contracts on zkRollup and zkPorter will also be able to interact with each other seamlessly. I just want to repeat something before we move on, the Operator and Guardians can NEVER steal user funds because the only way funds can move on any zkSync system is with a validity proof!
Fees
One question I have heard often is “How are zkSync fees so cheap?”. The answer of course is because zkRollup and zkPorter allow for thousands of transactions to be rolled up into a batch and then verified as a single transaction. Instead of every transaction being validated onto the Ethereum mainnet one by one with all of their transaction data, all that is needed with the zkRollup is a validity proof and limited transaction data. The data needed to be stored for zkPorter is even less. All that goes on the mainnet is the validity proof, the transaction data gets stored off-chain with the Guardian network. Besides the batch of transactions being validated as a single transaction and very limited data being needed to go on-chain for zkRollup, another reason for the ridiculously low fees is that all of the users who had a transaction that was part of the validated batch will split the fee. This means the transaction fee will be split with thousands of users. The easiest way to think about fees in regards to zkSync and Ethereum, is to think of it almost like a storage unit, anytime zkSync users drop off data to be stored on the Ethereum mainnet they will be charged for it, the more items that go into storage the higher the fee will be. When a user makes their first transaction on zkSync they will have to pay a one-time account activation fee. Once an account is activated on zkSync 1.0, a new private-public key pair is generated to the users’ associated Ethereum address. zkSync 2.0 however will not require users to pay an activation fee. Since the registration takes place on the L1 (layer 1) blockchain the fee will be paid to Ethereum stakers which will be more expensive than if this function took place on L2 (layer 2). There are no registration or activation fees to receive funds on zkSync 1.0. Transaction fees are based on 3 main factors:
1) Amount of data that will be sent to the Ethereum blockchain.
2) Ethereum gas price at the time of transaction.
3) Cost to compute and generate a validity proof along with the transactions.
On average, when users send ERC 20 (tokens created on Ethereum) and ETH tokens on zkSync they pay less than 1/100th and 1/30th “respectively” in fees compared to if they used the Ethereum mainnet. Besides fees being cheaper on zkSync they can also be paid for by any token that is listed on Uniswap with at least $500 worth of liquidity and a token price that is listed on CoinGecko. Users can use this page https://zkscan.io/explorer/tokens/ to see if the token they want to send is already listed on the supported tokens list. If it isn’t listed, users can click the “Add New Token” button on the same page and register the token manually.
Security
Not only can zkSync provide increased throughput and cheaper fees, it does so with paramount security. No transaction can be successfully sent on zkSync without a validity proof being executed by the verifier contract on the Ethereum mainnet. ZkRollup users can always use a forced transaction if they believe there is censorship taking place on zkSync, this allows users to bypass zkSync server nodes and send transactions directly to the Ethereum mainnet any time they want. These two features ensure that funds held on the zkRollup have equivalent security guarantees to funds held on the Ethereum mainnet. ZkSync and Ethereum complement each other, zkSync inherits Ethereum’s layer 1 security while Ethereum inherits zkSync’s scalability benefits. This is a monumental feature as normally when bridging funds from one blockchain to another there is a huge susceptibility for a bridge hack. The validating bridge between zkSync and Ethereum is much safer. In August 2022 it was reported that bridge hacks had been responsible for the loss of over 2 billion dollars of user funds already this year. Vitalik Buterin, made a detailed twitter post where the title read: “My argument for why the future will be *multi-chain*, but it will not be *cross-chain*: there are fundamental limits to the security of bridges that hop across multiple “zones of sovereignty”. Vitalik is saying that he believes we will have a future where multiple projects will operate for the most part independently of each other compared to a cross chain future where projects will communicate with each other and allow people to move their token’s value from one blockchain to the other. Since this post came out in January of this year zkSync along with other ZK-rollup projects have made tremendous strides in their development. ZK-rollup technology might very well solve the enormous problem of cross chain susceptibility that is responsible for bridge hacks. I will discuss this in greater detail in the paragraph titled, “The Future of ZK Technology”.
Privacy
When I originally heard about the concept of ZK proofs in crypto I assumed that information would be hidden from the blockchain. I kept thinking zero knowledge is in the name, it must have to do with keeping user information private. For instance, I assumed that somehow the blockchain would hide information like my account or the total amount of tokens in my account. As of right now this isn’t the case, the real utility of ZK proofs is that they are succinct, and can compress a huge amount of data into a validity proof with a much smaller amount of data bytes that need to go on-chain. Well, at least for now. zkSync has made a conscious effort to first optimize scaling and then focus on privacy in the near future. ZkPorter will make it possible for Dapps to keep users’ information off of the blockchain. Since zkPorter doesn’t need to store calldata to the Ethereum blockchain, certain data will be able to stay hidden since it will be stored by the Guardians and not the L1 blockchain. I’m sure as projects get closer to launching private Dapps on zkSync, the Matter Labs team will inform the public on how privacy features will specifically be implemented.
ZK-EVM
The way smart contracts are processed in Ethereum is by the Ethereum Virtual Machine (EVM). The EVM is a blockchain based, globally distributed virtual machine responsible for keeping the Ethereum ledger in order as well as executing smart contracts mostly written in [13]Solidity. EVM is considered Turing complete which means in principle it can execute any possible smart contract, however the more steps the EVM needs to take to compute the smart contract the more the user will need to pay in gas fees. That’s actually why some people like to refer to Ethereum as “quasi” Turing complete because while in theory the EVM can execute any smart contract in reality the users will not be able to afford the gas fees for complex smart contracts. The EVM was not designed to process complex ZK proofs as when it was designed over 7 years ago, Vitalik and his cohorts did not have zero knowledge proofs in mind. To combat this there are multiple teams who are actively building their versions of a ZK-EVM. zkSync’s ZK-EVM is considered EVM compatible, which means its smart contracts can be executed on the EVM. While most existing Ethereum smart contracts could immediately be executed on the ZK-EVM, there is still a very small number of smart contracts that would need to be altered before the ZK-EVM could execute them. The reason for this is because the ZK-EVM is not EVM equivalent. When I first heard that zkSync’s ZK-EVM wasn’t going to be EVM equivalent I thought it was a negative for the project but then as I looked into it deeper, I realized this could be seen as a positive, let me explain. Haven’t we already established that the EVM isn’t designed to execute ZK proof smart contracts efficiently? So why would we want zkSync to make an equivalent ZK-EVM that matches it? zkSync altered their ZK-EVM to make it about 98% compatible with the EVM, the 2% difference allowed for the team to make optimizations that ultimately enabled it to be ZK smart contract friendly. The simplest way the ZK-EVM can achieve compatibility is by using the same programming languages the EVM supports like Solidity, Vyper or Yul. It is also possible to use other languages but the code needs to be compiled in a way that the EVM can understand it. Eventually zkSync will implement a rust-based programming language called Zinc. By introducing a Rust based language to the zkSync ecosystem, it will allow Devs who are familiar with Rust the opportunity to participate in the zkSync network in no time. Zinc will allow smart contracts to be more expressive compared to Solidity. Because this language is explicitly designed for ZK smart contracts it allows for very fast prover times and for the Operator to have minimal hardware requirements. This substantially reduces costs and makes it easier to become an Operator, which in turn helps decentralization.
There are 2 main reasons for creating a ZK-EVM and making it as compatible as possible with the EVM. The first reason is to allow for more generalized and complex smart contracts on the zkSync blockchain. The EVM on Ethereum layer 1 blockchain can only validate very specific and simple smart contracts from the zkSync chain but because ZK-EVM is built to interact with zero knowledge proofs it will allow for more complex and generalized smart contracts. Once the validity proof is validated by the ZK-EVM the ZK-EVM can then translate the final state changes onto the EVM. The ZK-EVM basically acts as a middle man between the zkSync smart contracts and the Ethereum mainnet. The other main reason for creating ZK-EVM with EVM compatibility is to allow existing smart contracts, Dapps, and tooling on the Ethereum mainnet to [14]port over to the zkSync blockchain as smoothly as possible. This will be the fastest route to bringing a lively community full of utility over to the zkSync blockchain. Developers and other builders who port over projects from Ethereum may need to make small changes to their code before deploying on zkSync. The reason for this is because the ZK-EVM is EVM compatible and not EVM equivalent. ZK-EVM’s that are EVM equivalent can port dapps and smart contracts between L1 and L2 seamlessly with no changes needed to be made to the code.
The Future of ZK Technology
I will close by summarizing Matter Labs team member Steve Newcomb’s SmartCon 2022 talk on the future of the crypto space with ZK technology. First Steve discusses the three different layers of blockchains, layer 1 of course being Ethereum, layer 2 the base level of zkSync with only the zkRollup, and then layer 3 where there is zkRollup, zkPorter, tokenomics, privacy, Hyperbridges/Hyperchains. Steve states layer 3 is where the real magic happens, where they plan to scale infinitely and not just by increased throughput and cheap fees but also in terms of security. Steve paints a picture where he talks about porting over existing layer 1 blockchains, which would be termed a “Hyperchain” once they come to zkSync. This would give the existing L1’s the opportunity to have a native bridge with Ethereum vs their current non-native bridges that leave them susceptible to bridge hacks. There would be no risk transferring assets back and forth between the Hyperchains and Ethereum because it would all be validated with the validity proof. This would solve a massive security problem. Hyperchains can also dictate if they are private or public, meaning they can choose if they want to keep certain user data private. Steve’s next idea would be considered the grand finale of scaling. I can’t stress this enough how groundbreaking this could be. If all of the layer 2 (other ZK and Optimistic rollup) projects could agree on a standardized ZK-EVM and standardized Operator and become Hyperchains like the layer 1’s every project on layer 3 would have a native link to each other. Ultimately this would make all the layer 3 projects one cohesive group bound together by the same ZK-EVM and Operator. This would bring maximum security to an incredibly scaled system. I believe the key take away from Steve’s speech was that if the crypto community can declare universal standardizations on top of layer 3 all of the projects involved can gain shared security and increased scalability. This would make cross-chain bridges obsolete, solving possibly the biggest problem crypto is faced with today. In the 90’s, TCP/IP was declared the winner of the internet wars and became the standard internet network, from that point on the vast majority of the internet was built on top of it. It’s a similar idea here. This is just one way the crypto space could possibly go; there are an infinite number of other possibilities. Only time will tell how impactful zkSync will be on the crypto space as whole. I know I will be following the project closely and will continue to root for their success.
Here is a link to Steve’s full speech if you would like to watch it in its entirety- https://youtu.be/0RZvOLKo3Xw
Existing Roadmap
Baby Alpha- This is currently where we are in the roadmap. During this phase of the roadmap the mainnet is live with limited access for internal testing. There is a testnet that allows users to port and build Dapps on top of it. Went live October 28, 2022.
Fair Onboarding Alpha- Here zkSync will welcome all of their ecosystem projects. The last I heard they will have over 150 projects deploying at this time. The projects will be able to test and audit the system to get ready for when the general public will be allowed to participate. Expect Q1-Q2 2023.
Full Launch Alpha- This is where the door gets kicked in and everyone is welcome to explore zkSync. Before this phase of the roadmap is ready to be implemented, projects will need to fully test their projects on the zkSync system for security audits, bug bounties and much more to ensure safety to the incoming users. The Matter Labs team has stated at this stage expect to see top notch developer support in the form of documentation, tutorials and tools. Expect 2023.
Layer 3 Testnet: Opportunity- The team will deploy a layer 3 Hyperchain proof of concept called Opportunity. Existing projects will be able to port over to the layer 3. When this milestone comes there will be major upgrades in developer tools such as CLI and SDKs. Expect 2023.
Decentralization- The Matter Labs’ team goal is to bring decentralization to the zkSync protocol, proof generations, block production and transaction validation. Expect 2023.
Definitions
[1] Smart contract- a computer program that will self-execute the terms of a contract or agreement when specific conditions have been met.
[2] Defi- Decentralized finance, a cryptography technology that offers peer to peer financial services without the need for a third party.
[3] NFT- Non-fungible tokens, are cryptographic assets that come with unique digital properties that distinguish them from each other. They can come in the form of music, art, gaming, videos, and collectibles.
[4] Dapps- Decentralized applications or programs that run on blockchains and are powered by smart contracts.
[5] On-chain- transactions that have been verified and recorded on the blockchain which offers security and transparency because they can never be altered.
[6] Decentralization- a network being controlled by a distributed group rather than one central entity making all of the decisions.
[7] Block- the basic data structure in a blockchain. They store transaction data. Once the transaction data has been validated the information inside of the block will be permanently recorded on the blockchain. The recorded block will be closed and a new block will be created.
[8] Off-chain- transactions that are confirmed outside of the main blockchain.
[9] Bridge- a smart contract protocol that enables the transfer of assets from one blockchain to another blockchain. (This can be used as a noun or a verb)
[10] State change- any time there is a recorded change on the mainnet.
[11] Merkle root- each transaction can be represented by a hash. The combination of all the transactions in a block can also be represented by a single hash. As this process continues each new hash will represent more transactions than the prior hash until it gets to the point where there is only 1 hash that represents the entirety and new state of the blockchain, this is called the Merkle root or root hash. This process allows users to be able to trace back and verify data from the entire blockchain while using a minuscule amount of data to store the information.
[12] Hash- a mathematical function that converts any input into an encrypted output.
[13] Solidity- a programming language designed for writing smart contracts on the Ethereum blockchain.
[14] Port- transferring Dapps or programs from one blockchain to another blockchain
Additional Links:
https://docs.zksync.io/userdocs/ resource for paragraphs: ZK-rollups, Onboarding to zkSync, Basic Order of Operations, PLONK, Operator and Verifier, zkPorter, Fees, Security, Privacy, ZK-EVM, Existing Roadmap
https://www.youtube.com/watch?v=Z9dTO3L-vMk&t=3849s resource for paragraphs: Operator and Verifier, Security, ZK-EVM, The Future of ZK Technology
https://ethworks.io/assets/download/zero-knowledge-blockchain-scaling-ethworks.pdf resource for paragraphs: Basic Order of Operations, PLONK, Operator and Verifier
https://www.youtube.com/watch?v=dukgSVE6fxc&t=785s resource for paragraph: zkPorter
https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf: resource for paragraph: zkPorter
https://vitalik.ca/general/2022/08/04/zkevm.html resource for paragraph: ZK-EVM
