Sovereign is an open, interconnected rollup ecosystem. Our goal is to enable all developers to deploy seamlessly interoperable and scalable rollups that can run on any blockchain. That’s why we’re building the Sovereign SDK, the simplest framework for creating secure and interoperable sovereign zk-rollups.
The Problem: Blockchain Apps Don’t Scale
Monolithic L1s Don’t Scale
In the quest to scale blockchain apps, three dominant paradigms have emerged: application-specific layer 1s, optimistic rollups, and zk-rollups. App-specific layer 1s are the simplest to design and implement - but they come with a significant drawback. Every layer 1 has to recruit its own validators and convince them to stake enough capital to defend the chain against attacks. Costs of capital being what they are, this approach is only viable for a few well-funded apps.
Optimistic Rollups Break Composability
Rollups try to solve this problem by allowing developers to extend existing blockchains with new logic, rather than starting new ones. This drastically decreases the barrier to entry for app-chain development.
But optimistic rollups (the rollups that dominate the market today) are not a panacea. In order to minimize the burden on the shared validator set, optimistic rollups rely on fraud proofs to prevent misbehavior. During an attack, these fraud proofs might be censored - so optimistic rollups have long “finality delays” during which transactions could be rolled back by the appearance of a fraud proof. This makes bridging out of optimistic rollups slow and costly.
So, optimistic rollup developers have to make a tough choice: do they build narrow, special-purpose rollups and expect users to bridge frequently between chains? Or do they build general-purpose rollups that try to satisfy all of a user’s needs in one place? Neither choice is good. Bridging between optimistic chains is too slow, too expensive, and too risky to be an everyday operation. But general-purpose optimistic rollups suffer from many of the drawbacks of monolithic L1s: not only do they suffer from scalability issues of their own, but they also fail to support the full diversity of functionality that app-chains can create.
Zk-Rollups are the Future
For all of these reasons, we expect zk-rollups to emerge as the dominant scaling paradigm. They share the advantages of optimistic rollups, but without the long finality delay. Instead of waiting days to see if a fraud proof appears, users can be confident that their transaction is final as soon as a validity proof is created - a process which can take mere seconds.
But if zk-rollups are the superior scaling solution, why isn’t everyone using them? Because until now, actually building zk-rollups has been a huge undertaking - requiring years of effort from expert cryptography engineers.
Enter Sovereign: The Internet Of Rollups
What is the Sovereign SDK?
The Sovereign SDK aims to do for zk-rollups what the Cosmos SDK did for layer 1 chains.
It will provide all of the boilerplate that would usually go into a blockchain - a p2p network, a database, and an RPC node - letting builders focus on the business logic of their chain. In addition, it will provide a set of default modules that operate efficiently in a zero-knowledge environment: a token implementation, an authenticated data store, and a bridging module. Developers will be able to combine these primitives into app-chains, or build their own state-transition functions completely from scratch by implementing a standard set of APIs.
Even better, the Sovereign SDK will be the first rollup framework to abstract away the details of zero-knowledge. To take advantage of its power, developers won’t need to become experts in cryptography. Instead, developers will be able to write their apps in idiomatic Rust (or eventually C++), and the SDK will automatically compile it to an efficient zk virtual machine.
What properties will the Sovereign SDK provide?
-
Sovereign SDK rollups will be seamlessly interoperable. We use a novel bridging technique based on proof aggregation to allow Sovereign SDK rollups on a shared L1 to bridge back and forth without a trusted third party. Since zk-proofs can be aggregated, rollups will be able to maintain as many bridges as they want at minimal cost. Off-chain relayers can aggregate the proofs of all the peer rollups into a single proof, and just that single proof can be verified on chain. And since state transitions are proven to be valid, there will be no need to pay fees to a liquidity provider or wait a week for transactions to finalize. Bridge right away, with no drawbacks.
-
Sovereign SDK rollups will be securely scalable. By purpose-building every component especially for use in zk-rollups, the Sovereign SDK will provide excellent performance by default. Thanks to advances in parallelism, our proving will have latencies measured in seconds. And with the magic of zero-knowledge proofs, chains will be able to scale without sacrificing end-user verifiability.
-
Sovereign SDK Rollups can run on any blockchain. Sovereign SDK chains delegate the responsibility for checking proofs to the end user, not the underlying L1. This is what makes them “sovereign” rollups as opposed to smart-contract rollups. Since the data availability layer doesn’t need the capability to verify proofs, Sovereign SDK rollups are automatically portable across any L1. Write once, run anywhere.
Where are we now?
We’re currently hard at work developing the Sovereign SDK. Our current roadmap is split into three phases.
Phase 1: Research (In Progress)
The Sovereign SDK is currently undergoing R&D. We’re in the process of designing the default storage module, cryptoeconomics, and core APIs. (If you’re interested in working on these problems, check out our jobs board!). We’re also working on a research prototype. Although the SDK will support a wide range of data availability layers and proving systems, our current prototype integrates Celestia for data availability and Risc0 for proving. We expect this phase to be complete around Q2 2023.
Phase 2: Initial Implementation
The initial implementation of the Sovereign SDK will begin in parallel with the remaining research. During this time, we’ll implement a peer-to-peer network, an RPC node, the core APIs, and default storage and sequencing modules.
Phase 3: Hardening
Once the SDK is feature complete, we’ll need plenty of time for code cleanup, testing, fuzzing, and audits. We’ll also begin developing our first use cases of the SDK during this time (more details on these to be announced!). We expect to see mainnet chains using the SDK after about six months of hardening the initial implementation.
Make scaling simple
At Sovereign Labs, we want to see blockchains support billions of users. That will only happen if zero-knowledge technology is accessible to developers without a PhD in cryptography - and if building rollups is accessible to developers who aren’t expert protocol engineers.
But limitless scalability is worthless if it comes at the expense of the end-user verifiability. If building, running, or viewing the state of your blockchain requires the cooperation of some centralized entity, then we have failed. That’s why the Sovereign SDK will always be completely free and open source - and why we’re committed to engineering every component of the stack for maximum resilience. But don’t just take our word for it. We’re building in public - come see for yourself.
Scaling should be simple. With the Sovereign SDK, it finally will be.
Resources
Acknowledgments
We really appreciate our supporters, especially Tim Beiko, James Prestwich, Mustafa Al-Bassam, Chris Ahn, and Ekram Ahmed, for reviewing drafts of this post, and their guidance along our journey.