Architecture

Liberty Chain is an Optimistic Rollup built on the OP Stack. It executes transactions on Layer 2 for speed and low cost, while posting all transaction data to Ethereum Layer 1 for security and finality. This page explains how the major components work together.

How Liberty Chain Works

At a high level, Liberty Chain processes transactions off-chain on its own execution layer, then periodically commits batches of transaction data to Ethereum. This architecture gives users fast, cheap transactions while inheriting the full security guarantees of Ethereum L1.

The system is composed of four key components that work together to produce blocks, commit data, and ensure correctness.

Core Components

Sequencer

The Sequencer is the component responsible for ordering transactions and producing L2 blocks. When you submit a transaction to Liberty Chain, the Sequencer receives it, includes it in the next block, and executes it against the current state. Blocks are produced every 2 seconds, giving users near-instant soft confirmations.

The Sequencer provides immediate transaction receipts and state updates, but these are considered "unsafe" until the transaction data is posted to L1. For most user-facing applications, soft confirmations from the Sequencer are sufficient.

Batcher

The Batcher takes batches of L2 transactions and posts them to Ethereum L1. This is the data availability step — by writing all transaction data to L1, anyone can independently reconstruct the L2 state without trusting the Sequencer. The Batcher compresses transaction data and submits it as calldata or EIP-4844 blobs to minimize L1 gas costs.

Once transaction data is posted to L1, the corresponding L2 blocks are considered "safe" because the data needed to verify them is now permanently available on Ethereum.

Proposer

The Proposer periodically submits output roots (state commitments) to an L1 contract. An output root is a cryptographic commitment to the full L2 state at a specific block height. These commitments are what allow withdrawals from L2 to L1, because the L1 bridge contract can verify that a withdrawal was included in a valid L2 state.

Challenger (Fault Proofs)

The Challenger monitors the output roots submitted by the Proposer and can dispute any incorrect state commitments through the fault proof system. If a Proposer submits an invalid output root, the Challenger initiates a dispute game on L1 that ultimately proves which state is correct by re-executing the disputed transactions on-chain.

This is the "optimistic" part of Optimistic Rollup — output roots are assumed correct unless challenged. There is a challenge window (typically 7 days) during which disputes can be raised. After the challenge window passes without a successful dispute, the output root is considered finalized.

Transaction Lifecycle

A transaction on Liberty Chain goes through the following stages from submission to finalization:

Security Model

Liberty Chain inherits its security from Ethereum through two mechanisms:

• Data availability — all transaction data is posted to Ethereum L1, so the L2 state can always be independently reconstructed even if the Sequencer goes offline. No data is kept off-chain.
• Fault proofs — any invalid state transition can be challenged and proven incorrect on L1 through the fault proof system. This means a single honest verifier can prevent invalid state from being finalized.

Together, these properties mean that the correctness of Liberty Chain does not depend on trusting the Sequencer or Proposer. As long as the transaction data is on L1 and the fault proof system is available, the chain's state can be verified by anyone.

Confirmation Levels

Because of the rollup architecture, transactions on Liberty Chain have multiple levels of confirmation:

For further details on fees and gas mechanics, see Transaction Fees. For system contract addresses and network endpoints, see Network Details.