Introducing Bedrock: Understanding the First Official Release of the OP Stack

TL;DR

• Optimized batch compression and Ethereum data availability layer reduce transaction fees, making it cost-effective
• Efficient handling of L1 reorgs reduces delays and improves transaction processing
• Modular proof systems promote flexibility and scalability for developers
• Enhanced node performance through the elimination of technical debt
• Provides a compelling and advantageous platform for building applications within the Ethereum ecosystem

The Bedrock release brings forth notable enhancements compared to its predecessor. These improvements include:

Transaction Fee Reduction

To minimize data costs, Bedrock implements an enhanced data compression strategy. Ongoing benchmarking is being conducted to assess the impact of this improvement, but the Optimism team expects a significant reduction in fees due to this optimization.

Furthermore, Bedrock eliminates all L1 execution gas, resulting in a reduction of L1 data fees to the theoretical minimum. This advancement leads to an additional 10% decrease in fees compared to the previous version of the protocol.

Decreased Delays

Bedrock addresses the issue of delayed inclusion of L1 transactions in rollups by efficiently handling L1 reorgs. This improvement results in reduced delays and smoother transaction processing.

In previous versions of the protocol, users had to wait for up to 10 minutes to confirm their deposits. However, with the introduction of Bedrock, we anticipate a remarkable improvement, with deposits expected to confirm within a mere 3 minutes!

This advancement ensures a faster and more efficient deposit confirmation process for users.

Modular Proof Systems

With the introduction of Bedrock, developers can now take advantage of modular proof systems through code reuse.

Bedrock simplifies the utilization of proof systems within the OP Stack by abstracting them. This means that a rollup can utilize different types of proofs, such as fault proofs or validity proofs (like zk-SNARKs), to demonstrate the accurate execution of inputs on the rollup.

Developers are empowered to choose the most suitable proof system for their specific needs, ensuring a more efficient and adaptable development experience.

Enhanced Node Performance

Bedrock significantly enhances the performance of node software by implementing various optimizations.

Firstly, it enables the execution of multiple transactions within a single rollup "block," replacing the previous "one transaction per block" approach. This allows for the amortization of merkle trie updates across multiple transactions, resulting in approximately 15GB/year reduction in state growth at the current transaction volume.

Furthermore, node performance is improved by eliminating technical debt inherited from the previous version of the protocol. This includes:

• removing the need for a separate "data transport layer" node to index L1
• updating the node software to efficiently query transaction data from L1

Bedrock has been designed to closely align with Ethereum, minimizing deviations from its core functionality.

Additionally, Bedrock introduces support for EIP-1559, chain reorgs, and other Ethereum features that are present on L1, further aligning it with the Ethereum ecosystem.

These improvements in Bedrock enhance the overall efficiency, performance, and compatibility of the node software, ensuring a more seamless and optimized experience for users.

Bedrock's design principles prioritize modularity, code reuse, and Ethereum equivalence to provide a flexible and compatible framework for developers in the Ethereum ecosystem.

Modularity

Bedrock is built with a focus on modularity and upgradability. It allows for the swapping of different components in the OP Stack and facilitates the addition of new capabilities through well-defined interfaces and versioning schemes.

This modular design ensures a flexible architecture that can adapt to future developments in the Ethereum ecosystem. Examples of this modularity include the separation of the rollup node and execution client and the use of a modular fault proof design.

Code Reuse

Bedrock maximizes the utilization of existing Ethereum architecture and infrastructure. By leveraging battle-tested codebases used in production on Ethereum Mainnet, the OP Stack inherits the security and reliability benefits associated with them.

Throughout the design of Bedrock, you will find instances of code being reused, such as minimally modified execution clients and the use of EVM contracts instead of precompiled client code.

Ethereum Equivalence

Bedrock is designed to achieve maximum compatibility with the existing Ethereum developer experience. While there are a few exceptions due to the fundamental differences between an L1 and a rollup, such as an altered fee model, faster block time (2 seconds versus 12 seconds), and a special transaction type for including L1 deposit transactions, the overall aim is to provide a seamless transition for Ethereum developers.

Examples of this Ethereum equivalence include:

• the fault-proof design tailored to prove faults of minimally modified Ethereum execution clients
• the code reuse of Ethereum execution clients for nodes in the L2 network and sequencers

By adhering to these design principles, Bedrock ensures modularity, promotes code reuse, and strives to offer an experience that aligns closely with the existing Ethereum ecosystem, facilitating a smooth transition and integration for developers.

For more information about Optimism Bedrock, check out the Optimism Docs.

To stay up to date with all the latest developments in Gelto and in web3, join our developer community on Discord.