# Introducing OP Succinct: Full Validity Proving on the OP Stack

*Upgrade any OP Stack chain to use ZKPs in just 1 hour with SP1*

**Today, we’re excited to showcase how combining SP1—a general-purpose zkVM—with OP Stack, a battle-tested rollup framework, creates a zkEVM rollup that is fast, affordable and highly customizable.**

Historically, zkEVM rollups have been difficult to build, requiring deep cryptography expertise that makes customization and maintainability complicated and time-consuming. Over the past year, zero-knowledge proofs have made tremendous progress, with zkVMs like SP1 leading the charge. SP1 enables any developer to seamlessly __integrate__ ZKPs using standard Rust code, while delivering fast performance required for real-world applications.

Over the past few months, we collaborated closely with the OP Labs team, to combine the OP Stack, a popular, battle-tested rollup framework, and SP1, a blazing fast zkVM, to create __OP Succinct__: a seamless way to **upgrade ANY existing OP Stack chain to use ZKPs in just 1 hour. **With OP Succinct you get:

**Fast finality**secured by ZKPs–proving latency can be on the order of tens of minutes, a dramatic improvement over the 7-day fraud proof window of standard optimistic rollups.**Cost-effective proving**,**Excellent developer experience**for rollup teams with unlimited customization (in Rust) and easy maintainability.

__Reach out today__** if you want a type-1 zkEVM rollup powered by SP1 (as a new rollup or a simple conversation from an existing rollup).**

**Succinct and Optimism are Creating the Future of Rollups**

### A close collaboration with Optimism

OP Succinct was built in close collaboration with OP Labs. From __day 1__, the OP Labs team built the OP Stack to be modular and have a path to supporting a variety of validity mechanisms (not just optimistic fault proofs).

As a part of their open-source initiatives, they recently developed __Kona__: a Rust implementation of the OP Stack rollup state transition function (STF). With Kona and SP1, we were able to write a simple SP1 program (less than 500 lines of code), to generate a zero-knowledge proof (ZKP) of OP Stack’s STF.

### What OP Succinct Provides Today

By fitting this ZKP into OP Stack’s modular architecture, it’s easy to convert an OP Stack rollup to a fully proven ZK rollup with incredible features:

**Easy switch to ZK:**OP Succinct rollups require deploying only*one*smart contract and spinning up a lightweight OP Succinct proposer service that generates proofs via an API call. The rest of your OP Stack chain remains**the exact same**as before, including the batcher/sequencer, op-node, indexers, etc.**Fast finality:**OP Succinct rollups today have a proving latency on the order of minutes with a sufficiently large cluster, a dramatic improvement over the 7 day fraud proof window of optimistic rollups.**Low proving costs, with 5-10x improvements to come:**Today, the average proving cost per transaction is between 0.5-1 cent, thanks to SP1’s market-leading performance in cost and latency for zkEVM rollup use-cases. For context, the 30-day average transaction fee for Base and Optimism is__2 cents and 5.4 cents respectively__. Proving costs are expected to drop by 5-10x by the end of the year with further optimizations to both SP1 and Kona.**EVM equivalent (Type-1):**OP Succinct rollups are EVM equivalent, including full bytecode compatibility and also using the same keccak-based Merkle Patricia Trie (MPT) state root as Ethereum. All tooling and smart contracts that work with OP Stack rollups work with OP Succinct Rollups.**Customizable and Maintainable:**Customizing or upgrading OP Succinct rollups is simple: developers can add new precompiles and modify rollup logic by simply writing Rust and modifying the existing STF. OP Succinct allows teams to have a ZK rollup without compromising on developer experience.**Secure:**OP Succinct rollups reuse most of the battle-tested components of OP Stack and introduce very minimal lines of code in creating a ZKP of the OP STF. By compounding open-source dependencies, like Kona, Revm, etc. that are used in many contexts, OP Succinct rollups make security simple.

**SP1 makes proving EVM rollups fast and cost-effective**

For both OP Sepolia and Base, we’ve run our OP Succinct stack (including proof generation + verification onchain) to showcase the viability of providing full validity proving with SP1. Check out the smart contracts that were updated with ZKPs __here__.

**Proving costs are between 0.5-1 cents per transaction (and will drop 5-10x by the end of the year)**

We calculated the proving costs of our OP Succinct integration on three OP Stack chains. Check out the results below:

*Note*: The average proving cost per transaction is cheaper on Base because the gas usage per transaction on Base is 60% of OP Mainnet and OP Sepolia's gas usage per transaction. Additionally, there is a fixed proving overhead per block that is amortized over a larger set of transactions on Base (Base does 50 TPS vs OP Mainnet's 8 TPS for this block range). OP Mainnet and OP Sepolia have similar gas usage per transaction, but OP Mainnet's costs are higher per transaction because of the frequent presence of BN precompiles, which are underpriced relative to the ZK proving cost they incur.

You can use our__ benchmarking CLI__ tool to compute these numbers on any arbitrary range of blocks for any OP Stack chain (that uses Ethereum for DA). We calculate the proving costs by running the SP1 STF program for a range of blocks (taken from the chain itself), get the RISC-V cycle count for executing the program, and then calculate how much proving time is required on commodity GPU hardware. From this, we compute the amortized proving cost per transaction. You can look at the full breakdown of results __here__.

To contextualize costs, the 30-day average transaction fee for Base and Optimism is __2 cents and 5.4 cents__ respectively. By using OP Succinct, users **only **have to pay an additional half a cent per transaction to get all the benefits of ZK (other onchain costs such as posting calldata/blobs and verifying proofs on Ethereum remain the same between regular OP Stack rollups and OP Succinct rollups). Already, SP1’s fast performance makes the cost of a fully ZK proven OP Stack rollup practical. But, we also estimate that these costs will go down by 5-10x by the end of the year–read more in the section below.

