Rust framework from Sovereign Labs for building zk-rollups whose canonical chain is defined entirely by data on a DA layer (Celestia / Avail / EigenDA), with pluggable STF, native account abstraction, and real-time proving.
- 01sovereign zk-rollups
- 02DA-defined canonical chains
- 03Rust-based custom STFs
- 04rollups with native AA
- 05Celestia / Avail / EigenDA-anchored rollups
- cargo install --git https://github.com/Sovereign-Labs/sovereign-sdk sov-cli
| Variable | Scope | Description |
|---|---|---|
| SOVEREIGN_DA_ENDPOINT | Server | RPC endpoint of the configured DA layer node (e.g. celestia-node or Avail RPC). |
| SOVEREIGN_DA_NAMESPACE | Client | Namespace / app-id reserved for your sovereign rollup on the DA layer. |
| SOVEREIGN_PROVER_URL | Server | URL of the prover service that produces zk-proofs over your STF. |
Use Sovereign SDK to build a sovereign zk-rollup in Rust. Define the state-transition function (STF) using the runtime macros, pick a DA adapter (Celestia, Avail, or EigenDA), and wire the prover (RISC Zero or SP1) to produce validity proofs over each batch. The rollup's canonical chain is the deterministic execution of all blobs in your namespace on the DA layer — there is no separate consensus or settlement contract. Run a full node to serve queries, a sequencer/batcher to post blobs, and a prover for real-time proofs; ship light-client verification to clients that need trust-minimized state.
- ⚑Sovereign rollups have no settlement contract or fork-choice signal beyond the DA layer — reorgs on the DA layer fork the rollup, so design around DA finality (Celestia ~12s, Avail ~20s).
- ⚑DA inclusion latency directly bounds rollup soft-finality and proof-emission cadence; plan UX around the chosen DA layer.
- ⚑Sequencer/batcher trust assumptions are entirely your design — there is no shared sequencer by default; pair with Espresso/Astria if you need credible neutrality.
- ⚑Gas/DA fees are paid in the DA layer's token (TIA, AVAIL, or EigenDA fee model) — keep batcher wallets funded in the right asset.
- ⚑Bridging out is non-trivial: sovereign rollups don't natively settle to Ethereum, so withdrawals require an external light-client bridge (e.g. Blobstream + a verifier contract) plus your zk-proof.
- ⚑STF and DA adapter changes are hard forks — version your namespace and coordinate node upgrades, since DA replay against the new STF defines the new chain.
- ⚑The SDK is Rust-only and pre-1.0 — APIs and proving backends still evolve; pin commits and budget for upgrade work.