**Fast proof generation allows for fast finality**

OP Succinct rollups have fast finality, with a proof for a range of blocks being submitted onchain every 1 hour currently (the same as OP mainnet, although configurable to be lower by the rollup operator). Factoring in proof generation latency with a sufficiently large cluster and more frequent submissions onchain, OP Succinct rollups can easily have a finality on the order of minutes**.** This allows users to withdraw against this finalized state root as soon as the proof is settled onchain, instead of waiting for 7 days as required by traditional OP stack rollups.

**OP Succinct Proposer Service Architecture: **The proposer service in OP Succinct rollups generates proofs for a range of blocks (instead of single blocks) to amortize __computational overhead__* associated with deriving state from the L1. Proofs for ranges of blocks are generated in parallel, before aggregation and submission onchain as a single ZKP every hour.*

**5-10x performance gains are coming**

Performance metrics present only a *point in time* view of cost and latency. However, it’s important to realize that SP1’s performance is rapidly improving every month. Since February, the cost of proving Ethereum blocks with SP1 has decreased 10x from averaging 1 cents to 0.1 cents per transaction.

Through a combination of SP1 performance improvements and protocol and software optimizations to the OP Stack and Kona program, we expect a 5-10x performance boost to OP Succinct rollups by end of year. Optimizations to SP1 are discussed in our __performance roadmap section__ and include a next-generation recursion system, optimizing our 2 phase prover and better arithmetization of our STARKs.

We have many ideas for optimizing the OP Stack’s protocol and the Kona program itself to make programs easier to prove in SP1 (i.e. less RISC-V cycles), including:

- Adding nonces to OP Stack deposits, removing the need to iterate through all L1 block receipts when performing derivation in the STF
- Maintaining an incremental Merkle tree for all blob commitments onchain when posting new batches of transactions
- Profiling Kona and removing RISC-V cycles from unnecessary memory copies and redundant loops (some recent optimizations cut 30% of the cycles!)

**Upgrade your OP Stack rollup to use ZK proofs in two easy steps**

The modular design of the OP Stack makes converting an OP Stack rollup to an OP Succinct rollup simple. Conversion requires only 2 steps:

**Deploy the ZK L2OutputOracle.sol contract:**Deploy a smart contract that is responsible for verifying proofs of the STF and keeping track of the latest verified state root.**Spin up a OP Succinct Proposer Service:**Run 1 command that spins up a lightweight proposer service that follows the tip of your chain (using your L1 + L2’s RPC) and requests proofs from the__Succinct Prover Network__at a configured cadence.

You can find more detailed instructions __here__ and if you intend to use this in production (or testing), please __reach out__ to us!

The **lack of underlying change to the OP Stack is a game-changer.** We were able to reuse almost all components of the stack, like the sequencer, batcher, op-node, op-geth, etc. Because this integration takes advantage of OP Stack’s modularity and has intentionally minimal surface area (and very few lines of code!), it can neatly integrate into existing deployments,* including ones with rollup-as-a-service teams. *

**Combining the OP Stack, Rust and SP1 for the Ethereum scaling endgame**

Prior to OP Succinct, creating a ZK rollup was very difficult, let alone a __Type-1 zkEVM__ rollup (meaning full EVM compatibility). It is common for most zkEVMs today to not support standard precompiles (like ecpairing) and make tradeoffs with custom data structures for state root computation to be more ZK compatible. But even worse for rollup teams, these zkEVMs require specialized cryptography expertise, making them difficult to customize and maintain.

**OP Succinct solves all of these problems. It combines OP Stack, the open-source Rust ecosystem, and SP1 to offer a type-1 zkEVM with the best of all worlds: fast-finality, cheap costs and a great developer experience.**

The __endgame__ of Ethereum scaling is that every rollup is a ZK rollup. In this world, users will no longer have to wait 7 days to withdraw funds from a rollup, they will have seamless interoperability across ecosystems, and capital efficiency and verifiability will dramatically improve. With OP Succinct rollups, we have all of these benefits, with a sleek developer experience for rollup teams that allows for customization and maintainability.

With OP Succinct rollups, we can have it all.

**Use OP Succinct Today**

Thinking about deploying an OP Succinct rollup or converting your existing rollup to one? Please reach out to us __here__. If you fit any of the following, we would love to chat with you:

**Team exploring new rollup options:**If your team is exploring deploying a rollup and wants to learn more about OP Succinct rollups as an option.**RaaS teams:**If you’re a RaaS team and you want to offer OP Succinct rollups as part of your platform (deployment should be very easy)!**Existing rollup team:**If your team currently has a rollup and wants to migrate it from optimistic to ZK or generally explore migrating to OP Succinct rollups.

**Code: **Our code is fully open-source with an MIT license: check out __OP Succinct here__ and __SP1 here__.

**Contribute to SP1:** If you’re interested in contributing to SP1 itself, check out the list of __open issues__ in the Github repository!

**Acknowledgements**

OP Succinct leverages significant high-quality, open-source work in the Ethereum and Optimism ecosystem, most importantly OP Stack and Kona. We would not have been able to build this without the great work of the OP Labs team, who had the foresight to architect their code as modular and open-source from day 1. We’d also like to specifically thank __Clabby__ and __Refcell__ on the OP team, who created Kona and who we collaborated with closely as we built out this integration. They patiently answered all of our questions and upstreamed a few of our PRs. We want to shout-out __Mark Tyneway__, __Dragan__ from Revm, and all the members of the Reth team who also helped with this collaboration.

Finally, we want to acknowledge __Zach Obront__, who worked closely with us for the past few months and spearheaded this integration alongside other members of the Succinct team.